1 files changed, 255 insertions, 0 deletions
diff --git a/www/dev_guide/inheritanceEtc.rst b/www/dev_guide/inheritanceEtc.rst
new file mode 100644
index 0000000..7dbed40
--- /dev/null
+++ b/www/dev_guide/inheritanceEtc.rst
@@ -0,0 +1,255 @@
+Directives: Import, Inheritance, Declaration and Assignment
+===========================================================
+
+(inheritanceEtc)
+
+#import and #from
+-----------------
+
+(inheritanceEtc.import)
+
+The template:
+
+::
+
+    #import math
+
+This construct does not produce any output.
+
+The generated module, at the bottom of the import section:
+
+::
+
+    import math
+
+#extends
+--------
+
+(inheritanceEtc.extends)
+
+The template:
+
+::
+
+    #extends SomeClass
+
+The generated import (skipped if {SomeClass} has already been
+imported):
+
+::
+
+    from SomeClass import SomeClass
+
+The generated class:
+
+::
+
+    class x(SomeClass):
+
+#implements
+-----------
+
+(inheritanceEtc.implements)
+
+The template:
+
+::
+
+    #implements doOutput
+
+In the generated class, the main method is {.doOutput} instead of
+{.respond}, and the attribute naming this method is:
+
+::
+
+    _mainCheetahMethod_for_x2= 'doOutput'
+
+#set and #set global
+--------------------
+
+(inheritanceEtc.set)
+
+The template:
+
+::
+
+    #set $namesList = ['Moe','Larry','Curly']
+    $namesList
+    #set global $toes = ['eeny', 'meeny', 'miney', 'moe']
+    $toes
+
+The output:
+
+::
+
+    ['Moe', 'Larry', 'Curly']
+    ['eeny', 'meeny', 'miney', 'moe']
+
+The generated code:
+
+::
+
+    1  namesList = ['Moe','Larry','Curly']
+    2  write(filter(namesList)) # generated from '$namesList' at line 2, col 1.
+    3  write('\n')
+    4  globalSetVars["toes"] = ['eeny', 'meeny', 'miney', 'moe']
+    5  write(filter(VFS(SL,"toes",1))) # generated from '$toes' at line 4, col 1.
+    6  write('\n')
+
+{globalSetVars} is a local variable referencing {.\_globalSetVars}.
+Writes go into it directly, but reads take advantage of the fact
+that {.\_globalSetVars} is on the searchList. (In fact, it's the
+very first namespace.)
+
+#del
+----
+
+(inheritanceEtc.del)
+
+The template:
+
+::
+
+    #set $a = 1
+    #del $a
+    #set $a = 2
+    #set $arr = [0, 1, 2]
+    #del $a, $arr[1]
+
+In the generated class:
+
+::
+
+    1  a = 1
+    2  del a
+    3  a = 2
+    4  arr = [0, 1, 2]
+    5  del a, arr[1]
+
+#attr
+-----
+
+(inheritanceEtc.attr)
+
+The template:
+
+::
+
+    #attr $namesList = ['Moe', 'Larry', 'Curly']
+
+In the generated class:
+
+::
+
+    ## GENERATED ATTRIBUTES
+    
+    namesList = ['Moe', 'Larry', 'Curly']
+
+#def
+----
+
+(inheritanceEtc.def)
+
+The template:
+
+::
+
+    #def printArg($arg)
+    The argument is $arg.
+    #end def
+    My method returned $printArg(5).
+
+The output:
+
+::
+
+    My method returned The argument is 5.
+    .
+
+Hmm, not exactly what we expected. The method returns a trailing
+newline because we didn't end the last line with {#slurp}. So the
+second period (outside the method) appears on a separate line.
+
+The {#def} generates a method {.printArg} whose structure is
+similar to the main method:
+
+::
+
+    def printArg(self,
+            arg,
+            trans=None,
+            dummyTrans=False,
+            VFS=valueFromSearchList,
+            VFN=valueForName,
+            getmtime=getmtime,
+            currentTime=time.time):
+    
+    
+        """
+        Generated from #def printArg($arg) at line 1, col 1.
+        """
+    
+        if not trans:
+            trans = DummyTransaction()
+            dummyTrans = True
+        write = trans.response().write
+        SL = self._searchList
+        filter = self._currentFilter
+        globalSetVars = self._globalSetVars
+        
+        ########################################
+        ## START - generated method body
+        
+        write('The argument is ')
+        write(filter(arg)) # generated from '$arg' at line 2, col 17.
+        write('.\n')
+        
+        ########################################
+        ## END - generated method body
+        
+        if dummyTrans:
+            return trans.response().getvalue()
+        else:
+            return ""
+
+When {.printArg} is called from a placeholder, only the arguments
+the user supplied are passed. The other arguments retain their
+default values.
+
+#block
+------
+
+(inheritanceEtc.block)
+
+The template:
+
+::
+
+    #block content
+    This page is under construction.
+    #end block
+
+The output:
+
+::
+
+    This page is under construction.
+
+This construct generates a method {.content} in the same structure
+as {.printArg} above, containing the write code:
+
+::
+
+    write('This page is under construction.\n')
+
+In the main method, the write code is:
+
+::
+
+    self.content(trans=trans) # generated from ('content', '#block content')
+        # at line 1, col 1.
+
+So a block placeholder implicitly passes the current transaction to
+the method.
+
+