Start of contrib/ cleanup

README

@@ -30,9 +30,11 @@ Emacs Lisp space.
 
 Here are some other Pymacs resources:
 
-+ This README file (you are likely visiting it right now):
++ This README file (you are reading it right now), and also the README
+  file of the :file:`contrib/` directory of the Pymacs distribution:
 
   + http://pymacs.progiciels-bpi.ca
+  + http://pymacs.progiciels-bpi.ca/contrib.html
 
 + The Pymacs manual, both in PDF and in HTML formats:
 

contrib/README

@@ -0,0 +1,34 @@
+============================
+Contents of Pymacs' contrib/
+============================
+
+  **This file is under construction.**
+
+.. contents::
+.. sectnum::
+
+
+misc-jj
+=======
+
+This directory contains miscellaneous files contributed by Giovanni
+Giorgi, most of them waiting to be sorted, documented or deleted, or at
+least pondered in one way or another.
+
+python-mode.diffs
+-----------------
+
+These diffs are relative to :file:`python-mode-1.0.tar.gz` as found at:
+
+  http://sourceforge.net/projects/python-mode/
+
+nn
+==
+
+This is a helper tool for handling ephemeral email groups under Gnus.
+
+rebox
+=====
+
+This tool helps the programmer at maintaining boxes around comments,
+while refilling them, for many styles and programming languages.

contrib/misc-jj/README

@@ -1,3 +1,16 @@
 Version 2.0 bought to you by Giovanni Giorgi
 Dev co:
 svn co http://adam/repos/ugis/dev/pymacs pymacs-2.0
+
+For loading the demo, look at testrun.el
+
+This is an extension found at
+
+  http://timchen119.blogspot.com/2007/02/bash-like-tab-completion-in-emacs.html
+
+See also
+
+ http://my.opera.com/liuyuan/blog/2006/11/10/hack-emacs-s-pycomplete-py
+ http://wiki.python.org/moin/EmacsPythonCompletion
+
+This version has been hacked by Giovanni Giorgi and heavily tested.

contrib/misc-jj/python-mode.diffs

