Initial

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "lisp/flymake-cursor"]
+	path = lisp/flymake-cursor
+	url = git@github.com:illusori/emacs-flymake-cursor.git
+[submodule "lisp/multi-line-it"]
+	path = lisp/multi-line-it
+	url = git@github.com:IvanMalison/multi-line-it.git
+[submodule "lisp/yasnippet"]
+	path = lisp/yasnippet
+	url = git@github.com:capitaomorte/yasnippet.git

elpa/archives/gnu/archive-contents

@@ -0,0 +1,140 @@
+(1
+ (adaptive-wrap .
+		[(0 1)
+		 nil "Smart line-wrapping with wrap-prefix" single])
+ (all .
+      [(1 0)
+       nil "Edit all lines matching a given regexp" single])
+ (ampc .
+       [(0 2)
+	nil "Asynchronous Music Player Controller" single])
+ (auctex .
+	 [(11 86)
+	  nil "Integrated environment for *TeX*" tar])
+ (coffee-mode .
+	      [(0 4 1)
+	       nil "Major mode for CoffeeScript files" tar])
+ (company .
+	  [(0 5)
+	   nil "Flexible inline text and code completion" tar])
+ (csv-mode .
+	   [(1 0)
+	    nil "Major mode for editing comma/char separated values" single])
+ (debbugs .
+	  [(0 3)
+	   nil "SOAP library to access debbugs servers" tar])
+ (dict-tree .
+	    [(0 12 7)
+	     ((trie
+	       (0 2 5))
+	      (tNFA
+	       (0 1 1))
+	      (heap
+	       (0 3)))
+	     "Dictionary data structure" single])
+ (djvu .
+       [(0 5)
+	nil "Edit and view Djvu files via djvused" single])
+ (ediprolog .
+	    [(1 0)
+	     nil "Emacs Does Interactive Prolog" single])
+ (eldoc-eval .
+	     [(0 1)
+	      nil "Enable eldoc support when minibuffer is in use." single])
+ (epoch-view .
+	     [(0 0 1)
+	      nil "Minor mode to visualize epoch timestamps" single])
+ (f90-interface-browser .
+			[(1 1)
+			 nil "Parse and browse f90 interfaces" single])
+ (heap .
+       [(0 3)
+	nil "Heap (a.k.a. priority queue) data structure" single])
+ (ioccur .
+	 [(2 4)
+	  nil "Incremental occur" single])
+ (jgraph-mode .
+	      [(0 0)
+	       nil "Major mode for Jgraph files" single])
+ (js2-mode .
+	   [(20090814)
+	    nil "Improved JavaScript editing mode" single])
+ (lmc .
+      [(1 0)
+       nil "Little Man Computer in Elisp" single])
+ (load-dir .
+	   [(0 0 3)
+	    nil "Load all Emacs Lisp files in a given directory" single])
+ (markchars .
+	    [(0 2 0)
+	     nil "Mark chars fitting certain characteristics" single])
+ (memory-usage .
+	       [(0 1)
+		nil "Analyze the memory usage of Emacs in various ways" single])
+ (minimap .
+	  [(1 0)
+	   nil "Sidebar showing a \"mini-map\" of a buffer" single])
+ (muse .
+       [(3 20)
+	nil "Authoring and publishing tool" tar])
+ (nhexl-mode .
+	     [(0 1)
+	      nil "Minor mode to edit files via hex-dump format" single])
+ (nlinum .
+	 [(1 0)
+	  nil "Show line numbers in the margin" single])
+ (oauth2 .
+	 [(0 8)
+	  nil "OAuth 2.0 Authorization Protocol" single])
+ (org .
+      [(20120903)
+       nil "Outline-based notes management and organizer" tar])
+ (quarter-plane .
+		[(0 1)
+		 nil "Minor mode for quarter-plane style editing" single])
+ (queue .
+	[(0 1)
+	 nil "Queue data structure" single])
+ (rainbow-mode .
+	       [(0 2)
+		nil "Colorize color names in buffers" single])
+ (register-list .
+		[(0 1)
+		 nil "Interactively list/edit registers" single])
+ (shen-mode .
+	    [(0 1)
+	     nil "Utilities for working with Shen code." tar])
+ (sisu-mode .
+	    [(3 0 3)
+	     nil "Major mode for SiSU markup text" single])
+ (svg-clock .
+	    [(0 4)
+	     nil "Analog clock using Scalable Vector Graphics" single])
+ (tNFA .
+       [(0 1 1)
+	((queue
+	  (0 1)))
+	"Tagged non-deterministic finite-state automata" single])
+ (trie .
+       [(0 2 5)
+	((tNFA
+	  (0 1 1))
+	 (heap
+	  (0 3)))
+	"Trie data structure" single])
+ (undo-tree .
+	    [(0 5 3)
+	     nil "Treat undo history as a tree" single])
+ (uni-confusables .
+		  [(0 1)
+		   nil "Unicode confusables table" tar])
+ (vlf .
+      [(0 2)
+       nil "View Large Files" single])
+ (windresize .
+	     [(0 1)
+	      nil "Resize windows interactively" single])
+ (xclip .
+	[(1 0)
+	 nil "Emacs Interface to XClip" single]))
+

elpa/flymake-0.4.12/flymake-autoloads.el

