You can download my version of the pycheckers.py script and you must put it on path available from the PATH environment variable scope. You must be sure that Emacs finds the pycheckers.py command in your PATH.

;;; load the python mode.
(autoload 'python-mode
          "python-mode"
          "Mode for editing Python source files")

;;; autoload the python-mode on each opened python file.
(setq auto-mode-alist
		(append '(("\\.py" . python-mode)) auto-mode-alist)))

;;; we ensure that we will use the font-lock mode
;;; on Python files.
(setq font-lock-auto-mode-list
      (list 'python-mode))

;;; finally we create the python mode hook function.
(defun dmw-python-mode-hook ()
  (setq py-indent-offset 4
        py-smart-indentation nil
        py-continuation-offset 4
        indent-tabs-mode nil
        py-pychecker-command "pycheckers"
        py-pychecker-command-args (quote ("")))
  (setq interpreter-mode-alist(cons '("python" . python-mode)
                                    interpreter-mode-alist))
  (eldoc-mode 1)
  (define-key py-mode-map "\C-c\C-w" (lambda ()
                                      (interactive)
                                      (command-execute
                                       'py-pychecker-run)))
  (message ">>> done dmw-python-mode-hook..."))

;;; then we add the hook function.
(add-hook 'python-mode-hook 'dmw-python-mode-hook)

I hope that you will enjoy checking your code. You just need to install pep8, pylint, pychecker and pyflakes.

Copyright © 2011 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2011. | Permalink | No comment
Post tags:

The first one is batch-kill-buffer-equal-named, which can kill various unmodified buffers at once. You just need to place your current buffer to the buffer that has the name that you want to kill, and apply that command.

(require 'cl)

(defun batch-kill-buffer-equal-named ()
  (interactive)
  (let ((cbn (file-name-nondirectory
              (buffer-file-name
               (current-buffer)))))
    (let ((eqn-nm (lambda (x)
                    (and (not (eq (buffer-file-name x) nil))
                         (and (string= (file-name-nondirectory
                                        (buffer-file-name x))
                                       cbn)
                              (not (buffer-modified-p x))))))
          (tmp-buffer-list (copy-tree (buffer-list))))
      (dolist (cb (remove-if-not eqn-nm tmp-buffer-list))
        (kill-buffer cb)))))

The command above uses the standard Emacs Lisp functions, also some Emacs CL (Common Lisp) functions to make some tasks easier. So, you need to use the cl package. The other command, applies the same logic, but instead of asking for buffer modifications, it saves the visited buffer and then kills it.

(defun batch-kill-buffer-save-equal-named ()
  (interactive)
  (let ((cbn (file-name-nondirectory
              (buffer-file-name
               (current-buffer)))))
    (let ((eqn-nm (lambda (x)
                    (and (not (eq (buffer-file-name x) nil))
                         (and (string= (file-name-nondirectory
                                        (buffer-file-name x))
                                       cbn)))))
          (tmp-buffer-list (copy-tree (buffer-list))))
      (dolist (cb (remove-if-not eqn-nm tmp-buffer-list))
        (progn (save-buffer cb)
               (kill-buffer cb))))))

This is one the reasons why I am very pleased to use Emacs, you can extend it and customize it without complex tasks, you just need to know how to program using the Emacs Lisp dialect. Then you can place those commands on binding of your taste, I have those commands configured with the following bindings:

(global-set-key "\C-c\C-q" 'batch-kill-buffer-equal-named)
(global-set-key "\C-c\C-a" 'batch-kill-buffer-save-equal-named)

I think that you will enjoy your favourite editor… Emacs :)

Copyright © 2011 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2011. | Permalink | No comment
Post tags:

This small trick, will allow you to use certain style and run your project specific hook based on the directory name or file name that is visited by Emacs.

(defvar dmw-visit-file-mode-list
  '(("/home/dmw" caffeine-c-mode-hook)
    ("/work/src/caffeine" caffeine-c-mode-hook)
    ("/work/src/caffeine++" caffeine-c++-mode-hook)
    ("/work/src/fireservice" caffeine-c++-mode-hook)
    ("/work/src/Linux" gnu-c++-mode-hook)
    ("/work/src/FreeBSD" caffeine-c-mode-hook)
    ("/work/src/jaxer/products/server/src" caffeine-c++-mode-hook)
    ("/work/src/syslog-ng" caffeine-c-mode-hook)
    ("/work/src/pyxser" python-c-mode-hook)
    ("/work/gae/gae-1.3.7/cclp" python-mode-hook)
    ("/work/gae/gae-1.3.7/todo" python-mode-hook)
    ("/work/gae/gae-1.3.7" python-mode-hook)
    ("/work/www" dmw-php-mode-hook)))

(defun dmw-directory-based-c-hook ()
  (make-local-variable 'tab-width)
  (make-local-variable 'indent-tabs-mode)
  (make-local-variable 'fill-column)
  (make-local-variable 'tab-width)
  (make-local-variable 'c-tab-always-indent)
  (make-local-variable 'c-auto-hungry-initial-state)
  (make-local-variable 'c-default-style)
  (make-local-variable 'c-indent-level)
  (make-local-variable 'c-auto-hungry-initial-state)
  (make-local-variable 'c-block-comment-prefix)
  (make-local-variable 'c-basic-offset)
  (make-local-variable 'c-offsets-alist)
  (make-local-variable 'c-tab-always-indent)
  (make-local-variable 'fill-column)
  (dolist (dir-mode-pair dmw-ecb-directory-change-alist)
    (let ((dir-name (concat (first dir-mode-pair) ".*"))
          (mode-is (car (last dir-mode-pair)))
          (match-dir-based (string-match
                            (concat (first dir-mode-pair) ".*")
                            (buffer-file-name))))
      (if (and (numberp match-dir-based)
               (>= match-dir-based 0))
          (funcall mode-is))))
  (message ">>> done dmw-directory-based-c-hook..."))

Where each hook function on the dmw-visit-file-mode-list, runs each time that a file is visited. For example if I visit a file on the "/work/src/pyxser" directory, it will run the python-c-mode-hook function as mode hook.

;;; I add dmw-directory-based-c-hook to both C and C++ mode hook lists
(add-hook 'c-mode-hook 'dmw-directory-based-c-hook)
(add-hook 'c++-mode-hook 'dmw-directory-based-c-hook)
;;; instead of adding directly the python-c-mode-hook
(add-hook 'c-mode-hook 'python-c-mode-hook)
;;; which is only one, so, I leave project specific hooks to be handled
;;; based on its directory

And the python-c-mode-hook hook function, looks as follows:

(defun python-c-mode-hook ()
  (setq c-default-style "python")
  (setq tab-width 4)
  (setq indent-tabs-mode nil)
  (setq c-tab-always-indent t)
  (setq c-basic-offset 4)
  (setq c-auto-hungry-initial-state 'none)
  (setq c-tab-always-indent t)
  (setq c-block-comment-prefix "* ")
  (setq fill-column 78)
  (c-set-offset 'arglist-cont 4)
  (c-set-offset 'arglist-cont-nonempty 4)
  (c-set-offset 'statement-cont 4)
  (c-set-offset 'label [0])
  (c-set-style "python")
  (message ">>> done python-c-mode-hook (style %s)" c-indentation-style))

Happy programming under Emacs ;)

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags:

python-mode

Emacs is configured through the Lisp dialect Emacs-Lisp. Core configuration directives are processed from the ~/.emacs file. To enable the python-mode, you just need to load the python-mode each time that your Emacs editor opens a Python file.

;;; auto load python-mode
(autoload 'python-mode "python-mode" "Mode for editing Python source files")

;;; enable python-mode on .py files
(setq auto-mode-alist
      (append '(("\\.py" . python-mode)
                ) auto-mode-alist))

;; auto font lock mode
(defvar font-lock-auto-mode-list
  (list 'python-mode))

Also i known that each Emacs Mode, has some hooks, and python-mode isn’t an exception. To customize the python-mode you can use the python-mode-hook variable:

(add-hook 'python-mode-hook 'dmw-python-mode-hook)

Where, in this case, dmw-python-mode-hook is a symbol pointing to a function called dmw-python-mode-hook:

;; python mode hook
(defun dmw-python-mode-hook ()
  (load "py-mode-ext")
  (load "pyp")
  (require 'pycomplete)
  (setq py-indent-offset 4)
  (setq py-smart-indentation t)
  (setq py-continuation-offset 4)
  (setq indent-tabs-mode nil)
  (setq py-pychecker-command "~/bin/pylint_etc_wrapper.py")
  (setq py-pychecker-command-args (quote ("")))
  (autoload 'pymacs-load "pymacs" nil t)
  (autoload 'pymacs-eval "pymacs" nil t)
  (autoload 'pymacs-apply "pymacs")
  (autoload 'pymacs-call "pymacs")
  (setq interpreter-mode-alist(cons '("python" . python-mode)
                                    interpreter-mode-alist))
  (eldoc-mode 1)
  (define-key py-mode-map [f12] 'pyp)
  (define-key py-mode-map "\C-c\C-w" (lambda ()
                                       (interactive)
                                       (command-execute 'py-pychecker-run)))
  (define-key py-mode-map [C-S-iso-lefttab] 'py-complete)
  )

python-mode-hook

This python-mode-hook function or hook function, enables a series of features for you python-mode. First, it loads py-mode-ext and pyp, and also loads pycomplete. Those tools are part of the PAGE – Python Automatic GUI Generator package. py-mode-ext adds some nice functions and commands, like py-call-pdb, to begin debugging Python. pyp adds a command/function that prints the current expression, or prompts for an expression to print, with the complete code hierarchy as prefix:

def main():
    if len(sys.argv) != 3:
        print "No dialup number\n"
    txtmsg = sys.argv[2]
    number = sys.argv[1]
    number = number.strip()
    for n in [' ', '+', '(', ')', "\s", "\t", '-']:
        number = number.replace(n, "");
    number = '+' + number
    skype = Skype4Py.Skype()
    skype.Attach()
    ### this line was generated with the pyp
    ### command that has the line
    ### (define-key py-mode-map [f12] 'pyp) on the
    ### python-mode-hook
    print 'main: skype =', skype    # dmw   pyp
    message = skype.CreateSms(Skype4Py.smsMessageTypeOutgoing, number)
    message.Body = txtmsg
    message.Send()

Finally the pycomplete module has a very nice tool to enable Python auto-completion. For example the following code:

class ParentObject:
    parent1 = None
    parent2 = None
    parent3 = None
    def __init__(self, m1, m2, m3):
        self.parent1 = m1
        self.parent2 = m2
    def child(self, m1, m2, m3):
        self.parent3 = ChildObject(m1, m2, m3)
    def nested(self, m1, m2, m3):
        self.parent3.child4 = NestedChild(m1, m2, m3)
    def subnested(self, m1):
        self.parent3.child4.nested4 = SubNestedChild(m1)
        ### here I press ctrl + s + tab
        ### this will run py-complete as the line
        ### (define-key py-mode-map [C-S-iso-lefttab] 'py-complete)
        ### is defined on the python-mode-hook
        str<Ctrl+S+Tab>
    def __repr__(self):
        return "\n-> " + repr(self.__dict__)

This will display a window as follows — where you just need to press mouse-2 or the middle button on your mouse to select one completion:

pychecker

Python static checkers are cool, also are tools that you must use in your daily Python programming tasks. For example, on the Emacs Wiki, you can find this article about using Emacs as Python IDE. There I’ve found the pylint_etc_wrapper.py script, which runs three Python static checkers at once: pylint, pychecker, pyflakes and pep8. Running the pychecker script using the ctrl + cctrl + w key sequence, you will obtain a window similar to the next one, will errors reported from those tools:

I hope that you will enjoy hacking Python from Emacs, it’s a great editor. Also you can use the Emacs Code Browser with Python, I hope that you can find it very interesting.

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags:

For indexing tasks I’ve integrated ECB and cscope-mode, and created some hooks for certain directories. To let ECB know which hook must run on each directory, I’ve created the following variable in my .emacs file:

(defvar dmw-ecb-directory-change-alist
  '(("/work/src/caffeine" caffeine-c-mode-hook)
    ("/work/src/caffeine++" caffeine-c++-mode-hook)
    ("/work/src/fireservice" caffeine-c++-mode-hook)
    ("/work/src/Linux" caffeine-c-mode-hook)
    ("/work/src/FreeBSD" caffeine-c-mode-hook)
    ("/work/src/jaxer/products/server/src" caffeine-c++-mode-hook)
    ("/work/src/syslog-ng" caffeine-c-mode-hook)
    ("/work/src/pyxser" python-c-mode-hook)
    ("/work/gae/gae-1.3.5/cclp" python-mode-hook)
    ("/work/gae/gae-1.3.5" python-mode-hook)))

To let emacs know which directories requires automatic indexing of C code files I’ve created the following variable:

(defvar dmw-ecb-cscope-autoindexing-projects
  '("/work/src/caffeine"
    "/work/src/caffeine++"
    "/work/src/fireservice"
    "/work/src/Linux"
    "/work/src/FreeBSD"
    "/work/src/jaxer/products/server/src"
    "/work/src/syslog-ng"
    "/work/src/pyxser"))

And created the following hook to make each emacs sessions something really productive:

(defun dmw-ecb-directory-change-hook (dirold dirnew)
  (dolist (prji dmw-ecb-directory-change-alist)
    (let ((prj-name (first prji))
          (prj-match (string-match (concat (first prji) ".*") dirnew))
          (prj-hook (last prji))
          )
      (if (numberp prj-match)
          (progn
            (if (>= prj-match 0)
                (dolist (h (last prji))
                  (run-hook-with-args h)))
            (dolist (cscope-auto dmw-ecb-cscope-autoindexing-projects)
              (let ((newpath (concat dirnew "/cscope.out"))
                    (dirnew dirnew))
                (if (and (string= prj-name cscope-auto)
                         (not (file-exists-p cscope-auto)))
                    (progn
                      (setq cscope-database-file newpath
                            cscope-do-not-update-database nil
                            cscope-use-relative-path t
                            cscope-initial-directory dirnew)
                      (cscope-index-files dirnew)))))
            )))))

(defun dmw-cedet-hook ()
  (local-set-key [(control return)] 'semantic-ia-complete-symbol)
  (local-set-key "\C-c?" 'semantic-ia-complete-symbol-menu)
  (local-set-key "\C-c>" 'semantic-complete-analyze-inline)
  (local-set-key "\C-cp" 'semantic-analyze-proto-impl-toggle))

(add-hook 'c-mode-common-hook
          'dmw-cedet-hook)

(add-hook 'ecb-after-directory-change-hook
          'dmw-ecb-directory-change-hook)

(global-ede-mode t)

The dmw-ecb-directory-change-hook run each hook associated with project directories in the dmw-ecb-directory-change-alist list and also, it verify if the directory is present in the dmw-ecb-cscope-autoindexing-projects, and if the directory is on the list, it will call the cscope-index-files function to index the directory using cscope(1).

Also, here is my ecb-activate-hook, which makes coding under emacs quite more productive, and make its behaviour very similar to any another IDE:

(defun dmw-ecb-activate-hook ()
  (custom-set-variables
   '(ecb-display-default-dir-after-start t)
   '(ecb-auto-activate nil)
   '(ecb-options-version "2.32")
   '(ecb-source-path dmw-ecb-working-projects)
   '(ecb-tip-of-the-day nil)
   '(cache-directory-contents
     (quote ((".*caffeine" . 10000)
             (".*caffeine++" . 10000)
             (".*pyxser" . 10000)
             (".*fireservice" . 10000)
             (".*src/" . 10000))))
   )
  (setq-mode-local c-mode semanticdb-find-default-throttle
                   '(project unloaded system recursive))
  (setq-mode-local c++-mode semanticdb-find-default-throttle
                   '(project unloaded system recursive))
  (semantic-add-system-include "/usr/include" 'c++-mode)
  (semantic-add-system-include "/usr/local/include" 'c++-mode)
  (semantic-add-system-include "/usr/include" 'c-mode)
  (semantic-add-system-include "/usr/local/include" 'c-mode)
  (message "ECB Activate Hook Done!"))

emacs rocks ;)

Copyright © 2010 Daniel Molina Wegener
Atribución-No Comercial-Sin Derivadas 2.0 Chile

© Daniel Molina Wegener for coder . cl, 2010. | Permalink | No comment
Post tags: