##############################################################################
#
# Copyright (c) 2001 Zope Corporation and Contributors. All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
# FOR A PARTICULAR PURPOSE
#
##############################################################################
"""Help system support module"""

__version__='$Revision: 1.12 $'[11:-2]


import Globals, Acquisition
import StructuredText.StructuredText
import sys, os,  re


stx_class=StructuredText.StructuredText.HTML


class HelpBase(Acquisition.Implicit):
    """ """
    def __bobo_traverse__(self, REQUEST, name=None):
        # A sneaky trick - we cant really _have_ an index_html
        # because that would often hide the index_html of a
        # wrapped object ;(
        if name=='index_html':
            return self.hs_index
        return getattr(self, name)

    def __len__(self):
        return 1


class object(Acquisition.Implicit):
    def __init__(self, name, ob, op=None):
        self._name=name
        self._obj_=ob
        self._obp_=op

    def __getattr__(self, name):
        return getattr(self.__dict__['_obj_'], name)

    def __len__(self):
        return 1

    def get_id(self):
        return id(self._obj_)

    def get_name(self):
        return self._name

    def get_type(self):
        return type(self._obj_).__name__

    def get_value(self):
        return self._obj_

    def get_docstring(self):
        if hasattr(self._obj_, '__doc__'):
            doc=self._obj_.__doc__
            if not doc: doc=''
            return doc
        return ''

    def get_docstring_html(self):
        doc=self.get_docstring()
        if doc.find('\n\n') > -1:
            doc=doc.split('\n\n')
            if len(doc) > 1:
                doc[1]=doc[1].strip()
            doc='\n\n'.join(doc)

        return str(stx_class(doc))

    def version(self):
        if hasattr(self._obj_, '__version__'):
            return self._obj_.__version__

    tpId   =get_name
    tpURL  =get_name
    __str__=get_name


class moduleobject(object):
    def get_file(self):
        if hasattr(self._obj_, '__file__'):
            return self._obj_.__file__

    def get_modules(self):
        data=[]
        for name, ob in self._obj_.__dict__.items():
            if is_module(ob) and _chModule(name, ob):
                data.append(moduleobject(name, ob, self))
        return data

    def get_classes(self):
        data=[]
        for name, ob in self._obj_.__dict__.items():
            if is_class(ob) and _chClass(name, ob):
                data.append(classobject(name, ob, self))
        return data


class classobject(object):
    def get_metatype(self):
        try: return self._obj_.meta_type
        except:
            t, v = sys.exc_info()[:2]
            return '%s %s' % (t, v)

    def get_module(self):
        if hasattr(self._obj_, '__module__'):
            module=sys.modules[self._obj_.__module__]
            return moduleobject(module.__name__, module)

    def get_file(self):
        return self.get_module().get_file()

    def get_bases(self):
        bases=[]
        if hasattr(self._obj_, '__bases__'):
            for base in self._obj_.__bases__:
                bases.append(classobject(base.__name__, base))
        return bases

    def get_base_list(self, list=None):
        if list is None: list=[]
        list.append(self)
        for base in self.get_bases():
            list=base.get_base_list(list)
        return list

    def get_methods(self):
        keys=self._obj_.__dict__.keys()
        dict=self._obj_.__dict__
        keys.sort()
        methods=[]
        for name in keys:
            ob=dict[name]
            if is_method(ob) and _chMethod(name, ob):
                methods.append(methodobject(name, ob, self))
        return methods

    def get_method_dict(self, dict=None):
        if dict is None:
            dict={}
        dup=dict.has_key
        for method in self.get_methods():
            name=method.get_name()
            if not dup(name):
                dict[name]=method
        for base in self.get_bases():
            dict=base.get_method_dict(dict)
        return dict

    def get_method_list(self):
        dict=self.get_method_dict()
        keys=dict.keys()
        keys.sort()
        list=[]
        for key in keys:
            list.append(dict[key])
        del dict
        return list

##     def obAttributes(self):
##         # Return list of class attributes
##         keys=self._obj_.__dict__.keys()
##         dict=self._obj_.__dict__
##         keys.sort()
##         attrs=[]
##         for name in keys:
##             ob=dict[name]
##             if _isAttribute(ob) and _chAttribute(name, ob):
##                 attrs.append(AttributeObject(name, ob, self))
##         return attrs

##     def obAttributeDict(self, dict=None):
##         # Return dict of attrs in class and superclasses
##         if dict is None:
##             dict={}
##             root=1
##         else: root=0
##         dup=dict.has_key
##         for attr in self._obj_Attributes():
##             name=attr.obName()
##             if not dup(name):
##                 dict[name]=attr
##         for base in self._obj_Bases():
##             dict=base.obAttributeDict(dict)
##         return dict

##     def obAttributeList(self):
##         # Return list of attrs in class and superclasses
##         dict=self._obj_AttributeDict()
##         keys=dict.keys()
##         keys.sort()
##         list=[]
##         append=list.append
##         for name in keys:
##             append(dict[name])
##             del dict
##         return list



# needs to be tested !!! The conversion of reconvert.convert looks suspicious
sig_match=re.compile(r'[\w]*\([^)]*\)').match # matches "f(arg1, arg2)"
pre_match=re.compile(r'[\w]*\([^)]*\)[ -]*').match # with ' ' or '-' included