@@ -0,0 +1,46 @@
+;;; flymake-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+
+;;;### (autoloads (flymake-find-file-hook flymake-mode-off flymake-mode-on
+;;;;;;  flymake-mode) "flymake" "flymake.el" (20685 13733))
+;;; Generated autoloads from flymake.el
+
+(autoload 'flymake-mode "flymake" "\
+Toggle on-the-fly syntax checking.
+With a prefix argument ARG, enable the mode if ARG is positive,
+and disable it otherwise.  If called from Lisp, enable the mode
+if ARG is omitted or nil.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'flymake-mode-on "flymake" "\
+Turn flymake mode on.
+
+\(fn)" nil nil)
+
+(autoload 'flymake-mode-off "flymake" "\
+Turn flymake mode off.
+
+\(fn)" nil nil)
+
+(autoload 'flymake-find-file-hook "flymake" "\
+
+
+\(fn)" nil nil)
+
+;;;***
+
+;;;### (autoloads nil nil ("flymake-pkg.el") (20685 13733 601582))
+
+;;;***
+
+(provide 'flymake-autoloads)
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; coding: utf-8
+;; End:
+;;; flymake-autoloads.el ends here

elpa/flymake-0.4.12/flymake-pkg.el

@@ -0,0 +1 @@
+(define-package "flymake" "0.4.12" "a universal on-the-fly syntax checker" (quote nil))

elpa/magit-1.1.1/magit-autoloads.el

@@ -0,0 +1,83 @@
+;;; magit-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+
+;;;### (autoloads (magit-status) "magit" "magit.el" (20540 8920))
+;;; Generated autoloads from magit.el
+
+(autoload 'magit-status "magit" "\
+Open a Magit status buffer for the Git repository containing
+DIR.  If DIR is not within a Git repository, offer to create a
+Git repository in DIR.
+
+Interactively, a prefix argument means to ask the user which Git
+repository to use even if `default-directory' is under Git control.
+Two prefix arguments means to ignore `magit-repo-dirs' when asking for
+user input.
+
+\(fn DIR)" t nil)
+
+;;;***
+
+;;;### (autoloads (turn-on-magit-stgit magit-stgit-mode) "magit-stgit"
+;;;;;;  "magit-stgit.el" (20540 8920))
+;;; Generated autoloads from magit-stgit.el
+
+(autoload 'magit-stgit-mode "magit-stgit" "\
+StGit support for Magit
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'turn-on-magit-stgit "magit-stgit" "\
+Unconditionally turn on `magit-stgit-mode'.
+
+\(fn)" nil nil)
+
+;;;***
+
+;;;### (autoloads (turn-on-magit-svn magit-svn-mode) "magit-svn"
+;;;;;;  "magit-svn.el" (20540 8920))
+;;; Generated autoloads from magit-svn.el
+
+(autoload 'magit-svn-mode "magit-svn" "\
+SVN support for Magit
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'turn-on-magit-svn "magit-svn" "\
+Unconditionally turn on `magit-svn-mode'.
+
+\(fn)" nil nil)
+
+;;;***
+
+;;;### (autoloads (turn-on-magit-topgit magit-topgit-mode) "magit-topgit"
+;;;;;;  "magit-topgit.el" (20540 8920))
+;;; Generated autoloads from magit-topgit.el
+
+(autoload 'magit-topgit-mode "magit-topgit" "\
+Topgit support for Magit
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'turn-on-magit-topgit "magit-topgit" "\
+Unconditionally turn on `magit-topgit-mode'.
+
+\(fn)" nil nil)
+
+;;;***
+
+;;;### (autoloads nil nil ("magit-bisect.el" "magit-key-mode.el"
+;;;;;;  "magit-pkg.el") (20540 8920 881666))
+
+;;;***
+
+(provide 'magit-autoloads)
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; coding: utf-8
+;; End:
+;;; magit-autoloads.el ends here

elpa/magit-1.1.1/magit-bisect.el

@@ -0,0 +1,196 @@
+(require 'magit)
+
+(defvar magit--bisect-last-pos)
+(defvar magit--bisect-tmp-file)
+(defvar magit--bisect-info nil)
+(make-variable-buffer-local 'magit--bisect-info)
+(put 'magit--bisect-info 'permanent-local t)
+
+(defun magit--bisecting-p (&optional required-status)
+  "Return t if a bisect session is running.
+If REQUIRED-STATUS is not nil then the current status must also
+match REQUIRED-STATUS."
+  (and (file-exists-p (concat (magit-get-top-dir default-directory)
+                          ".git/BISECT_LOG"))
+       (or (not required-status)
+           (eq (plist-get (magit--bisect-info) :status)
+               required-status))))
+
+(defun magit--bisect-info ()
+  (with-current-buffer (magit-find-status-buffer)
+    (or (if (local-variable-p 'magit--bisect-info) magit--bisect-info)
+        (list :status (if (magit--bisecting-p) 'running 'not-running)))))
+
+(defun magit--bisect-cmd (&rest args)
+  "Run `git bisect ...' and update the status buffer"
+  (with-current-buffer (magit-find-status-buffer)
+    (let* ((output (apply 'magit-git-lines (append '("bisect") args)))
+           (cmd (car args))
+           (first-line (car output)))
+      (save-match-data
+        (setq magit--bisect-info
+              (cond ((string= cmd "reset")
+                     (list :status 'not-running))
+                    ;; Bisecting: 78 revisions left to test after this (roughly 6 steps)
+                    ((string-match "^Bisecting:\\s-+\\([0-9]+\\).+roughly\\s-+\\([0-9]+\\)" first-line)
+                     (list :status 'running
+                           :revs (match-string 1 first-line)
+                           :steps (match-string 2 first-line)))
+                    ;; e2596955d9253a80aec9071c18079705597fa102 is the first bad commit
+                    ((string-match "^\\([a-f0-9]+\\)\\s-.*first bad commit" first-line)
+                     (list :status 'finished
+                           :bad (match-string 1 first-line)))
+                    (t
+                     (list :status 'error)))))))
+  (magit-refresh))
+
+(defun magit--bisect-info-for-status (branch)
+  "Return bisect info suitable for display in the status buffer"
+  (let* ((info (magit--bisect-info))
+         (status (plist-get info :status)))
+    (cond ((eq status 'not-running)
+           (or branch "(detached)"))
+          ((eq status 'running)
+           (format "(bisecting; %s revisions & %s steps left)"
+                   (or (plist-get info :revs) "unknown number of")
+                   (or (plist-get info :steps) "unknown number of")))
+          ((eq status 'finished)
+           (format "(bisected: first bad revision is %s)" (plist-get info :bad)))
+          (t
+           "(bisecting; unknown error occured)"))))
+
+(defun magit-bisect-start ()
+  "Start a bisect session"
+  (interactive)
+  (if (magit--bisecting-p)
+      (error "Already bisecting"))
+  (let ((bad (magit-read-rev "Start bisect with known bad revision" "HEAD"))
+        (good (magit-read-rev "Good revision" (magit-default-rev))))
+    (magit--bisect-cmd "start" bad good)))
+
+(defun magit-bisect-reset ()
+  "Quit a bisect session"
+  (interactive)
+  (unless (magit--bisecting-p)
+    (error "Not bisecting"))
+  (magit--bisect-cmd "reset"))
+
+(defun magit-bisect-good ()
+  "Tell git that the current revision is good during a bisect session"
+  (interactive)
+  (unless (magit--bisecting-p 'running)
+    (error "Not bisecting"))
+  (magit--bisect-cmd "good"))
+
+(defun magit-bisect-bad ()
+  "Tell git that the current revision is bad during a bisect session"
+  (interactive)
+  (unless (magit--bisecting-p 'running)
+    (error "Not bisecting"))
+  (magit--bisect-cmd "bad"))
+
+(defun magit-bisect-skip ()
+  "Tell git to skip the current revision during a bisect session."
+  (interactive)
+  (unless (magit--bisecting-p 'running)
+    (error "Not bisecting"))
+  (magit--bisect-cmd "skip"))
+
+(defun magit-bisect-log ()
+  "Show the bisect log"
+  (interactive)
+  (unless (magit--bisecting-p)
+    (error "Not bisecting"))
+  (magit-run-git "bisect" "log")
+  (magit-display-process))
+
+(defun magit-bisect-visualize ()
+  "Show the remaining suspects with gitk"
+  (interactive)
+  (unless (magit--bisecting-p)
+    (error "Not bisecting"))
+  (magit-run-git "bisect" "visualize")
+  (unless (getenv "DISPLAY")
+    (magit-display-process)))
+
+(easy-mmode-defmap magit-bisect-minibuffer-local-map
+  '(("\C-i" . comint-dynamic-complete-filename))
+  "Keymap for minibuffer prompting of rebase command."
+  :inherit minibuffer-local-map)
+
+(defvar magit-bisect-mode-history nil
+  "Previously run bisect commands.")
+
+(defun magit-bisect-run (command)
+  "Bisect automatically by running commands after each step"
+  (interactive
+   (list
+    (read-from-minibuffer "Run command (like this): "
+                          ""
+                          magit-bisect-minibuffer-local-map
+                          nil
+                          'magit-bisect-mode-history)))
+  (unless (magit--bisecting-p)
+    (error "Not bisecting"))
+  (let ((file (make-temp-file "magit-bisect-run"))
+        buffer)
+    (with-temp-buffer
+      (insert "#!/bin/sh\n" command "\n")
+      (write-region (point-min) (point-max) file))
+    (chmod file #o755)
+    (magit-run-git-async "bisect" "run" file)
+    (magit-display-process)
+    (setq buffer (get-buffer magit-process-buffer-name))
+    (with-current-buffer buffer
+      (set (make-local-variable 'magit--bisect-last-pos) 0)
+      (set (make-local-variable 'magit--bisect-tmp-file) file))
+    (set-process-filter (get-buffer-process buffer) 'magit--bisect-run-filter)
+    (set-process-sentinel (get-buffer-process buffer) 'magit--bisect-run-sentinel)))
+
+(defun magit--bisect-run-filter (process output)
+  (with-current-buffer (process-buffer process)
+    (save-match-data
+      (let ((inhibit-read-only t)
+            line new-info)
+        (insert output)
+        (goto-char magit--bisect-last-pos)
+        (beginning-of-line)
+        (while (< (point) (point-max))
+          (cond ( ;; Bisecting: 78 revisions left to test after this (roughly 6 steps)
+                 (looking-at "^Bisecting:\\s-+\\([0-9]+\\).+roughly\\s-+\\([0-9]+\\)")
+                 (setq new-info (list :status 'running
+                                      :revs (match-string 1)
+                                      :steps (match-string 2))))
+                ( ;; e2596955d9253a80aec9071c18079705597fa102 is the first bad commit
+                 (looking-at "^\\([a-f0-9]+\\)\\s-.*first bad commit")
+                 (setq new-info (list :status 'finished
+                                      :bad (match-string 1)))))
+          (forward-line 1))
+        (goto-char (point-max))
+        (setq magit--bisect-last-pos (point))
+        (if new-info
+            (with-current-buffer (magit-find-status-buffer)
+              (setq magit--bisect-info new-info)
+              (magit--bisect-update-status-buffer)))))))
+
+(defun magit--bisect-run-sentinel (process event)
+  (if (string-match-p "^finish" event)
+      (with-current-buffer (process-buffer process)
+        (delete-file magit--bisect-tmp-file)))
+  (magit-process-sentinel process event))
+
+(defun magit--bisect-update-status-buffer ()
+  (with-current-buffer (magit-find-status-buffer)
+    (save-excursion
+      (save-match-data
+        (let ((inhibit-read-only t))
+          (goto-char (point-min))
+          (when (search-forward-regexp "Local:" nil t)
+            (beginning-of-line)
+            (kill-line)
+            (insert (format "Local:    %s %s"
+                            (propertize (magit--bisect-info-for-status (magit-get-current-branch))
+                                        'face 'magit-branch)
+                            (abbreviate-file-name default-directory)))))))))
+
+(provide 'magit-bisect)

elpa/magit-1.1.1/magit-key-mode.el

@@ -0,0 +1,508 @@
+(require 'magit)
+
+(require 'assoc)
+(eval-when-compile (require 'cl))
+
+(defvar magit-key-mode-key-maps '()
+  "This will be filled lazily with proper `define-key' built
+  keymaps as they're requested.")
+
+(defvar magit-key-mode-buf-name "*magit-key*"
+  "Name of the buffer.")
+
+(defvar magit-key-mode-current-args '()
+  "Will contain the arguments to be passed to git.")
+
+(defvar magit-key-mode-current-options '()
+  "Will contain the arguments to be passed to git.")
+
+(defvar magit-log-mode-window-conf nil
+  "Will hold the pre-menu configuration of magit.")
+
+(defvar magit-key-mode-groups
+  '((logging
+     (man-page "git-log")
+     (actions
+      ("l" "Short" magit-log)
+      ("L" "Long" magit-log-long)
+      ("h" "Reflog" magit-reflog)
+      ("rl" "Ranged short" magit-log-ranged)
+      ("rL" "Ranged long" magit-log-long-ranged)
+      ("rh" "Ranged reflog" magit-reflog-ranged))
+     (switches
+      ("-m" "Only merge commits" "--merges")
+      ("-f" "First parent" "--first-parent")
+      ("-i" "Case insensitive patterns" "-i")
+      ("-pr" "Pickaxe regex" "--pickaxe-regex")
+      ("-n" "Name only" "--name-only")
+      ("-am" "All match" "--all-match")
+      ("-al" "All" "--all"))
+     (arguments
+      ("=r" "Relative" "--relative=" read-directory-name)
+      ("=c" "Committer" "--committer=" read-from-minibuffer)
+      ("=>" "Since" "--since=" read-from-minibuffer)
+      ("=<" "Before" "--before=" read-from-minibuffer)
+      ("=s" "Pickaxe search" "-S" read-from-minibuffer)
+      ("=a" "Author" "--author=" read-from-minibuffer)
+      ("=g" "Grep" "--grep=" read-from-minibuffer)))
+
+    (running
+     (actions
+      ("!" "Command from root" magit-shell-command)
+      (":" "Git command" magit-git-command)
+      ("g" "git gui" magit-run-git-gui)
+      ("k" "gitk" magit-run-gitk)))
+
+    (fetching
+     (man-page "git-fetch")
+     (actions
+      ("f" "Current" magit-fetch-current)
+      ("a" "All" magit-remote-update)
+      ("o" "Other" magit-fetch))
+     (switches
+      ("-p" "Prune" "--prune")))
+
+    (pushing
+     (man-page "git-push")
+     (actions
+      ("P" "Push" magit-push)
+      ("t" "Push tags" magit-push-tags))
+     (switches
+      ("-f" "Force" "--force")
+      ("-d" "Dry run" "-n")
+      ("-u" "Set upstream" "-u")))
+
+    (pulling
+     (man-page "git-pull")
+     (actions
+      ("F" "Pull" magit-pull))
+     (switches
+      ("-r" "Rebase" "--rebase")))
+
+    (branching
+     (man-page "git-branch")
+     (actions
+      ("v" "Branch manager" magit-show-branches)
+      ("n" "New" magit-create-branch)
+      ("m" "Move" magit-move-branch)
+      ("d" "Delete" magit-delete-branch)
+      ("D" "Force Delete" magit-delete-branch-forced)
+      ("b" "Checkout" magit-checkout)))
+
+    (tagging
+     (man-page "git-tag")
+     (actions
+      ("t" "Lightweight" magit-tag)
+      ("a" "Annotated" magit-annotated-tag))
+     (switches
+      ("-f" "Force" "-f")))
+
+    (stashing
+     (man-page "git-stash")
+     (actions
+      ("z" "Save" magit-stash)
+      ("s" "Snapshot" magit-stash-snapshot))
+     (switches
+      ("-k" "Keep index" "--keep-index")))
+
+    (merging
+     (man-page "git-merge")
+     (actions
+      ("m" "Merge" magit-merge))
+     (switches
+      ("-ff" "Fast-forward only" "--ff-only")
+      ("-nf" "No fast-forward" "--no-ff")
+      ("-nc" "No commit" "--no-commit")
+      ("-sq" "Squash" "--squash"))
+     (arguments
+      ("-st" "Strategy" "--strategy=" read-from-minibuffer)))
+
+    (rewriting
+     (actions
+      ("b" "Begin" magit-rewrite-start)
+      ("s" "Stop" magit-rewrite-stop)
+      ("a" "Abort" magit-rewrite-abort)
+      ("f" "Finish" magit-rewrite-finish)
+      ("*" "Set unused" magit-rewrite-set-unused)
+      ("." "Set used" magit-rewrite-set-used)))
+
+    (submodule
+     (man-page "git-submodule")
+     (actions
+      ("u" "Update" magit-submodule-update)
+      ("b" "Both update and init" magit-submodule-update-init)
+      ("i" "Init" magit-submodule-init)
+      ("s" "Sync" magit-submodule-sync)))
+
+    (bisecting
+     (man-page "git-bisect")
+     (actions
+      ("b" "Bad" magit-bisect-bad)
+      ("g" "Good" magit-bisect-good)
+      ("k" "Skip" magit-bisect-skip)
+      ("l" "Log" magit-bisect-log)
+      ("r" "Reset" magit-bisect-reset)
+      ("s" "Start" magit-bisect-start)
+      ("u" "Run" magit-bisect-run)
+      ("v" "Visualize" magit-bisect-visualize))))
+  "Holds the key, help, function mapping for the log-mode. If you
+  modify this make sure you reset `magit-key-mode-key-maps' to
+  nil.")
+
+(defun magit-key-mode-delete-group (group)
+  "Delete a group from `magit-key-mode-key-maps'."
+  (let ((items (assoc group magit-key-mode-groups)))
+    (when items
+      ;; reset the cache
+      (setq magit-key-mode-key-maps nil)
+      ;; delete the whole group
+      (setq magit-key-mode-groups
+            (delq items magit-key-mode-groups))
+      ;; unbind the defun
+      (magit-key-mode-de-generate group))
+    magit-key-mode-groups))
+
+(defun magit-key-mode-add-group (group)
+  "Add a new group to `magit-key-mode-key-maps'. If there's
+already a group of that name then this will completely remove it
+and put in its place an empty one of the same name."
+  (when (assoc group magit-key-mode-groups)
+    (magit-key-mode-delete-group group))
+  (setq magit-key-mode-groups
+        (cons (list group '(actions)) magit-key-mode-groups)))
+
+(defun magit-key-mode-key-defined-p (for-group key)
+  "If KEY is defined as any of switch, argument or action within
+FOR-GROUP then return t"
+  (catch 'result
+    (let ((options (magit-key-mode-options-for-group for-group)))
+      (dolist (type '(actions switches arguments))
+        (when (assoc key (assoc type options))
+          (throw 'result t))))))
+
+(defun magit-key-mode-update-group (for-group thing &rest args)
+  "Abstraction for setting values in `magit-key-mode-key-maps'."
+  (let* ((options (magit-key-mode-options-for-group for-group))
+         (things (assoc thing options))
+         (key (car args)))
+    (if (cdr things)
+        (if (magit-key-mode-key-defined-p for-group key)
+            (error "%s is already defined in the %s group." key for-group)
+          (setcdr (cdr things) (cons args (cddr things))))
+      (setcdr things (list args)))
+    (setq magit-key-mode-key-maps nil)
+    things))
+
+(defun magit-key-mode-insert-argument (for-group key desc arg read-func)
+  "Add a new binding (KEY) in FOR-GROUP which will use READ-FUNC
+to receive input to apply to argument ARG git is run. DESC should
+be a brief description of the binding."
+  (magit-key-mode-update-group for-group 'arguments key desc arg read-func))
+
+(defun magit-key-mode-insert-switch (for-group key desc switch)
+  "Add a new binding (KEY) in FOR-GROUP which will add SWITCH to git's
+command line when it runs. DESC should be a brief description of
+the binding."
+  (magit-key-mode-update-group for-group 'switches key desc switch))
+
+(defun magit-key-mode-insert-action (for-group key desc func)
+  "Add a new binding (KEY) in FOR-GROUP which will run command
+FUNC. DESC should be a brief description of the binding."
+  (magit-key-mode-update-group for-group 'actions key desc func))
+
+(defun magit-key-mode-options-for-group (for-group)
+  "Retrieve the options (switches, commands and arguments) for
+the group FOR-GROUP."
+  (or (cdr (assoc for-group magit-key-mode-groups))
+      (error "Unknown group '%s'" for-group)))
+
+(defun magit-key-mode-help (for-group)
+  "Provide help for a key (which the user is prompted for) within
+FOR-GROUP."
+  (let* ((opts (magit-key-mode-options-for-group for-group))
+         (man-page (cadr (assoc 'man-page opts)))
+         (seq (read-key-sequence
+               (format "Enter command prefix%s: "
+                       (if man-page
+                         (format ", `?' for man `%s'" man-page)
+                         ""))))
+         (actions (cdr (assoc 'actions opts))))
+    (cond
+      ;; if it is an action popup the help for the to-be-run function
+      ((assoc seq actions) (describe-function (nth 2 (assoc seq actions))))
+      ;; if there is "?" show a man page if there is one
+      ((equal seq "?")
+       (if man-page
+         (man man-page)
+         (error "No man page associated with `%s'" for-group)))
+      (t (error "No help associated with `%s'" seq)))))
+
+(defun magit-key-mode-exec-at-point ()
+  "Run action/args/option at point."
+  (interactive)
+  (let* ((key (or (get-text-property (point) 'key-group-executor)
+                  (error "Nothing at point to do.")))
+         (def (lookup-key (current-local-map) key)))
+    (call-interactively def)))
+
+(defun magit-key-mode-build-keymap (for-group)
+  "Construct a normal looking keymap for the key mode to use and
+put it in magit-key-mode-key-maps for fast lookup."
+  (let* ((options (magit-key-mode-options-for-group for-group))
+         (actions (cdr (assoc 'actions options)))
+         (switches (cdr (assoc 'switches options)))
+         (arguments (cdr (assoc 'arguments options)))
+         (map (make-sparse-keymap)))
+    (suppress-keymap map 'nodigits)
+    ;; ret dwim
+    (define-key map (kbd "RET") 'magit-key-mode-exec-at-point)
+
+    ;; all maps should `quit' with `C-g' or `q'
+    (define-key map (kbd "C-g") `(lambda ()
+                                   (interactive)
+                                   (magit-key-mode-command nil)))
+    (define-key map (kbd "q")   `(lambda ()
+                                   (interactive)
+                                   (magit-key-mode-command nil)))
+    ;; run help
+    (define-key map (kbd "?") `(lambda ()
+                                 (interactive)
+                                 (magit-key-mode-help ',for-group)))
+
+    (flet ((defkey (k action)
+             (when (and (lookup-key map (car k))
+                        (not (numberp (lookup-key map (car k)))))
+               (message "Warning: overriding binding for `%s' in %S"
+                        (car k) for-group)
+               (ding)
+               (sit-for 2))
+             (define-key map (car k)
+               `(lambda () (interactive) ,action))))
+      (when actions
+        (dolist (k actions)
+          (defkey k `(magit-key-mode-command ',(nth 2 k)))))
+      (when switches
+        (dolist (k switches)
+          (defkey k `(magit-key-mode-add-option ',for-group ,(nth 2 k)))))
+      (when arguments
+        (dolist (k arguments)
+          (defkey k `(magit-key-mode-add-argument
+                      ',for-group ,(nth 2 k) ',(nth 3 k))))))
+
+    (aput 'magit-key-mode-key-maps for-group map)
+    map))
+
+(defvar magit-key-mode-prefix nil
+  "For internal use.  Holds the prefix argument to the command
+that brought up the key-mode window, so it can be used by the
+command that's eventually invoked.")
+
+(defun magit-key-mode-command (func)
+  (let ((args '()))
+    ;; why can't maphash return a list?!
+    (maphash (lambda (k v)
+               (push (concat k (shell-quote-argument v)) args))
+             magit-key-mode-current-args)
+    (let ((magit-custom-options (append args magit-key-mode-current-options))
+          (current-prefix-arg (or current-prefix-arg magit-key-mode-prefix)))
+      (set-window-configuration magit-log-mode-window-conf)
+      (when func
+        (call-interactively func))
+      (magit-key-mode-kill-buffer))))
+
+(defvar magit-key-mode-current-args nil
+  "A hash-table of current argument set (which will eventually
+  make it to the git command-line).")
+
+(defun magit-key-mode-add-argument (for-group arg-name input-func)
+  (let ((input (funcall input-func (concat arg-name ": "))))
+    (puthash arg-name input magit-key-mode-current-args)
+   (magit-key-mode-redraw for-group)))
+
+(defvar magit-key-mode-current-options '()
+  "Current option set (which will eventually make it to the git
+  command-line).")
+
+(defun magit-key-mode-add-option (for-group option-name)
+  "Toggles the appearance of OPTION-NAME in
+`magit-key-mode-current-options'."
+  (if (not (member option-name magit-key-mode-current-options))
+      (add-to-list 'magit-key-mode-current-options option-name)
+    (setq magit-key-mode-current-options
+          (delete option-name magit-key-mode-current-options)))
+  (magit-key-mode-redraw for-group))
+
+(defun magit-key-mode-kill-buffer ()
+  (interactive)
+  (kill-buffer magit-key-mode-buf-name))
+
+(defvar magit-log-mode-window-conf nil
+  "Pre-popup window configuration.")
+
+(defun magit-key-mode (for-group &optional original-opts)
+  "Mode for magit key selection. All commands, switches and
+options can be toggled/actioned with the key combination
+highlighted before the description."
+  (interactive)
+  ;; save the window config to restore it as was (no need to make this
+  ;; buffer local)
+  (setq magit-log-mode-window-conf
+        (current-window-configuration))
+  ;; setup the mode, draw the buffer
+  (let ((buf (get-buffer-create magit-key-mode-buf-name)))
+    (delete-other-windows)
+    (split-window-vertically)
+    (other-window 1)
+    (switch-to-buffer buf)
+    (kill-all-local-variables)
+    (set (make-local-variable
+          'magit-key-mode-current-options)
+         original-opts)
+    (set (make-local-variable
+          'magit-key-mode-current-args)
+         (make-hash-table))
+    (set (make-local-variable 'magit-key-mode-prefix) current-prefix-arg)
+    (magit-key-mode-redraw for-group))
+  (message
+   (concat
+    "Type a prefix key to toggle it. Run 'actions' with their prefixes. "
+    "'?' for more help.")))
+
+(defun magit-key-mode-get-key-map (for-group)
+  "Get or build the keymap for FOR-GROUP."
+  (or (cdr (assoc for-group magit-key-mode-key-maps))
+      (magit-key-mode-build-keymap for-group)))
+
+(defun magit-key-mode-redraw (for-group)
+  "(re)draw the magit key buffer."
+  (let ((buffer-read-only nil)
+        (old-point (point)))
+    (erase-buffer)
+    (make-local-variable 'font-lock-defaults)
+    (use-local-map (magit-key-mode-get-key-map for-group))
+    (magit-key-mode-draw for-group)
+    (delete-trailing-whitespace)
+    (setq mode-name "magit-key-mode" major-mode 'magit-key-mode)
+    (goto-char old-point))
+  (setq buffer-read-only t)
+  (fit-window-to-buffer))
+
+(defun magit-key-mode-draw-header (header)
+  "Draw a header with the correct face."
+  (insert (propertize header 'face 'font-lock-keyword-face)))
+
+(defvar magit-key-mode-args-in-cols nil
+  "When true, draw arguments in columns as with switches and
+  options.")
+
+(defun magit-key-mode-draw-args (args)
+  "Draw the args part of the menu."
+  (when args
+    (let ((strs (mapcar
+                 (lambda (argument)
+                   (propertize
+                    (format " %s: %s (%s) %s"
+                            (propertize
+                             (car argument)
+                             'face 'font-lock-builtin-face)
+                            (nth 1 argument)
+                            (nth 2 argument)
+                            (propertize
+                             (gethash (nth 2 argument)
+                                      magit-key-mode-current-args
+                                      "")
+                             'face 'widget-field))
+                    'key-group-executor (car argument)))
+                 args)))
+      (magit-key-mode-draw-header "Args\n")
+      (magit-key-mode-draw-in-cols strs (not magit-key-mode-args-in-cols)))))
+
+(defun magit-key-mode-draw-switches (switches)
+  "Draw the switches part of the menu."
+  (when switches
+    (let ((switch-strs (mapcar
+                        (lambda (s)
+                          (let ((option (nth 2 s)))
+                            (propertize
+                             (format " %s: %s (%s)"
+                                     (propertize (car s)
+                                                 'face 'font-lock-builtin-face)
+                                     (nth 1 s)
+                                     (if (member option magit-key-mode-current-options)
+                                         (propertize
+                                          option
+                                          'face 'font-lock-warning-face)
+                                       option))
+                             'key-group-executor (car s))))
+                        switches)))
+      (magit-key-mode-draw-header "Switches\n")
+      (magit-key-mode-draw-in-cols switch-strs))))
+
+(defun magit-key-mode-draw-actions (actions)
+  "Draw the actions part of the menu."
+  (when actions
+    (let ((action-strs (mapcar
+                        (lambda (a)
+                          (propertize
+                           (format
+                            " %s: %s"
+                            (propertize (car a)
+                                        'face 'font-lock-builtin-face)
+                            (nth 1 a))
+                           'key-group-executor (car a)))
+                       actions)))
+    (magit-key-mode-draw-header "Actions\n")
+    (magit-key-mode-draw-in-cols action-strs))))
+
+(defun magit-key-mode-draw-in-cols (strings &optional one-col-each)
+  "Given a list of strings, print in columns (using `insert'). If
+ONE-COL-EACH is true then don't columify, but rather, draw each
+item on one line."
+  (let ((longest-act (apply 'max (mapcar 'length strings))))
+    (while strings
+      (let ((str (car strings)))
+        (let ((padding (make-string (- (+ longest-act 3) (length str)) ? )))
+          (insert str)
+          (if (or one-col-each
+                  (and (> (+ (length padding) ;
+                             (current-column)
+                             longest-act)
+                          (window-width))
+                       (cdr strings)))
+              (insert "\n")
+            (insert padding))))
+      (setq strings (cdr strings))))
+  (insert "\n"))
+
+(defun magit-key-mode-draw (for-group)
+  "Function used to draw actions, switches and parameters."
+  (let* ((options (magit-key-mode-options-for-group for-group))
+         (switches (cdr (assoc 'switches options)))
+         (arguments (cdr (assoc 'arguments options)))
+         (actions (cdr (assoc 'actions options))))
+    (magit-key-mode-draw-switches switches)
+    (magit-key-mode-draw-args arguments)
+    (magit-key-mode-draw-actions actions)
+    (insert "\n")))
+
+(defun magit-key-mode-de-generate (group)
+  "Unbind the function for GROUP."
+  (fmakunbound
+   (intern (concat "magit-key-mode-popup-" (symbol-name group)))))
+
+(defun magit-key-mode-generate (group)
+  "Generate the key-group menu for GROUP"
+  (let ((opts (magit-key-mode-options-for-group group)))
+    (eval
+     `(defun ,(intern (concat "magit-key-mode-popup-" (symbol-name group))) nil
+        ,(concat "Key menu for " (symbol-name group))
+        (interactive)
+        (magit-key-mode (quote ,group))))))
+
+;; create the interactive functions for the key mode popups (which are
+;; applied in the top-level key maps)
+(mapc (lambda (g)
+        (magit-key-mode-generate (car g)))
+      magit-key-mode-groups)
+
+(provide 'magit-key-mode)

elpa/magit-1.1.1/magit-pkg.el

@@ -0,0 +1 @@
+(define-package "magit" "1.1.1" "Control Git from Emacs.")

elpa/magit-1.1.1/magit-stgit.el

@@ -0,0 +1,288 @@
+;;; magit-stgit.el --- StGit plug-in for Magit
+
+;; Copyright (C) 2011  Lluis Vilanova
+;;
+;; Magit is free software; you can redistribute it and/or modify it
+;; under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+;;
+;; Magit is distributed in the hope that it will be useful, but WITHOUT
+;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+;; License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with Magit.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This plug-in provides StGit functionality as a separate component of Magit.
+
+;; Available actions:
+;; - visit: Shows the patch at point in the series (stg show)
+;; - apply: Goes to the patch at point in the series (stg goto)
+;; - discard: Deletes the marked/at point patch in the series (stg delete)
+
+;; Available commands:
+;; - `magit-stgit-refresh': Refresh the marked/at point patch in the series
+;;   (stg refresh)
+;; - `magit-stgit-repair': Repair the StGit metadata (stg repair)
+;; - `magit-stgit-rebase': Rebase the whole series (stg rebase)
+
+;; TODO:
+;; - Let the user select which files must be included in a refresh.
+;; - Missing actions for `magit-show-item-or-scroll-up' and
+;;   `magit-show-item-or-scroll-down'.
+;; - Marking a patch is slow and refreshes all buffers, which resets their
+;;   position (i.e., the buffer is shown from its first line).
+
+;;; Code:
+
+(require 'magit)
+(eval-when-compile
+  (require 'cl))
+
+;;; Customizables:
+
+(defcustom magit-stgit-executable "stg"
+  "The name of the StGit executable."
+  :group 'magit
+  :type 'string)
+
+(defface magit-stgit-applied
+  '((t :inherit magit-diff-add))
+  "Face for an applied stgit patch."
+  :group 'magit-faces)
+
+(defface magit-stgit-current
+  '((t :inherit magit-item-highlight))
+  "Face for the current stgit patch."
+  :group 'magit-faces)
+
+(defface magit-stgit-other
+  '((t :inherit magit-diff-del))
+  "Face for a non-applied stgit patch."
+  :group 'magit-faces)
+
+(defface magit-stgit-marked
+  '((t :inherit magit-item-mark))
+  "Face for a marked stgit patch."
+  :group 'magit-faces)
+
+(defface magit-stgit-empty
+  '((t :inherit magit-item-mark))
+  "Face for an empty stgit patch."
+  :group 'magit-faces)
+
+;;; Common code:
+
+(defvar magit-stgit--enabled nil
+  "Whether this buffer has StGit support.")
+(make-variable-buffer-local 'magit-stgit--enabled)
+
+(defvar magit-stgit-mode)
+
+(defun magit-stgit--enabled ()
+  "Whether this buffer has StGit support enabled."
+  (if (assoc 'magit-stgit--enabled (buffer-local-variables))
+      magit-stgit--enabled
+    (setq magit-stgit--enabled
+          (and magit-stgit-mode
+               (not (null
+                     (member (concat (magit-get-current-branch) ".stgit")
+                             (mapcar #'(lambda (line)
+                                         (string-match "^\\*?\s*\\([^\s]*\\)"
+                                                       line)
+                                         (match-string 1 line))
+                                     (magit-git-lines "branch")))))))))
+
+(defun magit-stgit--enabled-reset ()
+  "Reset the StGit enabled state."
+  (kill-local-variable 'magit-stgit--enabled))
+
+(defvar magit-stgit--marked-patch nil
+  "The (per-buffer) currently marked patch in an StGit series.")
+(make-variable-buffer-local 'magit-stgit--marked-patch)
+
+;;; Menu:
+
+(easy-menu-define magit-stgit-extension-menu
+  nil
+  "StGit extension menu"
+  '("StGit"
+    :active (magit-stgit--enabled)
+
+    ["Refresh patch" magit-stgit-refresh
+     :help "Refresh the contents of a patch in an StGit series"]
+    ["Repair" magit-stgit-repair
+     :help "Repair StGit metadata if branch was modified with git commands"]
+    ["Rebase series" magit-stgit-rebase
+     :help "Rebase an StGit patch series"]
+    ))
+
+(easy-menu-add-item 'magit-mode-menu
+                    '("Extensions")
+                    magit-stgit-extension-menu)
+
+;;; Series section:
+
+(defun magit-stgit--wash-patch ()
+  (if (search-forward-regexp "^\\(.\\)\\(.\\) \\([^\s]*\\)\\(\s*# ?\\)\\(.*\\)"
+                             (line-end-position) t)
+      (let* ((empty-str "[empty] ")
+             (indent-str (make-string (string-bytes empty-str) ?\ ))
+             (empty (match-string 1))
+             (state (match-string 2))
+             (patch (match-string 3))
+             (descr (match-string 5)))
+        (delete-region (line-beginning-position) (line-end-position))
+        (insert
+         (cond ((string= empty "0")
+                (propertize (concat empty-str " " state " " descr) 'face 'magit-stgit-empty))
+               ((string= magit-stgit--marked-patch patch)
+                (propertize (concat indent-str " " state " " descr) 'face 'magit-stgit-marked))
+               ((string= state "+")
+                (concat indent-str " " (propertize state 'face 'magit-stgit-applied) " " descr))
+               ((string= state ">")
+                (propertize (concat indent-str " " state " " descr) 'face 'magit-stgit-current))
+               ((string= state "-")
+                (concat indent-str " " (propertize state 'face 'magit-stgit-other) " " descr))))
+        (goto-char (line-beginning-position))
+        (magit-with-section patch 'series
+          (magit-set-section-info patch)
+          (goto-char (line-end-position)))
+        (forward-line))
+    (delete-region (line-beginning-position) (1+ (line-end-position))))
+  t)
+
+(defun magit-stgit--wash-series ()
+    (let ((magit-old-top-section nil))
+      (magit-wash-sequence #'magit-stgit--wash-patch)))
+
+(magit-define-inserter series ()
+  (when (executable-find magit-stgit-executable)
+    (magit-insert-section 'series
+                          "Series:" 'magit-stgit--wash-series
+                          magit-stgit-executable "series" "-a" "-d" "-e")))
+
+;;; Actions:
+
+;; Copy of `magit-refresh-commit-buffer' (version 1.0.0)
+(defun magit-stgit--refresh-patch-buffer (patch)
+  (magit-create-buffer-sections
+    (magit-insert-section nil nil
+                       'magit-wash-commit
+                       magit-stgit-executable
+                       "show"
+                       patch)))
+
+;; Copy of `magit-show-commit' (version 1.0.0)
+(defun magit-stgit--show-patch (patch &optional scroll)
+  (when (magit-section-p patch)
+    (setq patch (magit-section-info patch)))
+  (let ((dir default-directory)
+        (buf (get-buffer-create magit-commit-buffer-name)))
+    (cond ((and (equal magit-currently-shown-commit patch)
+                ;; if it's empty then the buffer was killed
+                (with-current-buffer buf
+                  (> (length (buffer-string)) 1)))
+           (let ((win (get-buffer-window buf)))
+             (cond ((not win)
+                    (display-buffer buf))
+                   (scroll
+                    (with-selected-window win
+                      (funcall scroll))))))
+          (t
+           (setq magit-currently-shown-commit patch)
+           (display-buffer buf)
+           (with-current-buffer buf
+             (set-buffer buf)
+             (goto-char (point-min))
+             (magit-mode-init dir 'magit-commit-mode
+                              #'magit-stgit--refresh-patch-buffer patch))))))
+
+(magit-add-action (item info "visit")
+  ((series)
+   (magit-stgit--show-patch info)
+   (pop-to-buffer magit-commit-buffer-name)))
+
+(magit-add-action (item info "apply")
+  ((series)
+   (magit-run magit-stgit-executable "goto" info)))
+
+(magit-add-action (item info "discard")
+  ((series)
+   (let ((patch (or magit-stgit--marked-patch info)))
+     (if (yes-or-no-p (format "Delete patch '%s' in series? " patch))
+         (progn
+           (if (string= magit-stgit--marked-patch patch)
+               (setq magit-stgit--marked-patch nil))
+           (magit-run magit-stgit-executable "delete" patch))))))
+
+(defun magit-stgit--set-marked-patch (patch)
+  (setq magit-stgit--marked-patch
+        (if (string= magit-stgit--marked-patch patch)
+            nil
+          patch)))
+
+(magit-add-action (item info "mark")
+  ((series)
+   (magit-stgit--set-marked-patch info)
+   (magit-refresh-all)))
+
+;;; Commands:
+
+(defun magit-stgit-refresh ()
+  "Refresh the contents of a patch in an StGit series.
+If there is no marked patch in the series, refreshes the current
+patch.
+Otherwise, refreshes the marked patch."
+  (interactive)
+  (if magit-stgit--marked-patch
+      (magit-run magit-stgit-executable "refresh" "-p" magit-stgit--marked-patch)
+    (magit-run magit-stgit-executable "refresh")))
+
+(defun magit-stgit-repair ()
+  "Repair StGit metadata if branch was modified with git commands.
+In the case of Git commits these will be imported as new patches
+into the series."
+  (interactive)
+  (message "Repairing series...")
+  (magit-run magit-stgit-executable "repair")
+  (message ""))
+
+(defun magit-stgit-rebase ()
+  "Rebase an StGit patch series."
+  (interactive)
+  (if (magit-get-current-remote)
+      (progn
+        (if (yes-or-no-p "Update remotes? ")
+            (progn
+              (message "Updating remotes...")
+              (magit-run-git-async "remote" "update")))
+        (magit-run magit-stgit-executable "rebase"
+                   (format "remotes/%s/%s"
+                           (magit-get-current-remote)
+                           (magit-get-current-branch))))))
+
+;;;###autoload
+(define-minor-mode magit-stgit-mode "StGit support for Magit"
+  :lighter " Stg" :require 'magit-stgit
+  (or (derived-mode-p 'magit-mode)
+      (error "This mode only makes sense with magit"))
+  (if magit-stgit-mode
+      (progn
+        (add-hook 'magit-after-insert-stashes-hook 'magit-insert-series nil t))
+    (progn
+      (remove-hook 'magit-after-insert-stashes-hook 'magit-insert-series t)))
+  (when (called-interactively-p 'any)
+    (magit-refresh)))
+
+;;;###autoload
+(defun turn-on-magit-stgit ()
+  "Unconditionally turn on `magit-stgit-mode'."
+  (magit-stgit-mode 1))
+
+(provide 'magit-stgit)
+;;; magit-stgit.el ends here

elpa/magit-1.1.1/magit-svn.el

@@ -0,0 +1,240 @@
+;;; magit-svn.el --- git-svn plug-in for Magit
+
+;; Copyright (C) 2008  Alex Ott
+;; Copyright (C) 2009  Alexey Voinov
+;; Copyright (C) 2009  John Wiegley
+;; Copyright (C) 2008  Linh Dang
+;; Copyright (C) 2008  Marcin Bachry
+;; Copyright (C) 2008, 2009  Marius Vollmer
+;; Copyright (C) 2010  Yann Hodique
+;;
+;; Magit is free software; you can redistribute it and/or modify it
+;; under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+;;
+;; Magit is distributed in the hope that it will be useful, but WITHOUT
+;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+;; License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with Magit.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This plug-in provides git-svn functionality as a separate component of Magit
+
+;;; Code:
+
+(require 'magit)
+(eval-when-compile
+  (require 'cl))
+
+;; git svn commands
+
+(defun magit-svn-find-rev (rev &optional branch)
+  (interactive
+   (list (read-string "SVN revision: ")
+         (if current-prefix-arg
+             (read-string "In branch: "))))
+  (let* ((sha (apply 'magit-git-string
+                     `("svn"
+                       "find-rev"
+                       ,(concat "r" rev)
+                       ,@(when branch (list branch))))))
+    (if sha
+        (magit-show-commit
+         (magit-with-section sha 'commit
+           (magit-set-section-info sha)
+           sha))
+      (error "Revision %s could not be mapped to a commit" rev))))
+
+(defun magit-svn-create-branch (name)
+  (interactive "sBranch name: ")
+  (magit-run-git "svn" "branch" name))
+
+(defun magit-svn-rebase ()
+  (interactive)
+  (magit-run-git-async "svn" "rebase"))
+
+(defun magit-svn-dcommit ()
+  (interactive)
+  (magit-run-git-async "svn" "dcommit"))
+
+(defun magit-svn-enabled ()
+  (not (null (magit-svn-get-ref-info t))))
+
+(defun magit-svn-expand-braces-in-branches (branch)
+  (if (not (string-match "\\(.+\\){\\(.+,.+\\)}\\(.*\\):\\(.*\\)\\\*" branch))
+      (list branch)
+    (let ((prefix (match-string 1 branch))
+          (suffix (match-string 3 branch))
+          (rhs (match-string 4 branch))
+          (pieces (split-string (match-string 2 branch) ",")))
+      (mapcar (lambda (p) (concat prefix p suffix ":" rhs p)) pieces))))
+
+(defun magit-svn-get-local-ref (url)
+  (let* ((branches (cons (magit-get "svn-remote" "svn" "fetch")
+                        (magit-get-all "svn-remote" "svn" "branches")))
+         (branches (apply 'nconc
+                          (mapcar 'magit-svn-expand-braces-in-branches
+                                  branches)))
+        (base-url (magit-get "svn-remote" "svn" "url"))
+        (result nil))
+    (while branches
+      (let* ((pats (split-string (pop branches) ":"))
+             (src (replace-regexp-in-string "\\*" "\\\\(.*\\\\)" (car pats)))
+             (dst (replace-regexp-in-string "\\*" "\\\\1" (cadr pats)))
+             (base-url (replace-regexp-in-string "\\+" "\\\\+" base-url))
+             (base-url (replace-regexp-in-string "//.+@" "//" base-url))
+             (pat1 (concat "^" src "$"))
+             (pat2 (cond ((equal src "") (concat "^" base-url "$"))
+                         (t (concat "^" base-url "/" src "$")))))
+        (cond ((string-match pat1 url)
+               (setq result (replace-match dst nil nil url))
+               (setq branches nil))
+              ((string-match pat2 url)
+               (setq result (replace-match dst nil nil url))
+               (setq branches nil)))))
+    result))
+
+(defvar magit-svn-get-ref-info-cache nil
+  "A cache for svn-ref-info.
+As `magit-get-svn-ref-info' might be considered a quite
+expensive operation a cache is taken so that `magit-status'
+doesn't repeatedly call it.")
+
+(defun magit-svn-get-ref-info (&optional use-cache)
+  "Gather details about the current git-svn repository.
+Return nil if there isn't one.  Keys of the alist are ref-path,
+trunk-ref-name and local-ref-name.
+If USE-CACHE is non-nil then return the value of `magit-get-svn-ref-info-cache'."
+  (if (and use-cache magit-svn-get-ref-info-cache)
+      magit-svn-get-ref-info-cache
+    (let* ((fetch (magit-get "svn-remote" "svn" "fetch"))
+           (url)
+           (revision))
+      (when fetch
+        (let* ((ref (cadr (split-string fetch ":")))
+               (ref-path (file-name-directory ref))
+               (trunk-ref-name (file-name-nondirectory ref)))
+          (set (make-local-variable
+                'magit-svn-get-ref-info-cache)
+                (list
+                 (cons 'ref-path ref-path)
+                 (cons 'trunk-ref-name trunk-ref-name)
+                 ;; get the local ref from the log. This is actually
+                 ;; the way that git-svn does it.
+                 (cons 'local-ref
+                       (with-temp-buffer
+                         (insert (or (magit-git-string "log" "--first-parent"
+                                                       "--grep" "git-svn" "-1")
+                                     ""))
+                         (goto-char (point-min))
+                         (cond ((re-search-forward "git-svn-id: \\(.+/.+?\\)@\\([0-9]+\\)" nil t)
+                                (setq url (match-string 1)
+                                      revision (match-string 2))
+                                (magit-svn-get-local-ref url))
+                               (t
+                                (setq url (magit-get "svn-remote" "svn" "url"))
+                                nil))))
+                 (cons 'revision revision)
+                 (cons 'url url))))))))
+
+(defun magit-svn-get-ref (&optional use-cache)
+  "Get the best guess remote ref for the current git-svn based branch.
+If USE-CACHE is non nil, use the cached information."
+  (let ((info (magit-svn-get-ref-info use-cache)))
+    (cdr (assoc 'local-ref info))))
+
+(magit-define-inserter svn-unpulled (&optional use-cache)
+  (when (magit-svn-enabled)
+    (apply #'magit-git-section
+           'svn-unpulled "Unpulled commits (SVN):" 'magit-wash-log "log"
+           (append magit-git-log-options
+                   (list
+                    (format "HEAD..%s" (magit-svn-get-ref use-cache)))))))
+
+(magit-define-inserter svn-unpushed (&optional use-cache)
+  (when (magit-svn-enabled)
+    (apply #'magit-git-section
+           'svn-unpushed "Unpushed commits (SVN):" 'magit-wash-log "log"
+           (append magit-git-log-options
+                   (list
+                    (format "%s..HEAD" (magit-svn-get-ref use-cache)))))))
+
+(magit-define-section-jumper svn-unpushed  "Unpushed commits (SVN)")
+
+(defun magit-svn-remote-string ()
+  (let ((svn-info (magit-svn-get-ref-info)))
+    (when svn-info
+      (concat (cdr (assoc 'url svn-info))
+              " @ "
+              (cdr (assoc 'revision svn-info))))))
+
+(defun magit-svn-remote-update ()
+  (interactive)
+  (when (magit-svn-enabled)
+    (magit-run-git-async "svn" "fetch")))
+
+(easy-menu-define magit-svn-extension-menu
+  nil
+  "Git SVN extension menu"
+  '("Git SVN"
+    :visible magit-svn-mode
+    ["Create branch" magit-svn-create-branch (magit-svn-enabled)]
+    ["Rebase" magit-svn-rebase (magit-svn-enabled)]
+    ["Fetch" magit-svn-remote-update (magit-svn-enabled)]
+    ["Commit" magit-svn-dcommit (magit-svn-enabled)]))
+
+(easy-menu-add-item 'magit-mode-menu
+                    '("Extensions")
+                    magit-svn-extension-menu)
+
+;; add the group and its keys
+(progn
+  ;; (re-)create the group
+  (magit-key-mode-add-group 'svn)
+
+  (magit-key-mode-insert-action 'svn "r" "Rebase" 'magit-svn-rebase)
+  (magit-key-mode-insert-action 'svn "c" "DCommit" 'magit-svn-dcommit)
+  (magit-key-mode-insert-action 'svn "f" "Fetch" 'magit-svn-remote-update)
+  (magit-key-mode-insert-action 'svn "s" "Find rev" 'magit-svn-find-rev)
+  (magit-key-mode-insert-action 'svn "B" "Create branch" 'magit-svn-create-branch)
+
+  ;; generate and bind the menu popup function
+  (magit-key-mode-generate 'svn))
+
+(defvar magit-svn-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map (kbd "N") 'magit-key-mode-popup-svn)
+    map))
+
+;;;###autoload
+(define-minor-mode magit-svn-mode "SVN support for Magit"
+  :lighter " SVN" :require 'magit-svn :keymap 'magit-svn-mode-map
+  (or (derived-mode-p 'magit-mode)
+      (error "This mode only makes sense with magit"))
+  (let ((unpulled-hook (lambda () (magit-insert-svn-unpulled t)))
+        (unpushed-hook (lambda () (magit-insert-svn-unpushed t)))
+        (remote-hook 'magit-svn-remote-string))
+    (if magit-svn-mode
+        (progn
+          (add-hook 'magit-after-insert-unpulled-commits-hook unpulled-hook nil t)
+          (add-hook 'magit-after-insert-unpushed-commits-hook unpushed-hook nil t)
+          (add-hook 'magit-remote-string-hook remote-hook nil t))
+      (progn
+        (remove-hook 'magit-after-insert-unpulled-commits-hook unpulled-hook t)
+        (remove-hook 'magit-after-insert-unpushed-commits-hook unpushed-hook t)
+        (remove-hook 'magit-remote-string-hook remote-hook t)))
+    (when (called-interactively-p 'any)
+      (magit-refresh))))
+
+;;;###autoload
+(defun turn-on-magit-svn ()
+  "Unconditionally turn on `magit-svn-mode'."
+  (magit-svn-mode 1))
+
+(provide 'magit-svn)
+;;; magit-svn.el ends here

elpa/magit-1.1.1/magit-topgit.el

@@ -0,0 +1,191 @@
+;;; magit-topgit.el --- topgit plug-in for Magit
+
+;; Copyright (C) 2010  Nathan Weizenbaum
+;; Copyright (C) 2010  Yann Hodique
+;;
+;; Magit is free software; you can redistribute it and/or modify it
+;; under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+;;
+;; Magit is distributed in the hope that it will be useful, but WITHOUT
+;; ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
+;; or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
+;; License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with Magit.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This plug-in provides topgit functionality as a separate component of Magit
+
+;;; Code:
+
+(require 'magit)
+(eval-when-compile
+  (require 'cl))
+
+(defcustom magit-topgit-executable "tg"
+  "The name of the TopGit executable."
+  :group 'magit
+  :type 'string)
+
+(defcustom magit-topgit-branch-prefix "t/"
+  "Convention prefix for topic branch creation."
+  :group 'magit
+  :type 'string)
+
+(defface magit-topgit-current
+  '((t :weight bold :inherit magit-branch))
+  "Face for section titles."
+  :group 'magit-faces)
+
+;;; Topic branches (using topgit)
+
+(defun magit-topgit-in-topic-p ()
+  (and (file-exists-p ".topdeps")
+       (executable-find magit-topgit-executable)))
+
+(defun magit-topgit-create-branch (branch parent)
+  (when (zerop (or (string-match magit-topgit-branch-prefix branch) -1))
+    (magit-run* (list magit-topgit-executable "create"
+                      branch (magit-rev-to-git parent))
+                nil nil nil t)
+    t))
+
+(defun magit-topgit-pull ()
+  (when (magit-topgit-in-topic-p)
+    (magit-run* (list magit-topgit-executable "update")
+                nil nil nil t)
+    t))
+
+(defun magit-topgit-push ()
+  (when (magit-topgit-in-topic-p)
+    (let* ((branch (or (magit-get-current-branch)
+                       (error "Don't push a detached head.  That's gross")))
+           (remote (magit-get "topgit" "remote"))
+           (push-remote (if (or current-prefix-arg (not remote))
+                            (magit-read-remote (format "Push %s to" branch))
+                          remote)))
+      (when (and (not remote)
+                 (not current-prefix-arg))
+        (magit-set push-remote "topgit" "remote"))
+      (magit-run magit-topgit-executable "push" "-r" push-remote))
+    t))
+
+(defun magit-topgit-remote-update (&optional remote)
+  (when (magit-topgit-in-topic-p)
+    (let* ((remote (magit-get "topgit" "remote"))
+           (remote-update (if (or current-prefix-arg (not remote))
+                              (magit-read-remote)
+                            remote)))
+      (if (and (not remote)
+               (not current-prefix-arg))
+          (progn
+            (magit-set remote-update "topgit" "remote")
+            (magit-run magit-topgit-executable "remote"
+                       "--populate" remote-update)))
+      (magit-run magit-topgit-executable "remote" remote-update))
+    ;; We return nil anyway, as we also want regular "git remote update" to
+    ;; happen
+    nil))
+
+(defun magit-topgit-parse-flags (flags-string)
+  (let ((flags (string-to-list flags-string))
+        (void-flag ?\ ))
+    (list :current (not (eq (nth 0 flags) void-flag))
+          :empty (not (eq (nth 1 flags) void-flag)))))
+
+(defun magit-topgit-wash-topic ()
+  (let ((fmt "^\\(.\\{7\\}\\)\\s-\\(\\S-+\\)\\s-+\\(.*\\)"))
+    (if (search-forward-regexp fmt (line-end-position) t)
+        (let ((flags (magit-topgit-parse-flags (match-string 1)))
+              (topic (match-string 2)))
+          (goto-char (line-beginning-position))
+          (delete-char 8)
+          (insert "\t")
+          (goto-char (line-beginning-position))
+          (magit-with-section topic 'topic
+            (magit-set-section-info topic)
+            (let ((beg (1+ (line-beginning-position)))
+                  (end (line-end-position)))
+              (when (plist-get flags :current)
+                (put-text-property beg end 'face 'magit-topgit-current))
+              (when (plist-get flags :empty)
+                (put-text-property beg end 'face `(:strike-through t :inherit ,(get-text-property beg 'face)))))
+            (forward-line)))
+      (delete-region (line-beginning-position) (1+ (line-end-position))))
+    t))
+
+(defun magit-topgit-wash-topics ()
+  (let ((magit-old-top-section nil))
+    (magit-wash-sequence #'magit-topgit-wash-topic)))
+
+(defun magit-topgit-section (section title washer &rest args)
+  (when (executable-find magit-topgit-executable)
+    (let ((magit-git-executable magit-topgit-executable)
+          (magit-git-standard-options nil))
+      (apply 'magit-git-section section title washer args))))
+
+(magit-define-inserter topics ()
+  (magit-topgit-section 'topics
+                        "Topics:" 'magit-topgit-wash-topics
+                        "summary"))
+
+(magit-add-action (item info "discard")
+  ((topic)
+   (when (yes-or-no-p "Discard topic? ")
+     (magit-run* (list magit-topgit-executable "delete" "-f" info)
+                 nil nil nil t))))
+
+(magit-add-action (item info "visit")
+  ((topic)
+   (magit-checkout info)))
+
+(defun magit-topgit-get-top-bases-color (suffix)
+  (list nil nil))
+
+(defun magit-topgit-get-remote-top-bases-color (suffix)
+  (when (string-match "^\\(?:[^/]+\\)/top-bases" suffix)
+    (list nil nil)))
+
+(defconst magit-topgit-ignored-namespace
+  '("top-bases" magit-topgit-get-top-bases-color))
+
+;;;###autoload
+(define-minor-mode magit-topgit-mode "Topgit support for Magit"
+  :lighter " Topgit" :require 'magit-topgit
+  (or (derived-mode-p 'magit-mode)
+      (error "This mode only makes sense with magit"))
+  (if magit-topgit-mode
+      (progn
+        (add-hook 'magit-after-insert-stashes-hook 'magit-insert-topics nil t)
+        (add-hook 'magit-create-branch-command-hook 'magit-topgit-create-branch nil t)
+        (add-hook 'magit-pull-command-hook 'magit-topgit-pull nil t)
+        (add-hook 'magit-remote-update-command-hook 'magit-topgit-remote-update nil t)
+        (add-hook 'magit-push-command-hook 'magit-topgit-push nil t)
+        ;; hide refs for top-bases namespace in any remote
+        (add-hook 'magit-log-remotes-color-hook
+                  'magit-topgit-get-remote-top-bases-color)
+        ;; hide refs in the top-bases namespace, as they're not meant for the user
+        (add-to-list 'magit-refs-namespaces magit-topgit-ignored-namespace))
+    (progn
+        (remove-hook 'magit-after-insert-stashes-hook 'magit-insert-topics t)
+        (remove-hook 'magit-create-branch-command-hook 'magit-topgit-create-branch t)
+        (remove-hook 'magit-pull-command-hook 'magit-topgit-pull t)
+        (remove-hook 'magit-remote-update-command-hook 'magit-topgit-remote-update t)
+        (remove-hook 'magit-push-command-hook 'magit-topgit-push t)
+        (remove-hook 'magit-log-remotes-color-hook
+                     'magit-topgit-get-remote-top-bases-color)
+        (delete magit-topgit-ignored-namespace magit-refs-namespaces)))
+  (when (called-interactively-p 'any)
+    (magit-refresh)))
+
+;;;###autoload
+(defun turn-on-magit-topgit ()
+  "Unconditionally turn on `magit-topgit-mode'."
+  (magit-topgit-mode 1))
+
+(provide 'magit-topgit)
+;;; magit-topgit.el ends here

elpa/mo-git-blame-0.1.0/mo-git-blame-autoloads.el

@@ -0,0 +1,47 @@
+;;; mo-git-blame-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+
+;;;### (autoloads (mo-git-blame-current mo-git-blame-file) "mo-git-blame"
+;;;;;;  "mo-git-blame.el" (20540 9020))
+;;; Generated autoloads from mo-git-blame.el
+
+(autoload 'mo-git-blame-file "mo-git-blame" "\
+Calls `git blame' for REVISION of FILE-NAME or `HEAD' if
+REVISION is not given. Initializes the two windows that will show
+the output of 'git blame' and the content.
+
+If FILE-NAME is missing it will be read with `find-file' in
+interactive mode.
+
+ORIGINAL-FILE-NAME defaults to FILE-NAME if not given. This is
+used for tracking renaming and moving of files during iterative
+re-blaming.
+
+With a numeric prefix argument or with NUM-LINES-TO-BLAME only
+the NUM-LINES-TO-BLAME lines before and after point are blamed by
+using git blame's `-L' option. Otherwise the whole file is
+blamed.
+
+\(fn &optional FILE-NAME REVISION ORIGINAL-FILE-NAME NUM-LINES-TO-BLAME)" t nil)
+
+(autoload 'mo-git-blame-current "mo-git-blame" "\
+Calls `mo-git-blame-file' for HEAD for the current buffer.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil nil ("mo-git-blame-pkg.el") (20540 9020 314042))
+
+;;;***
+
+(provide 'mo-git-blame-autoloads)
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; coding: utf-8
+;; End:
+;;; mo-git-blame-autoloads.el ends here

elpa/mo-git-blame-0.1.0/mo-git-blame-pkg.el

@@ -0,0 +1 @@
+(define-package "mo-git-blame" "0.1.0" "An interactive, iterative 'git blame' mode for Emacs" (quote nil))

elpa/mo-git-blame-0.1.0/mo-git-blame.el

@@ -0,0 +1,762 @@
+;;; mo-git-blame.el --- An interactive, iterative 'git blame' mode for Emacs
+
+;; Copyright (C) 2009, 2010  Moritz Bunkus <moritz@bunkus.org>
+;; Copyright (C) 2010  `tpán Nmec <stepnem@gmail.com>
+
+;; Author: Moritz Bunkus <moritz@bunkus.org>
+;; Maintainer: Moritz Bunkus <moritz@bunkus.org>
+;; Version: 0.1.0
+;; Keywords: tools
+;; URL: https://github.com/mbunkus/mo-git-blame
+
+;; mo-git-blame is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License as
+;; published by the Free Software Foundation; either version 3, or (at
+;; your option) any later version.
+;;
+;; mo-git-blame is distributed in the hope that it will be useful, but
+;; WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+;; General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
+
+;;; Installation:
+;;;
+;;; Put this file somewhere in your load-path or add the directory it
+;;; is in to it, e.g.:
+;;;
+;;; (add-to-list 'load-path "~/.emacs.d/mo-git-blame")
+;;;
+;;; Then add two autoload definitions:
+;;;
+;;; (autoload 'mo-git-blame-file "mo-git-blame" nil t)
+;;; (autoload 'mo-git-blame-current "mo-git-blame" nil t)
+
+(require 'cl)
+(require 'easymenu)
+
+(defvar mo-git-blame-vars nil
+  "Buffer-local plist that stores various variables needed for
+interactive use, e.g. the file name, current revision etc.")
+
+(defvar mo-git-blame--wincfg nil)
+
+(defvar mo-git-blame-mode-map
+  (let ((map (make-keymap)))
+    (suppress-keymap map t)
+    (define-key map (kbd "a") 'mo-git-blame-reblame-for-ancestor-of-revision-at)
+    (define-key map (kbd "A") 'mo-git-blame-reblame-for-ancestor-of-current-revision)
+    (define-key map (kbd "b") 'mo-git-blame-reblame-for-revision-at)
+    (define-key map (kbd "B") 'mo-git-blame-reblame-for-specific-revision)
+    (define-key map (kbd "c") 'mo-git-blame-content-for-revision-at)
+    (define-key map (kbd "i") 'mo-git-blame-display-info)
+    (define-key map (kbd "l") 'mo-git-blame-log-for-revision-at)
+    (define-key map (kbd "L") 'mo-git-blame-log-for-current-revision)
+    (define-key map (kbd "o") 'mo-git-blame-overwrite-file-with-revision-at)
+    (define-key map (kbd "O") 'mo-git-blame-overwrite-file-with-current-revision)
+    (define-key map (kbd "p") 'mo-git-blame-reblame-for-prior-revision)
+    (define-key map (kbd "q") 'mo-git-blame-quit)
+    (define-key map (kbd "s") 'mo-git-blame-show-revision-at)
+    (define-key map (kbd "S") 'mo-git-blame-show-current-revision)
+    (define-key map (kbd "RET") 'mo-git-blame-show-revision-at)
+    (define-key map (kbd "TAB") 'mo-git-blame-display-content-buffer)
+    (define-key map [?\C-x ?k] 'mo-git-blame-quit)
+    (define-key map [?\C-x ?\C-l] 'mo-git-blame-goto-line)
+    map)
+  "The mode map for the blame output window of mo-git-blame-mode.")
+
+(defvar mo-git-blame-content-mode-map
+  (let ((map (make-keymap)))
+    (suppress-keymap map t)
+    (define-key map (kbd "A") 'mo-git-blame-reblame-for-ancestor-of-current-revision)
+    (define-key map (kbd "B") 'mo-git-blame-reblame-for-specific-revision)
+    (define-key map (kbd "i") 'mo-git-blame-display-info)
+    (define-key map (kbd "L") 'mo-git-blame-log-for-current-revision)
+    (define-key map (kbd "O") 'mo-git-blame-overwrite-file-with-current-revision)
+    (define-key map (kbd "q") 'mo-git-blame-quit)
+    (define-key map (kbd "S") 'mo-git-blame-show-current-revision)
+    (define-key map [?\C-x ?k] 'mo-git-blame-quit)
+    (define-key map [?\C-x ?\C-l] 'mo-git-blame-goto-line)
+    map)
+  "The mode map for the content window of mo-git-blame-mode.")
+
+(easy-menu-define mo-git-blame-mode-menu mo-git-blame-mode-map
+  "MoGitBlame menu"
+  '("MoGitBlame"
+    ["Re-blame for revision at point" mo-git-blame-reblame-for-revision-at t]
+    ["Re-blame for ancestor of revision at point" mo-git-blame-reblame-for-ancestor-of-revision-at-point t]
+    ["Raw content for revision at point" mo-git-blame-content-for-revision-at t]
+    ["Log for revision at point" mo-git-blame-log-for-revision-at t]
+    ["Overwrite file with revision at point" mo-git-blame-overwrite-file-with-revision-at t]
+    ["'git show' for revision at point" mo-git-blame-show-revision-at t]
+    "---"
+    ["Re-blame for ancestor of current revision" mo-git-blame-reblame-for-ancestor-of-current-revision t]
+    ["Log for current revision" mo-git-blame-log-for-current-revision t]
+    ["Overwrite file with current revision" mo-git-blame-overwrite-file-with-current-revision t]
+    ["'git show' for current revision" mo-git-blame-show-current-revision t]
+    "---"
+    ["Re-blame for prior revision" mo-git-blame-reblame-for-prior-revision t]
+    ["Re-blame for a specific revision" mo-git-blame-reblame-for-specific-revision t]
+    "---"
+    ["Display status information" mo-git-blame-display-info t]
+    ["Display content buffer" mo-git-blame-display-content-buffer t]
+    "---"
+    ["Exit MoGitBlame" mo-git-blame-quit t]))
+
+(defgroup mo-git-blame nil
+  "Interactively use Git's 'blame' from Emacs."
+  :prefix "mo-git-blame-"
+  :group 'tools)
+
+(defcustom mo-git-blame-git-executable "git"
+  "The name of the Git executable."
+  :group 'mo-git-blame
+  :type 'string)
+
+(defcustom mo-git-blame-incremental t
+  "Runs `git blame' in the background with the --incremental
+option if this variable is non-nil."
+  :group 'mo-git-blame
+  :type '(choice (const :tag "Use --incremental" t)
+                 (const :tag "Don't use --incremental" nil)))
+
+(defcustom mo-git-blame-blame-window-width 45
+  "The width of the 'blame' window leaving the rest for the
+'content' window."
+  :group 'mo-git-blame
+  :type 'integer)
+
+(defcustom mo-git-blame-use-ido 'if-available
+  "Controls whether or not ido will be used. Possible choices:
+
+  `never'        -- do not use ido even if it is loaded
+  `if-available' -- use ido if it has been loaded before
+  `always'       -- automatically load ido and use it"
+  :group 'mo-git-blame
+  :type '(choice (const :tag "Always" always)
+                 (const :tag "If available" if-available)
+                 (const :tag "Never" never)))
+
+;; This function was taken from magit (called 'magit-trim-line' there).
+(defun mo-git-blame-trim-line (str)
+  (cond ((string= str "")
+         nil)
+        ((equal (elt str (- (length str) 1)) ?\n)
+         (substring str 0 (- (length str) 1)))
+        (t str)))
+
+;; This function was taken from magit (called 'magit-git-output' there).
+(defun mo-git-blame-git-output (args)
+  (with-output-to-string
+    (with-current-buffer standard-output
+      (apply #'process-file
+             mo-git-blame-git-executable
+             nil (list t nil) nil
+             args))))
+
+;; This function was taken from magit (called 'magit-git-string' there).
+(defun mo-git-blame-git-string (&rest args)
+  (mo-git-blame-trim-line (mo-git-blame-git-output args)))
+
+(defun mo-git-blame-get-top-dir (cwd)
+  (let ((cwd (expand-file-name cwd))
+        git-dir)
+    (setq git-dir
+          (or (getenv "GIT_WORK_TREE")
+              (if (file-directory-p cwd)
+                  (let* ((default-directory cwd)
+                         (dir (mo-git-blame-git-string "rev-parse" "--git-dir"))
+                         (dir (if dir (file-name-directory (expand-file-name dir)) "")))
+                    (if (and dir (file-directory-p dir))
+                        (file-name-as-directory dir))))))
+    (or git-dir
+        (error "No Git repository found"))))
+
+(defun mo-git-blame-run (&rest args)
+  (message "Running 'git %s'..." (car args))
+  (apply 'call-process mo-git-blame-git-executable nil (current-buffer) nil args)
+  (message "Running 'git %s'... done" (car args)))
+
+(defvar mo-git-blame-process nil)
+(defvar mo-git-blame-client-buffer nil)
+
+(defun mo-git-blame-assert-not-running ()
+  "Exits with an error if `mo-git-blame-incremental' is true and
+git is already/still running."
+  (if (and mo-git-blame-incremental
+           mo-git-blame-process
+           (get-buffer "*mo-git-blame-process*"))
+      (error "Git is already running")))
+
+(defun mo-git-blame-process-sentinel (process event)
+  (let ((msg (format "Git %s." (substring event 0 -1)))
+        (successp (string-match "^finished" event)))
+    (with-current-buffer (process-buffer process)
+      (let ((inhibit-read-only t))
+        (goto-char (point-max))
+        (insert msg "\n")
+        (message msg)))
+    (setq mo-git-blame-process nil)
+    (message "Running 'git blame'... done")))
+
+(defun mo-git-blame-commit-info-to-time (entry)
+  (let* ((tz (plist-get entry :author-tz))
+         (mult (if (string= "+" (substring tz 0 1)) 1 -1))
+         (hours (string-to-number (substring tz 1 3)))
+         (minutes (string-to-number (substring tz 3 5))))
+    (seconds-to-time (+ (string-to-number (plist-get entry :author-time))
+                        (* mult
+                           (+ (* minutes 60)
+                              (* hours 3600)))))))
+
+(defun mo-git-blame-process-filter-process-entry (entry)
+  (with-current-buffer (plist-get mo-git-blame-vars :blame-buffer)
+    (save-excursion
+      (let ((inhibit-read-only t)
+            (info (format "%s (%s %s %s) %s"
+                          (substring (symbol-name (plist-get entry :hash)) 0 8)
+                          (plist-get entry :author)
+                          (format-time-string "%Y-%m-%d %T" (mo-git-blame-commit-info-to-time entry) t)
+                          (plist-get entry :author-tz)
+                          (plist-get entry :filename)))
+            i)
+        (mo-git-blame-goto-line-markless (plist-get entry :result-line))
+        (dotimes (i (plist-get entry :num-lines))
+          (insert info)
+          (goto-char (line-beginning-position 2)))))))
+
+(defun mo-git-blame-set-entry (key value)
+  (let ((plist (or (plist-get mo-git-blame-data mo-git-blame-curr-entry)
+                   (list :hash mo-git-blame-curr-entry))))
+    (setq mo-git-blame-data
+          (plist-put mo-git-blame-data
+                     mo-git-blame-curr-entry
+                     (plist-put plist key value)))))
+
+(defun mo-git-blame-process-filter (process string)
+  (with-current-buffer (process-buffer process)
+    (let ((inhibit-read-only t)
+          done matched)
+      (save-excursion
+        (goto-char (process-mark process))
+        (insert string)
+        (set-marker (process-mark process) (point)))
+      (while (not done)
+        (goto-char (line-end-position))
+        (setq done (= (point) (point-max)))
+        (goto-char (line-beginning-position))
+        (unless done
+          (setq matched t)
+          (cond ((and (not mo-git-blame-curr-entry)
+                      (looking-at "^\\([a-fA-F0-9]\\{40\\}\\) +\\([0-9]+\\) +\\([0-9]+\\) +\\([0-9]+\\)$"))
+                 ;; SHA line, beginning of entry
+                 (setq mo-git-blame-curr-entry (intern (buffer-substring-no-properties (match-beginning 1) (match-end 1))))
+                 (mo-git-blame-set-entry :source-line (string-to-number (buffer-substring-no-properties (match-beginning 2) (match-end 2))))
+                 (mo-git-blame-set-entry :result-line (string-to-number (buffer-substring-no-properties (match-beginning 3) (match-end 3))))
+                 (mo-git-blame-set-entry :num-lines (string-to-number (buffer-substring-no-properties (match-beginning 4) (match-end 4))))
+                 )
+
+                ((and mo-git-blame-curr-entry
+                      (looking-at "^filename +\\(.+\\)$"))
+                 ;; filename line, end of entry
+                 (mo-git-blame-set-entry :filename (buffer-substring-no-properties (match-beginning 1) (match-end 1)))
+                 (mo-git-blame-process-filter-process-entry (plist-get mo-git-blame-data mo-git-blame-curr-entry))
+                 (setq mo-git-blame-curr-entry nil)
+                 )
+                ((and mo-git-blame-curr-entry
+                      (looking-at "^\\([a-zA-Z0-9-]+\\) +\\(.+\\)$"))
+                 ;; property line
+                 (mo-git-blame-set-entry (intern (concat ":" (buffer-substring-no-properties (match-beginning 1) (match-end 1))))
+                                         (buffer-substring-no-properties (match-beginning 2) (match-end 2)))
+                 )
+
+                (t (setq matched nil)))
+          (forward-line 1))))))
+
+(defun mo-git-blame-run* (&rest args)
+  (message "Running 'git blame'...")
+  (let ((buf (get-buffer-create "*mo-git-blame-process*"))
+        (cmd (car args))
+        (dir default-directory)
+        (vars mo-git-blame-vars))
+    (save-excursion
+      (set-buffer buf)
+      (setq buffer-read-only t)
+      (let ((inhibit-read-only t))
+        (set (make-local-variable 'mo-git-blame-data) nil)
+        (set (make-local-variable 'mo-git-blame-curr-entry) nil)
+        (set (make-local-variable 'mo-git-blame-vars) vars)
+        (setq default-directory dir
+              mo-git-blame-process (apply 'start-file-process cmd buf mo-git-blame-git-executable args))
+        (set-process-sentinel mo-git-blame-process 'mo-git-blame-process-sentinel)
+        (set-process-filter mo-git-blame-process 'mo-git-blame-process-filter)))))
+
+(defun mo-git-blame-get-output-buffer ()
+  (let* ((name "*mo-git-blame-output*")
+         (buffer (get-buffer name)))
+    (if (null buffer)
+        (progn
+          (setq buffer (get-buffer-create name))
+          (with-current-buffer buffer
+            (use-local-map mo-git-blame-mode-map))))
+    buffer))
+
+(defun mo-git-blame-parse-rev (revision)
+  (let ((result (mo-git-blame-git-string "rev-parse" "--short" revision)))
+    (unless result
+      (error "Unparseable revision %s" revision))
+    result))
+
+(defun mo-git-blame-parse-blame-line ()
+  (save-excursion
+    (save-match-data
+      (beginning-of-line)
+      (cond ((looking-at "^\\([a-f0-9]+\\) +\\(([^)]+)\\) *$")
+             (list :hash (buffer-substring (match-beginning 1) (match-end 1))
+                   :file-name (plist-get mo-git-blame-vars :file-name)
+                   :timestamp (buffer-substring (match-beginning 2) (match-end 2))))
+            ((looking-at "^\\([a-f0-9]+\\) +\\(([^)]+)\\) +\\(.+\\)")
+             (list :hash (buffer-substring (match-beginning 1) (match-end 1))
+                   :file-name (buffer-substring (match-beginning 3) (match-end 3))
+                   :timestamp (buffer-substring (match-beginning 2) (match-end 2))))
+            (t (error "Not a 'git blame' line"))))))
+
+(defun mo-git-blame-revision-at-point ()
+  (plist-get (mo-git-blame-parse-blame-line) :hash))
+
+(defun mo-git-blame-log-for-revision (revision)
+  (let ((file-name (plist-get mo-git-blame-vars :file-name))
+        (buffer (mo-git-blame-get-output-buffer)))
+    (with-current-buffer buffer
+      (erase-buffer)
+      (mo-git-blame-run "log" revision "--" file-name)
+      (goto-char (point-min)))
+    (display-buffer buffer)))
+
+(defun mo-git-blame-log-for-revision-at ()
+  "Calls 'git log' for revision in the current line."
+  (interactive)
+  (mo-git-blame-log-for-revision (mo-git-blame-revision-at-point)))
+
+(defun mo-git-blame-log-for-current-revision ()
+  "Calls 'git log' for the buffer's current revision and file."
+  (interactive)
+  (mo-git-blame-log-for-revision (plist-get mo-git-blame-vars :current-revision)))
+
+(defun mo-git-blame-show-revision (revision)
+  (let ((buffer (mo-git-blame-get-output-buffer)))
+    (with-current-buffer buffer
+      (erase-buffer)
+      (mo-git-blame-run "show" revision)
+      (goto-char (point-min))
+      (diff-mode))
+    (display-buffer buffer)))
+
+(defun mo-git-blame-show-revision-at ()
+  "Calls 'git show' for the revision in the current line."
+  (interactive)
+  (mo-git-blame-show-revision (mo-git-blame-revision-at-point)))
+
+(defun mo-git-blame-show-current-revision ()
+  "Calls 'git show' for the current revision."
+  (interactive)
+  (mo-git-blame-show-revision (plist-get mo-git-blame-vars :current-revision)))
+
+(defun mo-git-blame-content-for-revision-at ()
+  "Calls 'git cat-file' for the revision in the current line."
+  (interactive)
+  (let ((info (mo-git-blame-parse-blame-line))
+        (buffer (mo-git-blame-get-output-buffer)))
+    (with-current-buffer buffer
+      (erase-buffer)
+      (mo-git-blame-run "cat-file" "blob" (concat (plist-get info :hash) ":" (plist-get info :file-name)))
+      (goto-char (point-min)))
+    (display-buffer buffer)))
+
+(defun mo-git-blame-overwrite-file-with-revision (revision)
+  (let ((file-name (plist-get mo-git-blame-vars :original-file-name)))
+    (if (yes-or-no-p (format "Do you really want to overwrite %s with revision %s " file-name revision))
+        (progn
+          (find-file (concat (plist-get mo-git-blame-vars :top-dir) file-name))
+          (erase-buffer)
+          (mo-git-blame-run "cat-file" "blob" (concat revision ":" file-name))
+          (goto-char (point-min))))))
+
+(defun mo-git-blame-overwrite-file-with-revision-at ()
+  "Calls 'git cat-file' for the revision in the current line and overwrites
+the original file's content. The file is not saved but left modified in an
+open buffer."
+  (interactive)
+  (mo-git-blame-overwrite-file-with-revision (mo-git-blame-revision-at-point)))
+
+(defun mo-git-blame-overwrite-file-with-current-revision ()
+  "Calls 'git cat-file' for the current revision and overwrites
+the original file's content. The file is not saved but left modified in an
+open buffer."
+  (interactive)
+  (mo-git-blame-overwrite-file-with-revision (plist-get mo-git-blame-vars :current-revision)))
+
+(defun mo-git-blame-reblame-for-ancestor-of-revision-at (&optional arg)
+  "Calls 'git blame' for the ancestor of the revision in the current line.
+
+With a numeric prefix argument ARG only the ARG lines before and
+after point are blamed by using git blame's `-L'
+option. Otherwise the whole file is blamed."
+  (interactive "P")
+  (mo-git-blame-reblame-for-specific-revision (mo-git-blame-parse-rev (concat (plist-get (mo-git-blame-parse-blame-line) :hash) "~")) arg))
+
+(defun mo-git-blame-reblame-for-ancestor-of-current-revision (&optional arg)
+  "Calls 'git blame' for the ancestor of the current revision.
+
+With a numeric prefix argument ARG only the ARG lines before and
+after point are blamed by using git blame's `-L'
+option. Otherwise the whole file is blamed."
+  (interactive "P")
+  (mo-git-blame-reblame-for-specific-revision (mo-git-blame-parse-rev (concat (plist-get mo-git-blame-vars :current-revision) "~")) arg))
+
+(defun mo-git-blame-reblame-for-revision-at (&optional arg)
+  "Calls 'git blame' for the revision in the current line.
+
+With a numeric prefix argument ARG only the ARG lines before and
+after point are blamed by using git blame's `-L'
+option. Otherwise the whole file is blamed."
+  (interactive "P")
+  (let* ((info (mo-git-blame-parse-blame-line))
+         (revision (plist-get info :hash)))
+    (if (string= revision (plist-get mo-git-blame-vars :current-revision))
+        (error "Already showing this revision"))
+    (mo-git-blame-file (concat (plist-get mo-git-blame-vars :top-dir) (plist-get info :file-name)) revision (plist-get mo-git-blame-vars :original-file-name) arg)))
+
+(defun mo-git-blame-reblame-for-specific-revision (&optional revision arg)
+  "Calls 'git blame' for a specific REVISION.
+
+With a numeric prefix argument ARG only the ARG lines before and
+after point are blamed by using git blame's `-L'
+option. Otherwise the whole file is blamed."
+  (interactive "sRevision: \nP")
+  (setq revision (mo-git-blame-parse-rev revision))
+  (if (string= revision (plist-get mo-git-blame-vars :current-revision))
+      (error "Already showing this revision"))
+  (mo-git-blame-file (concat (plist-get mo-git-blame-vars :top-dir) (plist-get mo-git-blame-vars :file-name)) revision (plist-get mo-git-blame-vars :original-file-name) arg))
+
+(defun mo-git-blame-reblame-for-prior-revision (&optional arg)
+  "Calls 'git blame' for the revision shown before the current
+one (see `prior revisions' in the info output of
+`mo-git-blame-display-info').
+
+With a numeric prefix argument ARG only the ARG lines before and
+after point are blamed by using git blame's `-L'
+option. Otherwise the whole file is blamed."
+  (interactive "P")
+  (let ((rev-list (plist-get mo-git-blame-vars :prior-revisions))
+        revision-plist)
+    (unless rev-list
+      (error "No revision shown prior to the current one"))
+    (setq revision-plist (car rev-list))
+    (mo-git-blame-file (plist-get revision-plist :full-file-name)
+                       (plist-get revision-plist :revision)
+                       (plist-get mo-git-blame-vars :original-file-name)
+                       arg)))
+
+(defun mo-git-blame-display-info ()
+  "Displays short information about the current revision."
+  (interactive)
+  (let* ((buffer (mo-git-blame-get-output-buffer))
+         (vars mo-git-blame-vars)
+         (prior-revs (plist-get vars :prior-revisions))
+         (prior-revs-str (if prior-revs
+                             (reduce (lambda (joined element) (concat (or joined "") (if joined " " "") element))
+                                     (mapcar (lambda (element) (plist-get element :revision))
+                                             prior-revs))
+                           "none")))
+    (with-current-buffer buffer
+      (erase-buffer)
+      (insert (format "Current revision:   %s\n" (plist-get vars :current-revision))
+              (format "Prior revisions:    %s\n" prior-revs-str)
+              (format "Git repository:     %s\n" (plist-get vars :top-dir))
+              (format "Original file name: %s\n" (file-relative-name (plist-get vars :original-file-name)
+                                                                     (plist-get vars :top-dir)))
+              (format "Current file name:  %s\n" (plist-get vars :file-name)))
+      (goto-char (point-min)))
+    (display-buffer buffer)))
+
+(defun mo-git-blame-number-of-content-lines ()
+  (with-current-buffer (plist-get mo-git-blame-vars :content-buffer)
+    (save-excursion
+      (goto-char (point-max))
+      (line-number-at-pos))))
+
+(defun mo-git-blame-mode ()
+  "Show the output of 'git blame' and the content of the file in
+two frames side-by-side. Allows iterative re-blaming for specific
+revisions. Can show the output of 'git log' and 'git show'. Can
+overwrite the file with the content of specific revisions by
+calling 'git cat-file blob ...'.
+
+Use 'mo-git-blame-current' interactively or 'mo-git-blame-file'
+from elisp.
+
+\\{mo-git-blame-mode-map}"
+  (setq major-mode 'mo-git-blame-mode
+        mode-name "MoGitBlame"
+        mode-line-process ""
+        truncate-lines t)
+  (use-local-map mo-git-blame-mode-map))
+
+(defun mo-git-blame-run-blame-normally (start-line lines-to-blame)
+  (let* ((num-content-lines (mo-git-blame-number-of-content-lines))
+         (num-lines-to-append (if (and start-line
+                                       (< (+ start-line lines-to-blame)
+                                          num-content-lines))
+                                  (- num-content-lines start-line lines-to-blame)))
+         args i)
+    (if (and start-line (> start-line 1))
+        (dotimes (i (1- start-line))
+          (insert "\n")))
+
+    (setq args (list (plist-get mo-git-blame-vars :current-revision) "--" (plist-get mo-git-blame-vars :file-name)))
+    (if start-line
+        (setq args (append (list "-L" (format "%d,+%d" start-line lines-to-blame))
+                           args)))
+    (apply 'mo-git-blame-run "blame" args)
+
+    (if num-lines-to-append
+        (dotimes (i num-lines-to-append)
+          (insert "\n")))))
+
+(defun mo-git-blame-run-blame-incrementally (start-line lines-to-blame)
+  (let* ((num-content-lines (mo-git-blame-number-of-content-lines))
+         i)
+    (dotimes (i (1- num-content-lines))
+      (insert "\n"))
+
+    (setq args (list "--incremental" (plist-get mo-git-blame-vars :current-revision) "--" (plist-get mo-git-blame-vars :file-name)))
+    (if start-line
+        (setq args (append (list "-L" (format "%d,+%d" start-line lines-to-blame))
+                           args)))
+    (mo-git-blame-assert-not-running)
+    (apply 'mo-git-blame-run* "blame" args)))
+
+(defun mo-git-blame-init-blame-buffer (start-line lines-to-blame)
+  (if mo-git-blame-incremental
+      (mo-git-blame-run-blame-incrementally start-line lines-to-blame)
+    (mo-git-blame-run-blame-normally start-line lines-to-blame))
+  (goto-char (point-min))
+  (save-match-data
+    (while (re-search-forward "^\\([a-f0-9]+\\) +\\(([^)]+)\\) \\(.*\\)" nil t)
+      (replace-match "\\1 \\2" nil nil))
+    (goto-char (point-min))
+    (while (re-search-forward "^\\([a-f0-9]+\\) +\\([^ ]+\\) +\\(([^)]+)\\) \\(.*\\)" nil t)
+      (replace-match "\\1 \\3 \\2" nil nil))
+    (goto-char (point-min))
+    (while (re-search-forward " +[0-9]+)" nil t)
+      (replace-match ")" nil nil)))
+  (toggle-read-only t)
+  (goto-char (point-min))
+  (set (make-local-variable 'line-move-visual) nil))
+
+(defun mo-git-blame-init-content-buffer ()
+  (let ((vars mo-git-blame-vars))
+    (rename-buffer (concat "*mo-git-blame:" (file-name-nondirectory (plist-get vars :full-file-name)) ":" (plist-get vars :current-revision) "*"))
+    (setq buffer-file-name (file-name-nondirectory (plist-get vars :full-file-name))
+          default-directory (plist-get vars :top-dir))
+    (mo-git-blame-run "cat-file" "blob" (concat (plist-get vars :current-revision) ":" (plist-get vars :file-name)))
+    (normal-mode)
+    (use-local-map mo-git-blame-content-mode-map)
+    (font-lock-fontify-buffer)
+    (toggle-read-only t)
+    (set-buffer-modified-p nil)
+    (setq truncate-lines t)
+    (set (make-local-variable 'mo-git-blame-vars) vars)
+    (set (make-local-variable 'line-move-visual) nil)))
+
+(defun mo-git-blame-read-file-name ()
+  "Calls `read-file-name' or `ido-read-file-name' depending on
+the value of `mo-git-blame-use-ido'."
+  (let ((the-func (cond ((eq mo-git-blame-use-ido 'always)
+                         (require 'ido)
+                         'ido-read-file-name)
+                        ((and (eq mo-git-blame-use-ido 'if-available)
+                              (functionp 'ido-read-file-name))
+                         'ido-read-file-name)
+                        (t 'read-file-name))))
+    (funcall the-func "File for 'git blame': " nil nil t)))
+
+;;;###autoload
+(defun mo-git-blame-file (&optional file-name revision original-file-name num-lines-to-blame)
+  "Calls `git blame' for REVISION of FILE-NAME or `HEAD' if
+REVISION is not given. Initializes the two windows that will show
+the output of 'git blame' and the content.
+
+If FILE-NAME is missing it will be read with `find-file' in
+interactive mode.
+
+ORIGINAL-FILE-NAME defaults to FILE-NAME if not given. This is
+used for tracking renaming and moving of files during iterative
+re-blaming.
+
+With a numeric prefix argument or with NUM-LINES-TO-BLAME only
+the NUM-LINES-TO-BLAME lines before and after point are blamed by
+using git blame's `-L' option. Otherwise the whole file is
+blamed."
+  (interactive)
+  (mo-git-blame-assert-not-running)
+  (unless mo-git-blame--wincfg
+    (setq mo-git-blame--wincfg (current-window-configuration)))
+  (let* ((file-name (or file-name (mo-git-blame-read-file-name)))
+         (has-blame-vars (local-variable-p 'mo-git-blame-vars))
+         (the-raw-revision (or revision "HEAD"))
+         (the-revision (if (string= the-raw-revision "HEAD")
+                           (mo-git-blame-parse-rev "HEAD")
+                         the-raw-revision))
+         (base-name (concat (file-name-nondirectory file-name) "@" the-revision))
+         (blame-buffer (get-buffer-create "*mo-git-blame*"))
+         (content-buffer-name (concat "*mo-git-blame:" (file-name-nondirectory file-name) ":" the-revision "*"))
+         (content-buffer (if has-blame-vars
+                             (plist-get mo-git-blame-vars :content-buffer)
+                           (get-buffer-create content-buffer-name)))
+         (top-dir (mo-git-blame-get-top-dir (file-name-directory file-name)))
+         (relative-file-name (file-relative-name file-name top-dir))
+         (blame-window (selected-window))
+         (prior-vars (if has-blame-vars mo-git-blame-vars))
+         (line-to-go-to (line-number-at-pos))
+         (lines-to-blame (or num-lines-to-blame
+                             (if (and current-prefix-arg (> (prefix-numeric-value current-prefix-arg) 0))
+                                 (prefix-numeric-value current-prefix-arg))))
+         content-window the-buffer prior-revisions start-line)
+    (switch-to-buffer blame-buffer)
+    (setq prior-revisions (if prior-vars (plist-get prior-vars :prior-revisions)))
+    (setq prior-revisions
+          (if (and prior-revisions (string= the-revision (plist-get (car prior-revisions) :revision)))
+              (cdr prior-revisions)
+            (if prior-vars
+                (cons (list :full-file-name (plist-get prior-vars :full-file-name)
+                            :revision (plist-get prior-vars :current-revision))
+                      prior-revisions))))
+    (if (window-full-width-p)
+        (split-window-horizontally mo-git-blame-blame-window-width))
+    (select-window (setq content-window (next-window)))
+    (switch-to-buffer content-buffer)
+    (select-window blame-window)
+    (dolist (the-buffer (list blame-buffer content-buffer))
+      (with-current-buffer the-buffer
+        (toggle-read-only 0)
+        (kill-all-local-variables)
+        (buffer-disable-undo)
+        (erase-buffer)
+        (setq default-directory top-dir)
+        (set (make-local-variable 'mo-git-blame-vars)
+             (list :top-dir top-dir
+                   :file-name relative-file-name
+                   :full-file-name file-name
+                   :original-file-name (or original-file-name file-name)
+                   :current-revision the-revision
+                   :prior-revisions prior-revisions
+                   :blame-buffer blame-buffer
+                   :blame-window blame-window
+                   :content-buffer content-buffer
+                   :content-window content-window))))
+    (with-current-buffer content-buffer
+      (mo-git-blame-init-content-buffer))
+    (when lines-to-blame
+      (setq start-line (max 1 (- line-to-go-to lines-to-blame))
+            lines-to-blame (1+ (- (+ line-to-go-to lines-to-blame)
+                                  start-line))))
+    (with-current-buffer blame-buffer
+      (mo-git-blame-mode)
+      (mo-git-blame-init-blame-buffer start-line lines-to-blame))
+    (mo-git-blame-goto-line line-to-go-to)
+    (add-to-list 'window-scroll-functions 'mo-git-blame-window-scrolled)))
+
+(defvar mo-git-blame-scroll-info
+  nil
+  "Information which window to scroll and where to scroll to.")
+
+(defun mo-git-blame-window-scrolled (window new-start-pos)
+  (if (and window
+           (eq window (selected-window))
+           (local-variable-p 'mo-git-blame-vars))
+      (let* ((vars (with-current-buffer (window-buffer window) mo-git-blame-vars))
+             (start-line (line-number-at-pos new-start-pos))
+             (point-line (line-number-at-pos (window-point window)))
+             (window-to-scroll (if (eq window (plist-get vars :blame-window))
+                                   (plist-get vars :content-window)
+                                 (plist-get vars :blame-window))))
+        (setq mo-git-blame-scroll-info (list :window-to-scroll window-to-scroll
+                                             :start-line start-line
+                                             :point-line point-line))
+        (run-at-time "0 sec" nil 'mo-git-blame-update-other-window-after-scrolling))))
+
+(defun mo-git-blame-update-other-window-after-scrolling ()
+  (if mo-git-blame-scroll-info
+      (let ((window (plist-get mo-git-blame-scroll-info :window-to-scroll))
+            new-start-pos)
+        (with-selected-window window
+          (with-current-buffer (window-buffer window)
+            (goto-char (point-min))
+            (setq new-start-pos (line-beginning-position (plist-get mo-git-blame-scroll-info :start-line)))
+            (goto-char (point-min))
+            (goto-char (line-beginning-position (plist-get mo-git-blame-scroll-info :point-line)))
+            (set-window-start window new-start-pos)))
+        (setq mo-git-blame-scroll-info nil))))
+
+(defun mo-git-blame-quit ()
+  "Kill the mo-git-blame buffers."
+  (interactive)
+  (setq window-scroll-functions (remq 'mo-git-blame-window-scrolled window-scroll-functions))
+  (let ((buffer))
+    (dolist (buffer (buffer-list))
+      (if (string-match-p "^\\*mo-git-blame" (buffer-name buffer))
+          (kill-buffer buffer))))
+  (set-window-configuration mo-git-blame--wincfg)
+  (setq mo-git-blame--wincfg nil))
+
+(defun mo-git-blame-display-content-buffer ()
+  "Show the content buffer in the content window."
+  (interactive)
+  ; Declare buffer here because mo-git-blame-vars might not be available in the other buffer.
+  (let ((buffer (plist-get mo-git-blame-vars :content-buffer))
+        (line-num (line-number-at-pos)))
+    (mo-git-blame-goto-line-markless line-num)
+    (recenter)
+    (with-selected-window (plist-get mo-git-blame-vars :content-window)
+      (switch-to-buffer buffer)
+      (mo-git-blame-goto-line-markless line-num)
+      (recenter))))
+
+(defun mo-git-blame-other-buffer ()
+  (plist-get mo-git-blame-vars
+             (if (eq (current-buffer) (plist-get mo-git-blame-vars :blame-buffer))
+                 :content-buffer
+               :blame-buffer)))
+
+(defun mo-git-blame-goto-line-markless (line)
+  (goto-char (point-min))
+  (goto-char (line-beginning-position line)))
+
+(defun mo-git-blame-goto-line (line)
+  "Goto a line in both the blame and the content buffer."
+  (interactive "nGoto line: ")
+  (with-selected-window (plist-get mo-git-blame-vars :blame-window)
+    (mo-git-blame-goto-line-markless line))
+  (with-selected-window (plist-get mo-git-blame-vars :content-window)
+    (mo-git-blame-goto-line-markless line)))
+
+;;;###autoload
+(defun mo-git-blame-current ()
+  "Calls `mo-git-blame-file' for HEAD for the current buffer."
+  (interactive)
+  (if (null (buffer-file-name))
+      (error "The current buffer is not associated with a file."))
+  (mo-git-blame-file (buffer-file-name)))
+
+(provide 'mo-git-blame)
+
+;; Leave this in for debugging purposes:
+;; (global-set-key [?\C-c ?i ?b] (lambda () (interactive) (let ((mo-git-blame-incremental t)) (mo-git-blame-current))))
+;; (global-set-key [?\C-c ?i ?B] (lambda () (interactive) (let ((mo-git-blame-incremental nil)) (mo-git-blame-current))))
+;;; mo-git-blame.el ends here

elpa/python-mode-6.0.10/INSTALL

@@ -0,0 +1,24 @@
+Put the respective lines into your Emacs initialisation file:
+
+(add-to-list 'load-path "PATH/TO/PYTHON-MODE/") 
+(setq py-install-directory "PATH/TO/PYTHON-MODE/")
+(require 'python-mode)
+
+To change the Python default shell use 
+
+M-x customize-variable py-shell-name 
+
+or write 
+
+(setq py-shell-name "MY-PYTHON")
+resp.
+(setq py-shell-name "PATH/TO/MY-PYTHON")
+
+IPython users for example may insert "ipython" with
+M-x customize-variable py-shell-name 
+
+or in init-file
+
+(setq py-shell-name "ipython")
+resp.
+(setq py-shell-name "PATH/TO/ipython")

elpa/python-mode-6.0.10/LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

elpa/python-mode-6.0.10/NEWS

@@ -0,0 +1,467 @@
+Python Mode News
+================
+
+New in version 6.0.9
+--------------------
+
+- autopair-mode delivered
+  Credits to Joao Tavora http://autopair.googlecode.com
+  see README-AUTOPAIR.org for details
+
+- Syntax highlighting in Python-shell buffers enabled
+  boolean `py-fontify-shell-buffer-p', default is nil
+
+- py-add-abbrev, new command
+  Similar to `add-mode-abbrev', but uses
+  `py-partial-expression' before point for expansion to
+  store, not `word'. Also provides a proposal for new
+  abbrevs.
+
+  Proposal for an abbrev is composed from the downcased
+  initials of expansion - provided they are of char-class
+  [:alpha:]
+
+  For example code below would be recognised as a
+  `py-expression' composed by three
+  py-partial-expressions.
+
+  OrderedDict.popitem(last=True)
+
+  Putting the curser at the EOL, M-3 M-x py-add-abbrev
+
+  would prompt "op" for an abbrev to store, as first
+  `py-partial-expression' beginns with a "(", which is
+  not taken as proposal.
+
+- py-edit-abbrevs
+  Jumps to `python-mode-abbrev-table' 
+
+- modeline enhanced
+  when a path/to/my/favoured/Python is given with `py-shell-name'
+  the Python-shell buffer before would display
+
+  *ND path/to/my/favoured/Python* 
+
+  now:
+
+  *ptmfP Python*
+
+  boolean `py-modeline-display-full-path-p' 
+  boolean `py-modeline-acronym-display-home-p'  
+  If the modeline acronym should contain chars indicating the home-directory.
+
+- mode-line indicates "Py" by default
+  customize  `python-mode-modeline-display' 
+
+- Pymacs intergration dropped from trunk
+  conflicts with classic install being reported
+
+New in version 6.0.8
+
+--------------------
+
+- `py-pep8-run', new command checking formatting
+   `py-pep8-help'
+
+- `py-pyflake-run', new command 
+   Pyflakes is a simple program which checks Python
+   source files for errors. - It is similar to
+   PyChecker in scope, but differs in - that it does
+   not execute the modules to check them.
+   `py-pyflake-help'
+
+- `py-pylint-run', new command calls Pylint, 
+  a Python source code analyzer which looks for
+  programming errors, helps enforcing a coding standard
+  and sniffs for some code smells (as defined in Martin
+  Fowler's Refactoring book) . 
+
+  Pylint checks length of lines of code, if variable
+  names are well-formed according to your coding
+  standard, if declared interfaces are truly
+  implemented, and much more. Additionally, it is
+  possible to write plugins.
+  `py-pylint-doku', `py-pylint-help'
+
+- py-pyflakespep8-run, combines calls to pyflakes and pep8
+  
+- respective flymake-modes,
+  `pyflakespep8-flymake-mode', `pylint-flymake-mode'
+  etc. See meny PyTools
+
+New in version 6.0.7
+--------------------
+
+- make every Python shell acces its own history-file
+  .python3_history
+  .python_history
+  .ipython_history etc.
+
+- related to shell used
+  `toggle-force-py-shell-name-p'
+  `force-py-shell-name-p-on'/off
+
+  making it easier to enforce default py-shell upon execution
+
+  `toggle-force-local-shell'
+  `py-force-local-shell-on'/off
+
+  If locally indicated Python shell should be taken and
+  enforced upon sessions execute commands, lp:988091
+
+- specific completion:
+  py-python2-shell-complete, py-python3-shell-complete,
+  py-python2-script-complete, py-python3-script-complete
+
+New in version 6.0.6
+--------------------
+
+- files inside a virtual machine made visible for pdbtrack
+
+- new commands `py-toggle-split-windows-on-execute', ...-on, ...-off
+  `py-toggle-shell-switch-buffers-on-execute', ...-on, ...-off
+  allow `py-execute-buffer' etc. to split/not-split windows,
+  move cursor onto output or not
+
+- Behavior of C-u M-x `py-shell' closer to common shell
+
+  C-u 4 prompts for a buffer,
+  i.e. when a "*Python*" shell is running,
+  C-u M-x `py-shell' opens a "*Python<2>*" per default
+  C-u 2 M-x py-shell promts for command-arguments as known from 5th-series
+
+- `py-intend-tabs-mode' sets default of `indent-tabs-mode', lp:953765
+
+-- New boolean variable `py-intend-tabs-mode'
+  Permits value independent from Emacs-wide `indent-tabs-mode'
+  Commands `py-toggle-indent-tabs-mode', ...-on, ...-off
+  menu PyTools "Toggle indent-tabs-mode"
+
+- Extended py-execute-... forms provided for "line"
+
+- new commands py-beginning/end-of-line
+  while introduced for internal reasons --because of it's
+  return values-- they allow repeats, i.e. when already
+  at end-of-line, jumping to next end etc.
+
+- new boolean `py-force-py-shell-name-p'
+  When `t', execution with Python specified in `py-shell-name' is en  forced, shebang will have no effect. Default is nil.
+
+-  customizable `py-separator-char', a string, see report lp:975539
+  Precedes guessing when not empty, is returned by
+  function `py-separator-char'
+
+- nicer `org-cycle' behavior: when new `py-org-cycle-p' it `t',
+  command `org-cycle' is available at shift-TAB, <backtab>
+
+New in version 6.0.5
+--------------------
+
+- Menu reworked and extended
+
+- extended commands combine executing statement/block... with dedidi  cated/switch... etc. This may remove some need of customization.
+
+- local environments support started
+  If calls to common `py-shell' should use local executable
+  instead of default system Python set
+  `py-use-local-default' alongside with
+  `py-shell-local-path'
+
+- `py-toggle-shells' alias of more powerful `py-switch-shells'
+  Toggles between the interpreter customized in `py-shell-toggle-1' resp. `py-shell-toggle-2'. Was hard-coded CPython and Jython in earlier versions, now starts with Python2 and Python3 by default.
+
+- `py-shell-name' accepts PATH/TO/EXECUTABLE
+  in addition to name of an installed default Python-Shell.
+  Permits installing commands like
+  (defun python-XYZ-shell (&optional argprompt)
+    "Start an Python-XYZ interpreter ... "
+    (interactive)
+    (let ((py-shell-name "PATH/TO/PYTHON-XYZ"))
+      (py-shell argprompt)))
+
+-  new commands `indent-tabs-mode', `toggle-indent-tabs-mode',
+  `indent-tabs-mode-on', `indent-tabs-mode-off'
+
+  feature after a request at Stack Exchange asked Jul
+  13 '11 at 13:23 saying
+  `tab-width' now follows `py-indent-offset'
+
+- new command `py-execute-region-default' forces the
+  systems default Python interpreter to execute, ignores
+  shebang
+
+  related functions redesigned, `async' argument dropped
+  `py-execute-region' now reads:
+
+  (defun py-execute-region (start end &optional shell dedicated)
+    "Send the region to a Python interpreter.
+
+  When called with \\[univeral-argument], execution through `default-value' of `py-shell-name' is forced.
+  When called with \\[univeral-argument] followed by a number different from 4 and 1, user is prompted to specify a shell. This might be the name of a system-wide shell or include the path to a virtual environment.
+
+  When called from a programm, it accepts a string specifying a shell which will be forced upon execute as argument. "
+  [ ... ]
+
+- new `py-number-face',
+  visible only when customized and `py-use-number-face-p' is `t',
+  inherits default face
+  With large files fontifying numbers may cause a delay
+  Credits to github.com/fgallina/python.el/issues42
+
+- new boolean `py-verbose-p'
+  if `t', reached indent level etc. is messaged
+
+- new commands py-execute-buffer-dedicated, py-execute-buffer-switch  -dedicated
+
+- `toggle-py-smart-indentation' new command
+   also `py-smart-indentation-on', -off
+
+New in version 6.0.4
+--------------------
+
+- Python shell starts with `python-mode'
+  that's needed by completion for now
+  boolean customizable `py-start-run-py-shell'
+
+- outline-(minor-)mode enabled providing regular
+  expressions. Customize `py-outline-minor-mode-p' to
+  switch it on with python-mode
+
+- Hook delivered to start hs-minor-mode from python-mode
+  Customize `py-hide-show-minor-mode-p'
+  Key setting example:
+  (global-set-key [(super s)] 'hs-hide-all)
+  (global-set-key [(super S)] 'hs-show-all)
+
+- Listing of available commands in org-mode and reST
+  format in directory "doc"
+
+- Python shells and executing forms may be called as
+  dedicated process. See commands available \w suffix
+  "-dedicated".
+
+- completion fixed: M-TAB completes in Python buffer, TAB
+  completes in Python shells
+
+- py-down-FORM-lc commands
+  Goto beginning of line following end of FORM.
+  \"-lc\" stands for \"left-corner\" - a complementary command travelling left, whilst `py-end-of-FORM' stops at right corner.
+  Implemented forms are "block", "clause", "def", "class", "statement".
+
+- py-down-FORM commands
+
+  like py-down-block introduced in version 6.0.3,
+  implemented also for "clause", "def", "class",
+  "statement".
+  Go to the beginning of next block below
+  current level.
+
+New in version 6.0.3
+--------------------
+
+- ipython integration started
+
+- commands `ipython', `python2', `python3', `jython', `python'
+  opening a respective python shell
+
+-  py-shift-block-left, py-shift-block-right etc.
+  Implemented forms that way are
+  "paragraph" "block" "clause" "def" "class" "line" "statement"
+
+- py-dedent
+  Dedent line according to `py-indent-offset'. With
+  arg, do it that many times. If point is between
+  indent levels, dedent to next level. Stops at BOL.
+  Returns column reached, if dedent done, nil otherwise.
+
+- py-indent-forward-line
+  Indent line and move one line forward. If
+  `py-kill-empty-line' is non-nil, delete an empty
+  line. When closing a form, use py-close-block et al,
+  which will move and indent likewise. Returns position.
+
+- py-close-block, -clause, -def, class
+  Set indent level to that of beginning of definition.
+  If final line isn't empty and
+  `py-close-block-provides-newline' non-nil, insert a
+  newline. Returns column.
+
+- new commands specifying the shell override
+  `py-shell-name' for execution
+  implemented shells are "python" "python2" "python2.7"
+  "python3" "python3.2" "jython"
+
+  available with default, -switch and -no-switch
+  option, i.e.
+  py-execute-region-python3.2
+  py-execute-region-python3.2-switch
+  py-execute-region-python3.2-no-switch etc.
+
+  Docstring of py-execute-region-python3.2-switch for
+  example: "Send the region to a common shell calling the
+  python3.2 interpreter. Ignores setting of
+  `py-shell-switch-buffers-on-execute', output-buffer
+  will being switched to."
+
+- Declarations
+  Deal with assigments resp. statements in current
+  level which don't open blocks. Provides common edit
+  functions as copy, mark, kill, goto beg/end.
+
+  Functions will be used typically to grasp
+  initialisations resp. assignements of variables
+  between the definition of a class or method and it's
+  body, likewise global stuff at the head of a file.
+
+- column-marker.el
+  Commands `column-marker-1', `column-marker-2', and
+  `column-marker-3' each highlight a given column
+  (using different background colors by default).
+
+  M-x column-marker-1 highlights the column where the
+  cursor is, in face `column-marker-1'.
+
+  C-u 70 M-x column-marker-2 highlights column 70 in
+  face `column-marker-2'.
+
+  C-u 70 M-x column-marker-3 highlights column 70 in
+  face `column-marker-3'. The face `column-marker-2'
+  highlighting no longer shows.
+
+  C-u M-x column-marker-3 turns off highlighting for
+  column-marker-3, so face `column-marker-2'
+  highlighting shows again for column 70.
+
+  C-u C-u M-x column-marker-1 (or -2 or -3) erases all
+  column highlighting.
+
+  ;;
+
+  Thanks a lot to it's author Rick Bielawski <rbielaws@i1.net>,
+  to Drew Adams for his care and Emacs Wiki hosting it.
+
+New in version 6.0.2
+--------------------
+
+- py-electric-comment
+
+  "Insert a comment. If starting a comment, indent
+   accordingly. If a numeric argument ARG is provided,
+   that many colons are inserted non-electrically. With
+   universal-prefix-key C-u a \"#\" Electric behavior
+   is inhibited inside a string or comment."
+
+- New commands `py-partial-expression':
+
+  "." operators delimit a partial-expression on it's
+  level.
+
+  Given the function below, `py-partial-expression'
+  called at pipe symbol would copy and return:
+
+  def usage():
+      print """Usage: %s
+      ....""" % (
+          os.path.basename(sys.argv[0]))
+  ------------|-------------------------
+  ==> path
+
+          os.path.basename(sys.argv[0]))
+  ------------------|-------------------
+  ==> basename(sys.argv[0]))
+
+          os.path.basename(sys.argv[0]))
+  --------------------------|-----------
+  ==> sys
+
+          os.path.basename(sys.argv[0]))
+  ------------------------------|-------
+  ==> argv[0]
+
+  while `py-expression' would copy and return
+
+  (
+          os.path.basename(sys.argv[0]))
+
+  ;;;;;
+
+  Also for existing commands a shorthand is defined:
+
+  (defalias 'py-statement 'py-copy-statement)
+
+  which will mark, copy and return.
+
+- Commands implementing a behavior which customizing of
+ `py-shell-switch-buffers-on-execute' would do:
+
+  py-execute-buffer-no-switch
+  py-execute-buffer-switch
+  py-execute-region-no-switch
+  py-execute-region-switch
+
+- Several bugfixes.
+
+New in version 6.0.1
+--------------------
+
+- New commands py-expression:
+
+  py-copy-expression
+  py-mark-expression
+  py-beginning-of-expression
+  py-end-of-expression
+  py-kill-expression
+
+  Also several of bugfixes are done.
+
+New in version 6.0
+--------------------
+
+- Finer grained commands, core re-write.
+
+  As shown below for the `mark'-command, delete,
+  copy, jump to beginning and end of the respective
+  programming-expressions:
+
+  py-mark-statement
+  py-mark-block
+  py-mark-block-or-clause
+  py-mark-def
+  py-mark-def-or-class
+  py-mark-class
+  py-mark-clause
+
+- Also a couple of bugfixes are done.
+
+New in version 5.2.1
+--------------------
+
+- Syntax highlight as a keyword "lambda:" just like "lambda x:".  Given by Dan
+  Davison.
+- Add "python3" as a key for python-mode in interpreter-mode-alist and
+  auto-mode-alist.
+
+New in version 5.2.0
+--------------------
+
+- Fixed filling of triple-quoted strings.
+
+- Add new font-lock faces for class names and exception names.
+
+- Do not fill when calling fill-paragraph with point in a region of code.
+
+- Fixed font-locking of exception names in parenthesized lists.
+
+- Fixed font-locking of decorators with arguments.
+
+- Fixed font-locking of triple-quoted strings; single quotes appearing in
+  triple-quoted strings no longer upset font-locking.
+
+- Fixed the stack-entry regexp used by pdbtrack so that it now works with
+  module-level frames.
+
+- Do not bind C-c C-h; `py-help-at-point' is now on C-c C-e by default.
+
+- hide-show mode is now supported.
+
+- When shifting regions right and left, keep the region active in Emacs.

elpa/python-mode-6.0.10/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 1.0
+Name: python-mode.el
+Version: 6.0.10
+Summary: Major mode for editing Python programs
+Home-page: http://launchpad.net/python-mode
+Author: Andreas Roehler
+Author-email: andreas.roehler@online.de
+License: GNU GPLv3, Python License
+Download-URL: http://launchpad.net/python-mode/trunk/6.0.10/+download/python-mode.el-6.0.10.tar.gz
+Description: UNKNOWN
+Platform: UNKNOWN

elpa/python-mode-6.0.10/README

@@ -0,0 +1,37 @@
+Customize default Python shell as `py-shell-name'
+
+`py-shell-name' might be an installed executable as
+shell command `type' would display, but also a
+PATH/TO/(I)PYTHON, of a virtualenv for example
+
+To change the Python default shell see also INSTALL
+
+Most python-mode.el commands start with prefix `py-'
+
+`M-x py- TAB'
+displays a list of them in completion-buffer. 
+See also commands list delivered in directory doc.
+
+List virtualenv related `M-x virtualenv- TAB'
+resp. Pymacs commands `M-x pymacs-'  
+
+Commands related to a specific shell start with
+it's name as `ipython-complete'.
+Open an installed shell by 
+
+M-x SHELL
+
+With prefix C-u user is prompted to specify a PATH-TO-LOCAL-SHELL
+Also evaluating
+
+(py-shell nil DEDICATED PATH-TO-LOCAL-SHELL)
+
+if DEDICATED is set to `t', shell will get an unique name.
+
+Install a local shell by evaluating
+
+(defun MY-LOCAL-SHELL ()
+  (interactive)
+  (py-shell nil DEDICATED PATH-TO-LOCAL-SHELL))
+
+If `py-complete-function' is set, it takes precedence 

elpa/python-mode-6.0.10/ToDo

@@ -0,0 +1,2 @@
+* implement respective to shell-dumb-shell-regexp 
+

elpa/python-mode-6.0.10/byte-compile-directory.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+ # -- byte-compile Emacs Lisp files delivered with python-mode.el
+
+# Author: Andreas Roehler <andreas.roehler@online.de>
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Commentary:  Edit the vars pointing to the directories/files
+# holding your python-mode for test
+# assumes python-mode files in or below current directory
+
+# Code:
+
+
+# the path 
+PDIR=`pwd`
+
+# python-mode file to load
+if [ -s "python-components-mode.el" ];
+    then
+    PYTHONMODE='python-components-mode.el'
+    else
+    PYTHONMODE='python-mode.el'
+fi
+
+EMACS=emacs
+PYMACSDIR=Pymacs
+
+$EMACS -Q --batch --eval "(message (emacs-version))" --eval "(when (featurep 'python-mode)(unload-feature 'python-mode t))" --eval "(add-to-list 'load-path \"$PDIR/\")" --eval "(add-to-list 'load-path \"$PYMACSDIR/\")" -load "$PDIR/pymacs.el" -load "$PDIR/$PYTHONMODE" --eval '(byte-recompile-directory default-directory 1 t)'
+
+

elpa/python-mode-6.0.10/completion/pycomplete.el

@@ -0,0 +1,81 @@
+;;; Complete symbols at point using Pymacs.
+
+;; Copyright (C) 2007  Skip Montanaro
+
+;; Author:     Skip Montanaro
+;; Maintainer: skip@pobox.com
+;; Created:    Oct 2004
+;; Keywords:   python pymacs emacs
+
+;; This software is provided as-is, without express or implied warranty.
+;; Permission to use, copy, modify, distribute or sell this software,
+;; without fee, for any purpose and by any individual or organization, is
+;; hereby granted, provided that the above copyright notice and this
+;; paragraph appear in all copies.
+
+;; Along with pycomplete.py this file allows programmers to complete Python
+;; symbols within the current buffer.  See pycomplete.py for the Python side
+;; of things and a short description of what to expect.
+
+(require 'pymacs)
+
+(pymacs-load "pycomplete")
+
+(defun py-symbol-near-point ()
+  "Return the first textual item to the nearest point."
+  ;; alg stolen from etag.el
+  (save-excursion
+    (with-syntax-table py-dotted-expression-syntax-table
+      (if (or (bobp) (not (memq (char-syntax (char-before)) '(?w ?_))))
+          (while (not (looking-at "\\sw\\|\\s_\\|\\'"))
+            (forward-char 1)))
+      (while (looking-at "\\sw\\|\\s_")
+        (forward-char 1))
+      (if (re-search-backward "\\sw\\|\\s_" nil t)
+          (progn (forward-char 1)
+                 (buffer-substring (point)
+                                   (progn (forward-sexp -1)
+                                          (while (looking-at "\\s'")
+                                            (forward-char 1))
+                                          (point))))
+        nil))))
+
+(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))
+      (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))))))
+      imports)))
+
+(defun py-complete ()
+  (interactive)
+  (let* ((pymacs-forget-mutability t)
+         (symbol (py-symbol-near-point))
+         (completions
+          (pycomplete-pycomplete symbol
+                                 (py-find-global-imports))))
+    (cond ((null completions) ; no matching symbol
+           (message "Can't find completion for \"%s\"" symbol)
+           (ding))
+          ((null (cdr completions))
+           (if (string= "" (car completions))
+               (tab-to-tab-stop)
+             ;; sole completion
+             (insert (car completions))))
+          (t
+           (message "Making completion list...")
+           (with-output-to-temp-buffer "*PythonCompletions*"
+             (display-completion-list completions))
+           (message "Making completion list...%s" "done")))))
+
+(provide 'pycomplete)

elpa/python-mode-6.0.10/completion/pycomplete.py

@@ -0,0 +1,121 @@
+
+"""
+Python dot expression completion using Pymacs.
+
+This almost certainly needs work, but if you add
+
+    (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
+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.
+
+See pycomplete.el for the Emacs Lisp side of things.
+"""
+
+# Author:     Skip Montanaro
+# Maintainer: skip@pobox.com
+# Created:    Oct 2004
+# Keywords:   python pymacs emacs
+
+# This software is provided as-is, without express or implied warranty.
+# Permission to use, copy, modify, distribute or sell this software, without
+# fee, for any purpose and by any individual or organization, is hereby
+# granted, provided that the above copyright notice and this paragraph
+# appear in all copies.
+
+# Along with pycomplete.el this file allows programmers to complete Python
+# symbols within the current buffer.
+# import pdb
+# pdb.set_trace()
+
+import sys
+import os.path
+
+try:
+    x = set
+except NameError:
+    from sets import Set as set
+else:
+    del x
+
+def get_all_completions(s, imports=None):
+    """Return contextual completion of s (string of >= zero chars).
+
+    If given, imports is a list of import statements to be executed first.
+    """
+    locald = {}
+    if imports is not None:
+        for stmt in imports:
+            try:
+                exec stmt in globals(), locald
+            except TypeError:
+                raise TypeError, "invalid type: %s" % stmt
+
+    dots = s.split(".")
+    if not s or len(dots) == 1:
+        keys = set()
+        keys.update(locald.keys())
+        keys.update(globals().keys())
+        import __builtin__
+        keys.update(dir(__builtin__))
+        keys = list(keys)
+        keys.sort()
+        if s:
+            return [k for k in keys if k.startswith(s)]
+        else:
+            return keys
+
+    sym = None
+    for i in range(1, len(dots)):
+        s = ".".join(dots[:i])
+        try:
+            sym = eval(s, globals(), locald)
+        except NameError:
+            try:
+                sym = __import__(s, globals(), locald, [])
+            except ImportError:
+                return []
+    if sym is not None:
+        s = dots[-1]
+        return [k for k in dir(sym) if k.startswith(s)]
+
+def pycomplete(s, imports=None):
+    completions = get_all_completions(s, imports)
+    if len(completions) == 0:
+        return None
+    else:
+        dots = s.split(".")
+        prefix = os.path.commonprefix([k for k in completions])
+        if len(completions)==1 or len(prefix)>len(dots[-1]):
+            return [prefix[len(dots[-1]):]]
+        
+        return completions
+
+        # return os.path.commonprefix([k[len(dots[-1]):] for k in completions])
+
+if __name__ == "__main__":
+    print "<empty> ->", 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 pycomplete("Enc", imports=["from email import *"])
+    print "E (email * imported) ->",
+    print pycomplete("E", imports=["from email import *"])
+
+    print "Enc ->", pycomplete("Enc")
+    print "E ->", pycomplete("E")
+
+# Local Variables :
+# pymacs-auto-reload : t
+# End :

elpa/python-mode-6.0.10/python-mode-autoloads.el

@@ -0,0 +1,18 @@
+;;; python-mode-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+
+;;;### (autoloads nil nil ("python-mode-pkg.el" "python-mode.el")
+;;;;;;  (20535 45425 973618))
+
+;;;***
+
+(provide 'python-mode-autoloads)
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; coding: utf-8
+;; End:
+;;; python-mode-autoloads.el ends here

elpa/python-mode-6.0.10/python-mode-pkg.el

@@ -0,0 +1,2 @@
+(define-package "python-mode" "6.0.10"
+                "Python major mode")

elpa/python-mode-6.0.10/setup.py

@@ -0,0 +1,14 @@
+#! /usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from distutils.core import setup
+
+setup(name='python-mode.el',
+      version='6.0.10',
+      url='http://launchpad.net/python-mode',
+      maintainer_email='andreas.roehler@online.de',
+      maintainer='Andreas Roehler',
+      description='Major mode for editing Python programs',
+      download_url='http://launchpad.net/python-mode/trunk/6.0.10/+download/python-mode.el-6.0.10.tar.gz',
+      license='GNU GPLv3, Python License',
+      )

elpa/python-mode-6.0.10/test/test-triple-strings.py

@@ -0,0 +1,78 @@
+# Source:
+# http://launchpadlibrarian.net/22565844/test-triple-strings.py
+# Author: Ed Loper
+
+# This file tests python-mode's ability to handle triple-quoted
+# string.  Here's how to tell if python-mode's doing the right thing:
+#
+# - All dashes (-) should *not* be marked as strings.
+# - All Os, Xs, <s, and >s should be marked as strings.
+# - None of the quote marks around O's should be marked as strings.
+# - Quote marks that are between angle brackets (<...>) should be
+#   marked as strings.  Think of "X" as a pair of angle brackets
+#   right next to one another.  Also, quotes to the left of >s
+#   and the right of <s should be marked as strings.
+#
+# (note: replacing -,O,X,<,> with other characters should not affect
+# the fontificatin any; these characters were just used to make it
+# easier to see what the intended colorization is.)
+
+# Some easy cases:
+"O" 'O' "<'>" '<">'
+ "O"   'O'   "<'>"   '<">'
+ " O "   ' O '   " < ' > "   ' < " > '
+"""O""" '''O''' "<<<'>>>" '''<">'''
+
+# Some harder cases:
+"""<">""" '''<'>'''
+
+# Some tricky cases with backslashes.
+'''<'>''' '''<\'''>''' '''<\\'''
+
+# Some tricky cases with more than 3 quotes in a row.
+"O""" "O"
+"""">"""
+"""">>"""
+""""X">"""
+""""X"">"""
+"""O""""O" ""
+"""O""""" "O"
+"""O""""""<">"""
+"""O"""""""X">"""
+"""O""""""""X">"""
+"""O""" "<<<>>>>"
+"""""""""O""" "O"
+"""O""""O""O""O"""
+"""">"""    """">>"""    """">>>"""
+""""">"""   """"">>"""   """"">>>"""
+""""">>>""""O"   """"">>>"""""
+"""""""""<""X"X"">"""
+
+# One version had a bug with comments ending in string markers: "
+"""O"""
+
+ "" ""
+
+"""<">""" '''<'>'''
+
+# Spanning multiple lines:
+
+"<
+>"
+
+'<
+>'
+
+"""
+<
+<
+<
+<
+'
+X
+X
+X
+"
+>
+>
+"""

init.el

@@ -0,0 +1,142 @@
+;; -----------------------------------------------------------------------------
+;; Ivan Malison
+;;    ___ _ __ ___   __ _  ___ ___
+;;   / _ \ '_ ` _ \ / _` |/ __/ __|
+;;  |  __/ | | | | | (_| | (__\__ \
+;; (_)___|_| |_| |_|\__,_|\___|___/
+;; -----------------------------------------------------------------------------
+
+(setq user-full-name    "Ivan Malison")
+(setq user-mail-address "<IvanMalison@gmail.com>")
+
+;; =============================================================================
+;;                                                       Load Path Configuration
+;; =============================================================================
+
+(let ((default-directory "~/.emacs.d/lisp/"))
+      (normal-top-level-add-subdirs-to-load-path))
+(setq load-path (cons "~/.emacs.d/elpa" load-path))
+
+;; =============================================================================
+;;                                                         General Emacs Options
+;; =============================================================================
+
+;; Disable the creation of backup files.
+(setq backup-inhibited t)
+(setq make-backup-files nil)
+(setq auto-save-default nil)
+
+;; Enable ido mode.
+(require 'ido)
+(ido-mode t)
+(setq ido-enable-flex-matching t)
+
+;; Unique buffer names dependent on file name
+(require 'uniquify)
+(setq uniquify-buffer-name-style 'forward)
+
+(add-hook 'python-mode-hook (lambda () (setq show-trailing-whitespace t)))
+(setq visible-bell t)
+
+;; Multi-lining for python.
+(require 'multi-line-it)
+
+;; Display line and column numbers in mode line.
+(line-number-mode t)
+(column-number-mode t)
+
+;; =============================================================================
+;;                                                           Custom Key Bindings
+;; =============================================================================
+
+;; Fast cursor movement in vertical direction with Meta.
+(global-set-key (kbd "M-<down>") (lambda () (interactive) (next-line 5)))
+(global-set-key (kbd "M-<up>") (lambda () (interactive) (previous-line 5)))
+(global-set-key (kbd "ESC <down>") (lambda () (interactive) (next-line 5)))
+(global-set-key (kbd "ESC <up>") (lambda () (interactive) (previous-line 5)))
+
+;; Macros
+(fset 'ipdb "import ipdb; ipdb.set_trace()")
+
+;; Miscellaneous
+(global-set-key "\C-x\C-b" 'buffer-menu)
+(global-set-key "\C-xw" 'whitespace-mode)
+(global-set-key "\C-x\C-r" (lambda () (interactive) (revert-buffer t t)))
+(global-set-key "\C-x\C-i" 'increase-left-margin)
+(global-set-key "\C-x\C-d" 'decrease-left-margin)
+
+;; =============================================================================
+;;                                                                          ELPA
+;; =============================================================================
+
+(require 'package)
+(add-to-list 'package-archives
+             '("marmalade" . "http://marmalade-repo.org/packages/"))
+(package-initialize)
+
+;; =============================================================================
+;;                                                                       Flymake
+;; =============================================================================
+
+(require 'flymake)
+(require 'flymake-cursor)
+
+;; Customize flymake colors.
+(custom-set-faces
+ '(flymake-errline ((((class color)) (:background "DarkViolet"))))
+ '(flymake-warnline ((((class color)) (:underline "Orange")))))
+
+(defun flymake-pylint-init ()
+  (let* ((temp-file (flymake-init-create-temp-buffer-copy
+                    'flymake-create-temp-inplace))
+        (local-file (file-relative-name
+                     temp-file
+                     (file-name-directory buffer-file-name))))
+   (list "pyflakes" (list local-file))))
+
+(add-to-list 'flymake-allowed-file-name-masks '("\\.py\\'" flymake-pylint-init))
+
+; Load flymake on non-temp buffers
+(add-hook 'python-mode-hook
+	  (lambda () (unless (eq buffer-file-name nil) (flymake-mode 1))))
+
+
+(require 'yasnippet)
+(require 'whitespace)
+
+
+
+
+
+
+
+
+;; pymacs
+(require 'pymacs)
+(autoload 'pymacs-apply "pymacs")
+(autoload 'pymacs-call "pymacs")
+(autoload 'pymacs-eval "pymacs" nil t)
+(autoload 'pymacs-exec "pymacs" nil t)
+(autoload 'pymacs-load "pymacs" nil t)
+
+(pymacs-load "ropemacs" "rope-")
+(whitespace-mode t)
+
+
+
+; tab display width of 4 columns by default
+; (throw everything at the wall, and eventually something will stick...)
+(setq-default tab-width 4)  ; Normal emacs tab-width
+; (setq-default c-basic-offset 2) ; python-mode.el setting
+(setq-default py-indent-offset 4) ; Use Tabs, not spaces
+(setq-default py-indent-offset 4) ; emacs-for-python setting
+(setq-default py-smart-indentation nil) ; Don't try to guess tab width
+
+
+
+(setq c-subword-mode t)
+(put 'upcase-region 'disabled nil)
+(defun change-major-mode-hook () (modify-syntax-entry ?_ "_"))
+
+(put 'downcase-region 'disabled nil)
+

lisp/flymake-cursor

@@ -0,0 +1 @@
+Subproject commit 5cac5045398b1436ceb143d48961b50d38ae1396

lisp/multi-line-it

@@ -0,0 +1 @@
+Subproject commit da2e474ec816c0f22037becc355d339899ddc1dd

lisp/multi-line-it.el

@@ -0,0 +1 @@
+Subproject commit da2e474ec816c0f22037becc355d339899ddc1dd

lisp/yasnippet

@@ -0,0 +1 @@
+Subproject commit d9d7ed32ae11df8cbc91646bd5b6984d37efd3b3