@@ -0,0 +1,263 @@
+diff -ur python-mode-1.0/pycomplete.el python-mode-1.0+/pycomplete.el
+--- python-mode-1.0/pycomplete.el	2005-12-02 11:30:11.000000000 -0500
++++ python-mode-1.0+/pycomplete.el	2008-02-01 22:22:01.000000000 -0500
+@@ -1,36 +1,45 @@
+ ;;; Complete symbols at point using Pymacs.
+-
+ ;;; See pycomplete.py for the Python side of things and a short description
+ ;;; of what to expect.
+
+ (require 'pymacs)
+ (require 'python-mode)
+
+-(pymacs-load "pycomplete")
++(pymacs-load "/home/jj/Projects/pymacs-2.0/extensions.pycomplete")
++
++;;check if prev character is blank-type
++(defun char-before-blank ()
++  (save-excursion
++  (forward-char -1)
++  (looking-at "[\n\t\r]")))
+
+ (defun py-complete ()
+   (interactive)
+-  (let ((pymacs-forget-mutability t)) 
+-    (insert (pycomplete-pycomplete (py-symbol-near-point)
+-				   (py-find-global-imports)))))
++  (let ((pymacs-forget-mutability t))
++    (if (and 
++         (and (eolp) (not (bolp)) 
++         (not (char-before-blank))))
++      (insert (pycomplete-pycomplete (py-symbol-near-point) (py-find-global-imports)))
++      (indent-for-tab-command))))
+
+ (defun py-find-global-imports ()
+   (save-excursion
+     (let (first-class-or-def imports)
+       (goto-char (point-min))
+       (setq first-class-or-def
+-	    (re-search-forward "^ *\\(def\\|class\\) " nil t))
++        (re-search-forward "^ *\\(def\\|class\\) " nil t))
+       (goto-char (point-min))
+       (setq imports nil)
+       (while (re-search-forward
+-	      "^\\(import \\|from \\([A-Za-z_][A-Za-z_0-9]*\\) import \\).*"
+-	      nil t)
+-	(setq imports (append imports
+-			      (list (buffer-substring
+-				     (match-beginning 0)
+-				     (match-end 0))))))
++          "\\(import \\|from \\([A-Za-z_][A-Za-z_0-9\\.]*\\) import \\).*"
++          nil t)
++    (setq imports (append imports
++                  (list (buffer-substring
++                     (match-beginning 0) 
++                     (match-end 0))))))  
+       imports)))
+
+-(define-key py-mode-map "\M-\C-i"  'py-complete)
++(define-key py-mode-map "\M-\C-i" 'py-complete)
++(define-key py-mode-map "\t" 'py-complete)
+
+ (provide 'pycomplete)
+diff -ur python-mode-1.0/pycomplete.py python-mode-1.0+/pycomplete.py
+--- python-mode-1.0/pycomplete.py	2005-12-02 11:30:11.000000000 -0500
++++ python-mode-1.0+/pycomplete.py	2008-02-01 22:22:01.000000000 -0500
+@@ -1,4 +1,3 @@
+-
+ """
+ Python dot expression completion using Pymacs.
+
+@@ -6,23 +5,25 @@
+
+     (require 'pycomplete)
+
+-to your .xemacs/init.el file (untried w/ GNU Emacs so far) and have Pymacs
+-installed, when you hit M-TAB it will try to complete the dot expression
++to your .xemacs/init.el file (.emacs for GNU Emacs) and have Pymacs
++installed, when you hit TAB it will try to complete the dot expression
+ before point.  For example, given this import at the top of the file:
+
+     import time
+
+-typing "time.cl" then hitting M-TAB should complete "time.clock".
+-
+-This is unlikely to be done the way Emacs completion ought to be done, but
+-it's a start.  Perhaps someone with more Emacs mojo can take this stuff and
+-do it right.
++typing "time.cl" then hitting TAB should complete "time.clock".
+
+ See pycomplete.el for the Emacs Lisp side of things.
+ """
+-
+ import sys
+ import os.path
++import string 
++from Pymacs import lisp
++
++
++sys.path.append(".")
++
++ENABLE_GG_FUZZY_GUESS=True
+
+ try:
+     x = set
+@@ -43,8 +44,9 @@
+                 exec stmt in globals(), locald
+             except TypeError:
+                 raise TypeError, "invalid type: %s" % stmt
+-
+-    dots = s.split(".")
++            except:
++                continue
++    dots = s.split(".") 
+     if not s or len(dots) == 1:
+         keys = set()
+         keys.update(locald.keys())
+@@ -60,7 +62,7 @@
+
+     sym = None
+     for i in range(1, len(dots)):
+-        s = ".".join(dots[:i])
++        s = ".".join(dots[:i])   
+         try:
+             sym = eval(s, globals(), locald)
+         except NameError:
+@@ -68,22 +70,98 @@
+                 sym = __import__(s, globals(), locald, [])
+             except ImportError:
+                 return []
+-    if sym is not None:
+-        s = dots[-1]
++    if sym is not None:  
++        s = dots[-1]     
+         return [k for k in dir(sym) if k.startswith(s)]
+
++def get_keyword_completition(s):
++    # Reserved keywords for Python 2.5 
++    keywords=""" and       del       from      not       while    
++as        elif      global    or        with     
++assert    else      if        pass      yield    
++break     except    import    print              
++class     exec      in        raise              
++continue  finally   is        return             
++def       for       lambda    try
++"""
++    kl=keywords.split()
++    
++    return [ k+" " for k in kl if k.startswith(s)]
++
++def get_common_fuzzy_completition(s):
++    result=[]
++    # Then we add  some *common* words 
++    commonFuzzyWords=""" self. """    
++    kl=commonFuzzyWords.split()
++    result=[ k for k in kl if k.startswith(s)]
++    if len(result)==0:
++        dottedparts=s.split(".")
++        if(len(dottedparts)>=2):
++            mx=dottedparts[1]
++            # This is a very tiny list of stuff
++            kl=""" remove( append(  join(""".split()
++            lisp.message("Hyper fuzzy extracted method:"+mx+" List:"+str(kl))
++            result=[ k for k in kl if k.startswith(mx)]
++    return result
++
++
+ def pycomplete(s, imports=None):
+     completions = get_all_completions(s, imports)
++    
++    
++    # [GG] Extension1:
++    if ENABLE_GG_FUZZY_GUESS : # and len(completions)==0:
++        #lisp.message("Trying to complete using a fuzzy guess for:"+s)
++        k2=get_keyword_completition(s)
++        k3=get_common_fuzzy_completition(s)
++        # Integrate the fuzzy guess with other completitions
++        for k in k2:
++            completions.append(k)
++        for k in k3:
++            completions.append(k)
++            
++    lisp.message("DEBUG completions="+str(completions))
+     dots = s.split(".")
+-    return os.path.commonprefix([k[len(dots[-1]):] for k in completions])
++    result = os.path.commonprefix([k[len(dots[-1]):] for k in completions])
+
+-if __name__ == "__main__":
+-    print "<empty> ->", pycomplete("")
++
++    if result == "":
++        if completions:
++            width = lisp.window_width() - 2
++            colum = width / 20
++            white = "                    "
++            
++            msg = ""
++
++            counter = 0
++            for completion in completions :
++                if completion.__len__() < 20 :
++                    msg += completion + white[completion.__len__():]
++                    counter += 1
++                else :
++                    msg += completion + white[completion.__len__() - 20:]
++                    counter += 2
++
++                if counter >= colum :
++                    counter = 0
++                    msg += '\n'
++
++        else:
++            msg = "no completions for:"+s
++
++            
++        lisp.message(msg)
++    return  result       
++
++
++
++def testPycomplete():
++    print " ->", pycomplete("")
+     print "sys.get ->", pycomplete("sys.get")
+     print "sy ->", pycomplete("sy")
+     print "sy (sys in context) ->", pycomplete("sy", imports=["import sys"])
+     print "foo. ->", pycomplete("foo.")
+-    print "Enc (email * imported) ->",
++    print "Enc (email * imported) ->", 
+     print pycomplete("Enc", imports=["from email import *"])
+     print "E (email * imported) ->",
+     print pycomplete("E", imports=["from email import *"])
+@@ -91,6 +169,32 @@
+     print "Enc ->", pycomplete("Enc")
+     print "E ->", pycomplete("E")
+
++
++def test():
++    from Pymacs import lisp,utility
++    log=utility.log
++    
++    lisp.switch_to_buffer("*Messages*")
++    log.info("Testing PyComplete extension... (GG)")
++    log.info(" ->" + str(pycomplete("")))
++    log.info("sys.get ->" + str(pycomplete("sys.get")))
++    log.info("sy ->" + str(pycomplete("sy")))
++    log.info("sy (sys in context) ->" + str(pycomplete("sy", imports=["import sys"])))
++    log.info("foo. ->" + str(pycomplete("foo.")))
++    log.info("Enc (email * imported) ->" + 
++             str(pycomplete("Enc" , imports=["from email import *"])))
++    log.info("E (email * imported) ->"+ str(pycomplete("E"  ,imports=["from email import *"])))
++
++    log.info("Enc ->" + str(pycomplete("Enc")))
++    log.info("E ->" + str(pycomplete("E")))
++    log.info(" Test finished")
++
++# Publish it:
++interactions = {}
++interactions[test]=''
++
++if __name__ == "__main__":
++    testPycomplete()
+ # Local Variables :
+ # pymacs-auto-reload : t
+ # End :