class methodobject(object):

    def get_class(self):
        return self._obp_

    def get_module(self):
        return self.get_class().get_module()

    def get_file(self):
        return self.get_module().get_file()

    def get_docstring(self):
        func=self._obj_
        doc=''
        if hasattr(func, 'im_func'):
            func=func.im_func
        if hasattr(func, '__doc__'):
            doc=func.__doc__
            if not doc: doc=''
            doc=doc.strip()
        if hasattr(func, 'func_code'):
            if hasattr(func.func_code, 'co_varnames'):
                return doc
        mo=pre_match(doc)
        if mo is not None:
            return doc[mo.end(0):]
        return doc

    def get_signaturex(self):
        name=self._name
        func=self._obj_
        method=None

        if hasattr(func, 'im_func'):
            method=1
            func=func.im_func

        # Normal functions
        if hasattr(func, 'func_code'):
            if hasattr(func.func_code, 'co_varnames'):
                args=map(lambda x: x,
                     func.func_code.co_varnames[:func.func_code.co_argcount])
                ndefaults=func.func_defaults
                ndefaults=ndefaults and len(ndefaults) or 0
                if '__ick__' in args:
                    nick=len(args)-args.index('__ick__')
                    args=args[:-nick]
                    ndefaults=ndefaults-nick
                if ndefaults > 0:
                    args[-ndefaults]='['+args[-ndefaults]
                    args[-1]=args[-1]+']'
                if method: args=args[1:]
                if name=='__call__':
                    name='Call Operation'
                return '%s(%s)' % (name, ', '.join(args))

        # Other functions - look for something that smells like
        # a signature at the beginning of the docstring.
        if hasattr(func, '__doc__'):
            doc=func.__doc__
            if not doc: doc=''
            doc=doc.strip()
            mo=sig_match(doc)
            if mo is not None:
                return doc[:mo.end(0)]
        return '%s()' % name


    def get_signature(self):
        try: return self.get_signaturex()
        except:
            t, v = sys.exc_info()[:2]
            return '%s %s' % (t, v)


## class AttributeObject(_ob_):
##     def obClass(self):
##         return self.op

##     def obModule(self):
##         return self.obClass().obModule()

##     def obFile(self):
##         return self.obModule().obFile()

## class InstanceObject(_ob_):
##     def obClass(self):
##         # Return the class for this instance
##         c=self._obj_.__class__
##         return ClassObject(c.__name__, c)

##     def obClassList(self):
##         # Return list of all superclasses
##         return self._obj_Class().obClassList()

##     def obMethods(self):
##         # Return list of instance methods
##         keys=self._obj_.__dict__.keys()
##         dict=self._obj_.__dict__
##         keys.sort()
##         methods=[]
##         for name in keys:
##             ob=dict[name]
##             if _isMethod(ob) and _chMethod(name, ob):
##                methods.append(MethodObject(name, ob))
##         return methods

##     def obMethodDict(self):
##         # Return dict of instance and superclass methods
##         dict=self._obj_Class().obMethodDict()
##         for method in self._obj_Methods():
##             dict[method.obName()]=method
##         return dict

##     def obMethodList(self):
##         # Return list of instance and superclass methods
##         dict=self._obj_MethodDict()
##         keys=dict.keys()
##         keys.sort()
##         list=[]
##         append=list.append
##         for name in keys:
##             append(dict[name])
##         return list

##     def obAttributes(self):
##         # Return list of instance attributes
##         keys=self._obj_.__dict__.keys()
##         dict=self._obj_.__dict__
##         keys.sort()
##         attrs=[]
##         for name in keys:
##             ob=dict[name]
##             if _isAttribute(ob) and _chAttribute(name, ob):
##                 attrs.append(AttributeObject(name, ob, self))
##         return attrs

##     def obAttributeDict(self):
##         # Return dict of instance and superclass attributes
##         dict=self._obj_Class().obAttributeDict()
##         for attr in self._obj_Attributes():
##             dict[attr.obName()]=attr
##         return dict

##     def obAttributeList(self):
##         # Return list of instance and superclass attributes
##         dict=self._obj_AttributeDict()
##         keys=dict.keys()
##         keys.sort()
##         list=[]
##         append=list.append
##         for name in keys:
##             append(dict[name])
##         return list




_classtypes=(type(Globals.HTML),
             type(Globals.Persistent),
            )

_methodtypes=(type([].sort),
              type(Globals.default__class_init__),
              type(Globals.HTML.manage_edit),
              type(Globals.HTML.__changed__),
              type(Globals.MessageDialog.manage_edit),
             )

def is_module(ob):
    return type(ob)==type(sys)

def is_class(ob):
    return type(ob) in _classtypes

def is_method(ob):
    if type(ob) in _methodtypes or hasattr(ob, 'func_code'):
        return 1
    return 0

def is_attribute(ob):
    return not is_method(ob)



def _chModule(name, ob):
    if name[0]=='_':
        return 0
    return 1

def _chClass(name, ob):
    if name[0]=='_':
        return 0
    return 1

def _chMethod(name, ob):
    if name[0]=='_':
        return 0
    return 1

def _chAttribute(name, ob):
    if name[0]=='_':
        return 0
    return 1
