Anonymous avatar Anonymous committed 8a1b7ad

added zen art find-recursive and other el files

Comments (0)

Files changed (70)

 
 
 (require 'zenburn)
+
+(add-to-list 'load-path "~/.emacs.d/eproject")
+    (require 'eproject)
+    (require 'eproject-extras)
+
+(global-hl-line-mode 1)
+ 
+;; To customize the background color
+(set-face-background 'hl-line "#222")  ;; Emacs 22 Only
+
+(require 'color-theme)
+(color-theme-initialize)
+(load-file "~/.emacs.d/zen-and-art/zen-and-art.el")
+(color-theme-zen-and-art)
+
+
+
+
+(autoload 'igrep "igrep"
+       "*Run `grep` PROGRAM to match REGEX in FILES..." t)
+    (autoload 'igrep-find "igrep"
+       "*Run `grep` via `find`..." t)
+    (autoload 'igrep-visited-files "igrep"
+       "*Run `grep` ... on all visited files." t)
+    (autoload 'dired-do-igrep "igrep"
+       "*Run `grep` on the marked (or next prefix ARG) files." t)
+    (autoload 'dired-do-igrep-find "igrep"
+       "*Run `grep` via `find` on the marked (or next prefix ARG) directories." t)
+    (autoload 'Buffer-menu-igrep "igrep"
+      "*Run `grep` on the files visited in buffers marked with '>'." t)
+    (autoload 'igrep-insinuate "igrep"
+      "Define `grep' aliases for the corresponding `igrep' commands." t)
+;;  2. a. For completeness, you can add these forms as well:
+  (autoload 'grep "igrep"
+       "*Run `grep` PROGRAM to match REGEX in FILES..." t)
+  (autoload 'egrep "igrep"
+       "*Run `egrep`..." t)
+    (autoload 'fgrep "igrep"
+       "*Run `fgrep`..." t)
+    (autoload 'agrep "igrep"
+       "*Run `agrep`..." t)
+    (autoload 'grep-find "igrep"
+       "*Run `grep` via `find`..." t)
+    (autoload 'egrep-find "igrep"
+       "*Run `egrep` via `find`..." t)
+    (autoload 'fgrep-find "igrep"
+       "*Run `fgrep` via `find`..." t)
+    (autoload 'agrep-find "igrep"
+       "*Run `agrep` via `find`..." t)
+
+
+# use glob syntax.
+syntax: glob
+
+*.elc
+*.pyc
+*~

elpa/archive-contents

 (1
+ (wrap-region .
+	      [(0 0 1)
+	       nil "Wrap text with punctation or tag" single])
+ (twitter .
+	  [(20090422)
+	   nil "Simple Emacs-based client for Twitter" single])
+ (pastie .
+	 [(20091230)
+	  nil "Emacs integration for pastie.org" single])
+ (textmate .
+	   [(1)
+	    nil "TextMate minor mode for Emacs" single])
+ (yaml-mode .
+	    [(0 0 5)
+	     nil "Major mode for editing YAML files" single])
+ (rspec-mode .
+	     [(0 2)
+	      ((ruby-mode
+		(1 1)))
+	      "Enhance ruby-mode for RSpec" single])
+ (htmlize .
+	  [(1 37)
+	   nil "Convert buffer text and decorations to HTML." single])
+ (swank-clojure .
+		[(1 1 0)
+		 ((slime-repl
+		   (20091016))
+		  (clojure-mode
+		   (1 6)))
+		 "slime adapter for clojure" single])
+ (slime-repl .
+	     [(20091016)
+	      ((slime
+		(20091016)))
+	      "Read-Eval-Print Loop written in Emacs Lisp" single])
+ (slime .
+	[(20091016)
+	 nil "Superior Lisp Interaction Mode for Emacs" single])
+ (nterm .
+	[(0 1)
+	 nil "New TERMinal emulator" single])
+ (sass-mode .
+	    [(2 2 7)
+	     ((haml-mode
+	       (2 2 7)))
+	     "Major mode for editing Sass files" single])
+ (haml-mode .
+	    [(2 2 7)
+	     nil "Major mode for editing Haml files" single])
+ (smart-tab .
+	    [(0 3)
+	     nil "Intelligent tab completion and indentation." single])
+ (cssh .
+       [(0 5)
+	nil "clusterssh implementation for emacs" single])
  (relax .
 	[(0 2)
 	 ((json
 	      [(0 1)
 	       nil "automatic setting of code style variables" single])
  (clojure-test-mode .
-		    [(1 2)
-		     ((clojure-mode
-		       (1 1)))
+		    [(1 3)
+		     ((swank-clojure
+		       (1 0)))
 		     "Minor mode for Clojure tests" single])
  (clojure-mode .
-	       [(1 1)
+	       [(1 6)
 		nil "Major mode for Clojure code" single])
  (magit .
 	[(0 7)
      [(4 0 46)
       nil "A web browser written entirely in Emacs Lisp" tar])
  (yasnippet-bundle .
-		   [(0 5 10)
+		   [(0 6 1)
 		    nil "Yet another snippet extension (Auto compiled bundle)" single])
  (rinari .
 	 [(2 1)
        [(0 3)
 	nil "Emacs integration for gist.github.com" single])
  (confluence .
-	     [(1 1)
+	     [(1 3)
 	      ((xml-rpc
 		(1 6 4)))
 	      "Emacs mode for interacting with confluence wikis" single])
 	   [(3 2)
 	    nil "Major mode for editing POV-Ray scene files." tar])
  (js2-mode .
-	   [(20080616)
+	   [(20090723)
 	    nil "an improved JavaScript editing mode" single])
  (ert .
       [(0 1)
 	     [(1 5)
 	      nil "clean a patch for submission via email" single])
  (lisppaste .
-	    [(1 5)
+	    [(1 8)
 	     ((xml-rpc
-	       (1 6 4)))
+	       (1 6 7)))
 	     "Interact with the lisppaste pastebot via XML-RPC." single])
  (weblogger .
-	    [(1 2 1)
-	     nil "Weblog maintenance via XML-RPC APIs" single])
+	    [(1 4 3)
+	     ((xml-rpc
+	       (1 6 5)))
+	     "Weblog maintenance via XML-RPC APIs" single])
  (xml-rpc .
-	  [(1 6 4)
+	  [(1 6 7)
 	   nil "An elisp implementation of clientside XML-RPC" single])
  (iresize .
 	  [(0 2)
 		   [(6)
 		    nil "preview TeX math expressions." single])
  (gtk-look .
-	   [(13)
+	   [(17)
 	    nil "lookup Gtk and Gnome documentation." single])
  (xtide .
-	[(9)
+	[(10)
 	 nil "XTide display in Emacs.      -*- coding: latin-1 -*-" single])
  (compilation-recenter-end .
 			   [(4)
 			    nil "compilation-mode window recentre" single])
  (gdb-shell .
-	    [(0 2)
+	    [(0 4)
 	     nil "minor mode to add gdb features to shell" single])
  (highline .
 	   [(4 2)

elpa/archive-contents~

 (1
+ (wrap-region .
+	      [(0 0 1)
+	       nil "Wrap text with punctation or tag" single])
+ (twitter .
+	  [(20090422)
+	   nil "Simple Emacs-based client for Twitter" single])
+ (pastie .
+	 [(20091230)
+	  nil "Emacs integration for pastie.org" single])
+ (textmate .
+	   [(1)
+	    nil "TextMate minor mode for Emacs" single])
+ (yaml-mode .
+	    [(0 0 5)
+	     nil "Major mode for editing YAML files" single])
+ (rspec-mode .
+	     [(0 2)
+	      ((ruby-mode
+		(1 1)))
+	      "Enhance ruby-mode for RSpec" single])
+ (htmlize .
+	  [(1 37)
+	   nil "Convert buffer text and decorations to HTML." single])
+ (swank-clojure .
+		[(1 1 0)
+		 ((slime-repl
+		   (20091016))
+		  (clojure-mode
+		   (1 6)))
+		 "slime adapter for clojure" single])
+ (slime-repl .
+	     [(20091016)
+	      ((slime
+		(20091016)))
+	      "Read-Eval-Print Loop written in Emacs Lisp" single])
+ (slime .
+	[(20091016)
+	 nil "Superior Lisp Interaction Mode for Emacs" single])
+ (nterm .
+	[(0 1)
+	 nil "New TERMinal emulator" single])
+ (sass-mode .
+	    [(2 2 7)
+	     ((haml-mode
+	       (2 2 7)))
+	     "Major mode for editing Sass files" single])
+ (haml-mode .
+	    [(2 2 7)
+	     nil "Major mode for editing Haml files" single])
+ (smart-tab .
+	    [(0 3)
+	     nil "Intelligent tab completion and indentation." single])
+ (cssh .
+       [(0 5)
+	nil "clusterssh implementation for emacs" single])
  (relax .
 	[(0 2)
 	 ((json
 	      [(0 1)
 	       nil "automatic setting of code style variables" single])
  (clojure-test-mode .
-		    [(1 2)
-		     ((clojure-mode
-		       (1 1)))
+		    [(1 3)
+		     ((swank-clojure
+		       (1 0)))
 		     "Minor mode for Clojure tests" single])
  (clojure-mode .
-	       [(1 1)
+	       [(1 6)
 		nil "Major mode for Clojure code" single])
  (magit .
 	[(0 7)
      [(4 0 46)
       nil "A web browser written entirely in Emacs Lisp" tar])
  (yasnippet-bundle .
-		   [(0 5 10)
+		   [(0 6 1)
 		    nil "Yet another snippet extension (Auto compiled bundle)" single])
  (rinari .
 	 [(2 1)
        [(0 3)
 	nil "Emacs integration for gist.github.com" single])
  (confluence .
-	     [(1 1)
+	     [(1 3)
 	      ((xml-rpc
 		(1 6 4)))
 	      "Emacs mode for interacting with confluence wikis" single])
 	   [(3 2)
 	    nil "Major mode for editing POV-Ray scene files." tar])
  (js2-mode .
-	   [(20080616)
+	   [(20090723)
 	    nil "an improved JavaScript editing mode" single])
  (ert .
       [(0 1)
 	     [(1 5)
 	      nil "clean a patch for submission via email" single])
  (lisppaste .
-	    [(1 5)
+	    [(1 8)
 	     ((xml-rpc
-	       (1 6 4)))
+	       (1 6 7)))
 	     "Interact with the lisppaste pastebot via XML-RPC." single])
  (weblogger .
-	    [(1 2 1)
-	     nil "Weblog maintenance via XML-RPC APIs" single])
+	    [(1 4 3)
+	     ((xml-rpc
+	       (1 6 5)))
+	     "Weblog maintenance via XML-RPC APIs" single])
  (xml-rpc .
-	  [(1 6 4)
+	  [(1 6 7)
 	   nil "An elisp implementation of clientside XML-RPC" single])
  (iresize .
 	  [(0 2)
 		   [(6)
 		    nil "preview TeX math expressions." single])
  (gtk-look .
-	   [(13)
+	   [(17)
 	    nil "lookup Gtk and Gnome documentation." single])
  (xtide .
-	[(9)
+	[(10)
 	 nil "XTide display in Emacs.      -*- coding: latin-1 -*-" single])
  (compilation-recenter-end .
 			   [(4)
 			    nil "compilation-mode window recentre" single])
  (gdb-shell .
-	    [(0 2)
+	    [(0 4)
 	     nil "minor mode to add gdb features to shell" single])
  (highline .
 	   [(4 2)

elpa/find-file-in-project-2.0/find-file-in-project-autoloads.el

+;;; find-file-in-project-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+
+;;;### (autoloads (ffip-project-root find-file-in-project) "find-file-in-project"
+;;;;;;  "find-file-in-project.el" (19270 3784))
+;;; Generated autoloads from find-file-in-project.el
+
+(autoload 'find-file-in-project "find-file-in-project" "\
+Prompt with a completing list of all files in the project to find one.
+
+The project's scope is defined as the first directory containing
+an `.emacs-project' file. You can override this by locally
+setting the `ffip-project-root' variable.
+
+\(fn)" t nil)
+
+(autoload 'ffip-project-root "find-file-in-project" "\
+Find the root of the project defined by presence of `.emacs-project'.
+
+\(fn &optional DIR)" nil nil)
+
+;;;***
+
+;;;### (autoloads nil nil ("find-file-in-project-pkg.el") (19270
+;;;;;;  3784 190154))
+
+;;;***
+
+(provide 'find-file-in-project-autoloads)
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; coding: utf-8
+;; End:
+;;; find-file-in-project-autoloads.el ends here

elpa/find-file-in-project-2.0/find-file-in-project-pkg.el

+(define-package "find-file-in-project" "2.0" "Find files in a project quickly." (quote ((project-local-variables "0.2"))))

elpa/find-file-in-project-2.0/find-file-in-project.el

+;;; find-file-in-project.el --- Find files in a project quickly.
+
+;; Copyright (C) 2006, 2007, 2008 Phil Hagelberg and Doug Alcorn
+
+;; Author: Phil Hagelberg and Doug Alcorn
+;; URL: http://www.emacswiki.org/cgi-bin/wiki/FindFileInProject
+;; Version: 2.0
+;; Created: 2008-03-18
+;; Keywords: project, convenience
+;; EmacsWiki: FindFileInProject
+;; Package-Requires: ((project-local-variables "0.2"))
+
+;; This file is NOT part of GNU Emacs.
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; This library depends on GNU find.
+
+;; This file provides a method for quickly finding any file in a given
+;; project. Projects are defined as per the `project-local-variables'
+;; library, by the presence of a `.emacs-project' file in a directory.
+
+;; By default, it looks only for files whose names match
+;; `ffip-regexp', but it's understood that that variable will be
+;; overridden locally. This can be done either with a mode hook:
+
+;; (add-hook 'emacs-lisp-mode-hook (lambda (setl ffip-regexp ".*\\.el")))
+
+;; or by setting it in your .emacs-project file, in which case it will
+;; get set locally by the project-local-variables library.
+
+;; You can also be a bit more specific about what files you want to
+;; find. For instance, in a Ruby on Rails project, you may be
+;; interested in all .rb files that don't exist in the "vendor"
+;; directory. In that case you could locally set `ffip-find-options'
+;; to "" from within a hook or your .emacs-project file. The options
+;; accepted in that variable are passed directly to the Unix `find'
+;; command, so any valid arguments for that program are acceptable.
+
+;; If `ido-mode' is enabled, the menu will use `ido-completing-read'
+;; instead of `completing-read'.
+
+;; Recommended binding:
+;; (global-set-key (kbd "C-x C-M-f") 'find-file-in-project)
+
+;;; TODO:
+
+;; Performance testing with large projects
+;; Switch to using a hash table if it's too slow
+
+;;; Code:
+
+(require 'project-local-variables)
+
+(defvar ffip-regexp
+  (concat ".*\\.\\(" (mapconcat (lambda (x) x) '("rb" "rhtml" "el") "\\|") "\\)")
+  "Regexp of things to look for when using find-file-in-project.")
+
+(defvar ffip-find-options
+  ""
+  "Extra options to pass to `find' when using find-file-in-project.
+
+Use this to exclude portions of your project: \"-not -regex \\\".*vendor.*\\\"\"")
+
+(defvar ffip-project-root nil
+  "If non-nil, overrides the project root directory location.")
+
+(defun ffip-project-files ()
+  "Return an alist of all filenames in the project and their path.
+
+Files with duplicate filenames are suffixed with the name of the
+directory they are found in so that they are unique."
+  (let ((file-alist nil))
+    (mapcar (lambda (file)
+              (let ((file-cons (cons (file-name-nondirectory file)
+                                     (expand-file-name file))))
+                (when (assoc (car file-cons) file-alist)
+                  (ffip-uniqueify (assoc (car file-cons) file-alist))
+                  (ffip-uniqueify file-cons))
+                (add-to-list 'file-alist file-cons)
+                file-cons))
+            (split-string (shell-command-to-string (concat "find " (or ffip-project-root
+                                                                       (ffip-project-root))
+                                                           " -type f -regex \""
+                                                           ffip-regexp
+                                                           "\" " ffip-find-options))))))
+
+(defun ffip-uniqueify (file-cons)
+  "Set the car of the argument to include the directory name plus the file name."
+  (setcar file-cons
+          (concat (car file-cons) ": "
+                  (cadr (reverse (split-string (cdr file-cons) "/"))))))
+;;;###autoload
+(defun find-file-in-project ()
+  "Prompt with a completing list of all files in the project to find one.
+
+The project's scope is defined as the first directory containing
+an `.emacs-project' file. You can override this by locally
+setting the `ffip-project-root' variable."
+  (interactive)
+  (let* ((project-files (ffip-project-files))
+         (file (if (and (boundp 'ido-mode) ido-mode)
+                   (ido-completing-read "Find file in project: "
+                                        (mapcar 'car project-files))
+                 (completing-read "Find file in project: "
+                                  (mapcar 'car project-files)))))
+    (find-file (cdr (assoc file project-files)))))
+
+;;;###autoload
+(defun ffip-project-root (&optional dir)
+  "Find the root of the project defined by presence of `.emacs-project'."
+  (file-name-directory (plv-find-project-file default-directory "")))
+
+(provide 'find-file-in-project)
+;;; find-file-in-project.el ends here

elpa/nav-35/nav-autoloads.el

+;;; nav-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+
+;;;### (autoloads (nav) "nav" "nav.el" (19270 3784))
+;;; Generated autoloads from nav.el
+
+(autoload 'nav "nav" "\
+Run nav-mode in a narrow window on the left side.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil nil ("nav-pkg.el") (19270 3784 721212))
+
+;;;***
+
+(provide 'nav-autoloads)
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; coding: utf-8
+;; End:
+;;; nav-autoloads.el ends here

elpa/nav-35/nav-pkg.el

+(define-package "nav" "35" "Emacs mode for IDE-like navigation of directories" (quote nil))

elpa/nav-35/nav.el

+;;; nav.el --- Emacs mode for IDE-like navigation of directories
+;;
+;; Copyright 2009 Google Inc. All Rights Reserved.
+;;
+;; Author: issactrotts@google.com (Issac Trotts)
+;; Version: 35
+;;
+
+;;; License:
+;;
+;; Licensed under the Apache License, Version 2.0 (the "License");
+;; you may not use this file except in compliance with the License.
+;; You may obtain a copy of the License at
+;;
+;;      http://www.apache.org/licenses/LICENSE-2.0
+;;
+;; Unless required by applicable law or agreed to in writing, software
+;; distributed under the License is distributed on an "AS IS" BASIS,
+;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+;; See the License for the specific language governing permissions and
+;; limitations under the License.
+
+;;; Commentary:
+;; 
+;; To use this file, put something like the following in your
+;; ~/.emacs:
+;;
+;; (add-to-list 'load-path "/directory/containing/nav/")
+;; (require 'nav)
+;;
+;; Type M-x nav to open the navigation window. It should show up as a
+;; 30-character wide column on the left, showing the contents of the
+;; current directory. If there are multiple windows open, all but one
+;; will be closed to make sure the nav window shows up correctly.
+
+;;; Key Bindings
+;;
+;;   Enter/Return: Open file or directory under cursor.
+;;
+;;   1: Open file under cursor in 1st other window.
+;;   2: Open file under cursor in 2nd other window.
+;;
+;;   c: Copy file or directory under cursor.
+;;   d: Delete file or directory under cursor (asks to confirm first).
+;;   e: Edit current directory in dired.
+;;   f: Recursively find files whose names or contents match some regexp.
+;;   g: Recursively grep for some regexp.
+;;   j: Jump to another directory.
+;;   m: Move or rename file or directory.
+;;   n: Make new directory.
+;;   p: Pop directory stack to go back to the directory where you just were.
+;;   q: Quit nav.
+;;   r: Refresh.
+;;   s: Start a shell in an emacs window in the current directory.
+;;   t: Start a terminal in an emacs window in the current directory.
+;;      This allows programs like vi and less to run. Exit with C-d C-d.
+;;   u: Go up to parent directory.
+;;   !: Run shell command.
+;;   [: Rotate non-nav windows counter clockwise.
+;;   ]: Rotate non-nav windows clockwise.
+;;
+
+;;; History:
+;;
+;; See http://code.google.com/p/emacs-nav/source/list
+;;
+
+;;; Code:
+
+(require 'cl)
+
+
+(defgroup nav nil
+  "A lightweight file/directory navigator."
+  :group 'applications)
+
+(defcustom nav-width 30
+  "*Initial width of the Nav window."
+  :type 'integer
+  :group 'nav)
+
+(defcustom nav-boring-file-regexps
+  (list "\\.pyc$" "\\.o$" "~$" "\\.bak$" "^\\.[^/]" "^\\./?$" "/\\.")
+  "*Nav ignores filenames that match any regular expression in this list."
+  :type '(repeat string)
+  :group 'nav)
+
+(defcustom nav-split-window-direction 'horizontal
+  "*Window split direction for `nav-open-file-other-window-2'.
+
+This is used if only one window besides the Nav window is visible."
+  :type '(choice (const horizontal) (const vertical))
+  :group 'nav)
+
+(defcustom nav-resize-frame-p nil
+  "*If non-nil, activating and deactivating nav will resize the current frame."
+  :type 'boolean
+  :group 'nav)
+
+
+(defun nav-make-mode-map ()
+  "Creates and returns a mode map with nav's key bindings."
+  (let ((keymap (make-sparse-keymap)))
+    (define-key keymap "\n" 'nav-open-file-under-cursor)
+    (define-key keymap "\r" 'nav-open-file-under-cursor)
+    (define-key keymap "1" 'nav-open-file-other-window-1)
+    (define-key keymap "2" 'nav-open-file-other-window-2)
+    (define-key keymap "c" 'nav-copy-file-or-dir)
+    (define-key keymap "d" 'nav-delete-file-or-dir-on-this-line)
+    (define-key keymap "e" 'nav-invoke-dired)
+    (define-key keymap "f" 'nav-find-files)
+    (define-key keymap "g" 'nav-recursive-grep)
+    (define-key keymap "j" 'nav-jump-to-dir)
+    (define-key keymap "m" 'nav-move-file)
+    (define-key keymap "n" 'nav-make-new-directory)
+    (define-key keymap "p" 'nav-pop-dir)
+    (define-key keymap "q" 'nav-quit)
+    (define-key keymap "r" 'nav-refresh)
+    (define-key keymap "s" 'nav-shell)
+    (define-key keymap "t" 'nav-term)
+    (define-key keymap "u" 'nav-go-up-one-dir)
+    (define-key keymap "[" 'nav-rotate-windows-ccw)
+    (define-key keymap "]" 'nav-rotate-windows-cw)
+    (define-key keymap "!" 'nav-shell-command)
+    (define-key keymap ":" 'nav-turn-off-keys-and-be-writable)
+    (define-key keymap [(control ?x) (control ?f)] 'find-file-other-window)
+    keymap))
+
+
+;; I use setq instead of defvar here so we can just use M-x
+;; eval-buffer instead of restarting emacs or other junk after
+;; changing the nav mode map.
+(setq nav-mode-map (nav-make-mode-map))
+
+(defvar nav-dir-stack '())
+
+(defvar nav-map-dir-to-line-number (make-hash-table :test 'equal)
+  "Hash table from dir paths to most recent cursor pos in them.")
+
+(defconst nav-shell-buffer-name "*nav-shell*"
+  "Name of the buffer used for the command line shell spawned by
+  nav on the 's' key.")
+
+(defconst nav-buffer-name "*nav*"
+  "Name of the buffer where nav shows directory contents.")
+
+(defconst nav-buffer-name-for-find-results "*nav-find*"
+  "Name of the buffer where nav shows results of its find command ('f' key).")
+
+
+(defun nav-join (sep string-list)
+  (mapconcat 'identity string-list sep))
+
+
+(defun nav-filename-matches-some-regexp (filename regexps)
+  (let ((matches-p nil))
+    (dolist (rx regexps)
+      (if (string-match rx filename)
+          (setq matches-p t)))
+      matches-p))
+
+
+(defun nav-filter-out-boring-filenames (filenames boring-regexps)
+  (flet ((is-boring (filename)
+                    (nav-filename-matches-some-regexp filename boring-regexps)))
+    (remove-if 'is-boring filenames)))
+
+
+(defun nav-get-non-boring-filenames-recursively (dirname)
+  (let ((paths (nav-get-paths dirname)))
+    (nav-filter-out-boring-filenames paths (cons "/$" nav-boring-file-regexps))))
+
+
+(defun nav-dir-files-or-nil (dirname)
+  "Returns a list of files in DIRNAME. 
+If DIRNAME is not a directory or is not accessible, returns nil."
+  (condition-case err
+      (directory-files dirname)
+    (file-error nil)))
+
+
+(defun nav-get-line-for-cur-dir ()
+  (gethash (nav-get-working-dir) nav-map-dir-to-line-number))
+
+
+(defun nav-cd (dirname)
+  "Changes to a different directory and pushes it onto the stack."
+  (let ((dirname (file-name-as-directory (file-truename dirname))))
+    ;; Update line number hash table.
+    (let ((line-num (nav-line-number-at-pos (point))))
+      (puthash (nav-get-working-dir) line-num nav-map-dir-to-line-number))
+
+    (setq default-directory dirname)
+    (nav-show-dir dirname)
+    
+    ;; Remember what line we were on last time we visited this directory.
+    (let ((line-num (nav-get-line-for-cur-dir)))
+      (when line-num
+        (goto-line line-num)))))
+
+
+(defun nav-open-file (filename)
+  "Opens a file or directory from Nav."
+  (interactive "FFilename:")
+  (if (file-directory-p filename)
+      (nav-push-dir filename)
+    (if (file-exists-p filename)
+        (find-file-other-window filename))))
+
+
+(defun nav-open-file-under-cursor ()
+  "Finds the file undert the cursor in the window not containing Nav."
+  (interactive)
+  (let ((filename (nav-get-cur-line-str)))
+    (nav-open-file filename)))
+
+
+(defun nav-go-up-one-dir ()
+  "Points Nav to ../."
+  (interactive)
+  (nav-push-dir ".."))
+
+
+(defun nav-push-dir (dirname)
+  (push (file-truename default-directory) nav-dir-stack)
+  (nav-cd dirname))
+
+
+(defun nav-pop-dir ()
+  "Goes to the previous directory in Nav's history.
+This works like a web browser's back button."
+  (interactive)
+  (let ((dir nil))
+    (while (and nav-dir-stack
+                (or (not dir)
+                    (equal dir (file-name-as-directory (file-truename ".")))
+                    (not (file-exists-p dir))))
+      (setq dir (pop nav-dir-stack)))
+    (setq dir (or dir "."))
+    (nav-cd dir)))
+
+
+(defun nav-get-cur-line-str ()
+  (buffer-substring-no-properties (point-at-bol)
+                                  (point-at-eol)))
+
+
+(defun nav-non-boring-directory-files (dir)
+  (nav-filter-out-boring-filenames (directory-files dir) nav-boring-file-regexps))
+
+
+(defun nav-dir-suffix (dir)
+  (replace-regexp-in-string ".*/" "" (directory-file-name dir)))
+
+
+(defun nav-line-number-at-pos (p)
+  (let ((line-num 1))
+    (dotimes (i p line-num)
+      (if (eq ?\n (char-after i))
+          (setq line-num (+ line-num 1))))))
+
+
+(defun nav-replace-buffer-contents (new-contents should-make-filenames-clickable)
+  (let ((saved-line-number (nav-line-number-at-pos (point)))
+        ;; Setting inhibit-read-only to t here lets us edit the buffer
+        ;; in this let-block.
+        (inhibit-read-only t))
+    (erase-buffer)
+    (insert new-contents)
+    (font-lock-fontify-buffer)
+    (if should-make-filenames-clickable
+        (nav-make-filenames-clickable))
+    (goto-line saved-line-number)))
+
+
+(defun nav-make-filenames-clickable ()
+  (condition-case err
+      (save-excursion
+        (goto-line 1)
+        (dotimes (i (count-lines 1 (point-max)))
+          (let ((start (line-beginning-position))
+                (end (line-end-position)))
+            (make-button start end
+                         'action (lambda (button)
+                                   (nav-open-file (button-label button)))
+                         'follow-link t
+                         'help-echo ""))
+          (forward-line 1)))
+    (error 
+     ;; This can happen for versions of emacs that don't have
+     ;; make-button defined.
+     'failed)))
+
+
+(defun nav-show-dir (dir)
+  (let ((new-contents '("../")))
+    (dolist (filename (nav-non-boring-directory-files dir))
+      (let ((line (concat "\n" filename
+                          (if (file-directory-p filename)
+                              "/"
+                            ""))))
+        (push line new-contents)))
+    (let ((new-contents (nav-join "" (reverse new-contents))))
+      (nav-replace-buffer-contents new-contents t))
+    (setq mode-line-format (concat "nav: " (nav-dir-suffix (file-truename dir)) "/"))
+    (force-mode-line-update)))
+
+
+(defun nav-set-window-width (n)
+  (if (> (window-width) n)
+    (shrink-window-horizontally (- (window-width) n)))
+  (if (< (window-width) n)
+    (enlarge-window-horizontally (- n (window-width)))))
+
+
+(defun nav-set-window-height (n)
+  (if (> (window-height) n)
+    (shrink-window (- (window-height) n)))
+  (if (< (window-height) n)
+    (enlarge-window (- n (window-height)))))
+
+
+(defun nav-get-working-dir ()
+  (save-current-buffer
+    (set-buffer nav-buffer-name)
+    (file-name-as-directory (file-truename default-directory))))
+
+
+(defun nav-invoke-dired ()
+  "Invokes dired on the current directory."
+  (interactive)
+  (other-window 1)
+  (dired (nav-get-working-dir)))
+
+
+(defun nav-open-file-other-window (k)
+  (let ((filename (nav-get-cur-line-str))
+        (dirname (nav-get-working-dir)))
+    (other-window k)
+    (find-file (concat dirname "/" filename))))
+
+
+(defun nav-open-file-other-window-1 ()
+  "Opens the file under the cursor in the first other window.
+This is equivalent to just pressing the [enter] key. 
+See nav-open-file-other-window-2."
+  (interactive)
+  (nav-open-file-other-window 1))
+
+
+(defun nav-open-file-other-window-2 ()
+  "Opens the file under the cursor in the second other window.
+If there is no second other window, Nav will create one."
+  (interactive)
+  (when (= 2 (length (window-list)))
+    (other-window 1)
+    (if (eq nav-split-window-direction 'horizontal)
+        (split-window-horizontally)
+      (split-window-vertically))
+    (select-window (nav-get-window nav-buffer-name)))
+  (nav-open-file-other-window 2))
+
+
+(defun nav-get-window (buf-name)
+  "Returns a window whose buffer has a given name."
+  (let ((nav-win nil))
+    (dolist (w (window-list))
+      (if (string= buf-name (buffer-name (window-buffer w)))
+          (setq nav-win w)))
+    nav-win))
+
+
+(defun nav-outer-width ()
+  (let* ((edges (window-edges (nav-get-window nav-buffer-name)))
+         (left (nth 0 edges))
+         (right (nth 2 edges)))
+    (- right left)))
+
+
+(defun nav-refresh ()
+  "Resizes the Nav window to its original size and updates its contents."
+  (interactive)
+  (nav-set-window-width nav-width)
+  (nav-show-dir "."))
+
+
+(defun nav-quit ()
+  "Exits Nav."
+  (interactive)
+  (let ((window	(get-buffer-window nav-buffer-name)))
+    (when window
+      (when nav-resize-frame-p
+        (set-frame-width (selected-frame) 
+                         (- (frame-width) (nav-outer-width))))
+      (delete-window window)))
+  (kill-buffer nav-buffer-name))
+
+
+(defun nav-is-open ()
+  "Returns non-nil if Nav is open."
+  (nav-get-window nav-buffer-name))
+
+
+(defun nav-toggle ()
+  "Toggles whether Nav is active.
+Synonymous with the (nav) function."
+  (interactive)
+  (nav))
+
+
+(defun nav-make-recursive-grep-command (pattern)
+  (let* ((file-paths (nav-get-non-boring-filenames-recursively "."))
+         (temp-filename (make-temp-file "nav")))
+    (other-window 1)
+    (save-current-buffer
+      (find-file temp-filename)
+      (insert (nav-join "\0" file-paths))
+      (save-buffer))
+    (select-window (nav-get-window nav-buffer-name))
+    (format "cat %s | xargs -0 grep -inH '%s'" temp-filename pattern)))
+
+
+(defun nav-recursive-grep (pattern)
+  "Greps for a regular expression in '.' and all subdirectories."
+  (interactive "sPattern to recursively grep for: ")
+  (grep (nav-make-recursive-grep-command pattern))
+  (other-window 1))
+
+
+(defun nav-jump-to-dir (dirname)
+  "Shows a specified directory in Nav."
+  (interactive "fDirectory: ")
+  (nav-push-dir dirname))
+
+
+(defun nav-this-is-a-microsoft-os ()
+  (or (string= system-type "windows-nt")
+      (string= system-type "ms-dos")))
+
+
+(defun nav-make-remove-dir-command (dirname)
+  (if (nav-this-is-a-microsoft-os)
+      (format "rmdir /S /Q \"%s\"" dirname)
+    (format "rm -rf '%s'" dirname)))
+
+
+(defun nav-delete-file-or-dir (filename)
+  (if (and (file-directory-p filename)
+           (not (file-symlink-p (directory-file-name filename))))
+      (when (yes-or-no-p (format "Really delete directory %s ?" filename))
+        (shell-command (nav-make-remove-dir-command filename))
+        (nav-refresh))
+      ;; We first use directory-file-name to strip the trailing slash
+      ;; if it's a symlink to a directory.
+      (let ((filename (directory-file-name filename)))
+        (when (y-or-n-p (format "Really delete file %s ? " filename))
+          (delete-file filename)
+          (nav-refresh)))))
+
+
+(defun nav-delete-file-or-dir-on-this-line ()
+  "Deletes a file or directory."
+  (interactive)
+  (nav-delete-file-or-dir (nav-get-cur-line-str)))
+
+
+(defun nav-ok-to-overwrite (target-name)
+  "Returns non-nil if it's ok to overwrite or create a file.
+That is, if a file with the given name doesn't exist, is a
+directory, or if the user says it's ok."
+  (or (not (file-exists-p target-name))
+      (file-directory-p target-name)
+      (y-or-n-p (format "Really overwrite %s ? " target-name))))
+
+
+(defun nav-copy-file-or-dir (target-name)
+  "Copies a file or directory."
+  (interactive "sCopy to: ")
+  (let ((filename (nav-get-cur-line-str)))
+    (if (nav-this-is-a-microsoft-os)
+	(copy-file filename target-name)
+      (if (nav-ok-to-overwrite target-name)
+	  (let ((maybe-dash-r (if (file-directory-p filename) "-r" "")))
+	    (shell-command (format "cp %s '%s' '%s'" maybe-dash-r filename
+                                   target-name))))))
+  (nav-refresh))
+
+
+(defun nav-move-file (new-name)
+  "Moves a file."
+  (interactive "sNew name or directory: ")
+  (let ((old-name (nav-get-cur-line-str)))
+    (if (nav-this-is-a-microsoft-os)
+	(rename-file old-name new-name)
+      (if (nav-ok-to-overwrite new-name)
+	  (shell-command (format "mv %s %s" old-name new-name)))))
+  (nav-refresh))
+
+
+(defun nav-make-grep-list-cmd (pattern filenames)
+  (if (not filenames)
+      ""
+    (format "grep -il '%s' %s" pattern (nav-join " " filenames))))
+
+
+(defun nav-append-slashes-to-dir-names (names)
+  (mapcar (lambda (name)
+            (if (file-directory-p name)
+                (concat name "/")
+              name))
+          names))
+
+
+(defun nav-find-files (pattern)
+  "Finds files whose names match a regular expression, in '.' and all subdirs."
+  (interactive "sPattern: ")
+  (let* ((filenames (nav-get-non-boring-filenames-recursively "."))
+         (names-matching-pattern
+          (remove-if-not (lambda (name) (string-match pattern name)) filenames))
+         (names-matching-pattern
+          (nav-append-slashes-to-dir-names names-matching-pattern)))
+    (pop-to-buffer nav-buffer-name-for-find-results nil)
+    (if names-matching-pattern
+        (nav-show-find-results names-matching-pattern)
+        (nav-replace-buffer-contents
+         "No matching files found."
+         nil))))
+
+
+(defun nav-show-find-results (paths)
+  (nav-replace-buffer-contents
+   (nav-join "\n" names-matching-pattern)
+   t)
+  ;; Enable nav keyboard shortcuts, mainly so hitting enter will open
+  ;; files.
+  (use-local-map nav-mode-map))
+
+
+(defun nav-make-new-directory (name)
+  "Creates a new directory."
+  (interactive "sMake directory: ")
+  (make-directory name)
+  (nav-refresh))
+
+
+(defun nav-shell ()
+  "Starts up a shell on the current nav directory."
+  (interactive)
+  (shell nav-shell-buffer-name)
+  ;; Tell the shell to cd to the working directory of nav.
+  (process-send-string (get-buffer-process nav-shell-buffer-name)
+                       (format "cd '%s'\n" (nav-get-working-dir)))
+  ;; Make sure the shell knows to do completion in the new directory.
+  (shell-process-cd (nav-get-working-dir)))
+
+
+(defun nav-term ()
+  "Starts up a term on the current nav directory.
+
+If there is already a *terminal* buffer then it is reused."
+  (interactive)
+  (let ((nav-temp-file "*nav-temp*"))
+    (find-file-other-window nav-temp-file)
+    (setq default-directory (nav-get-working-dir))
+    (term "/bin/bash")
+    (kill-buffer nav-temp-file)))
+
+
+(defun nav-get-other-windows ()
+  "Returns a list of windows other than the Nav window."
+  (let* ((nav-window (get-buffer-window nav-buffer-name))
+         (cur-window (next-window nav-window))
+         (result '()))
+    (while (not (eq cur-window nav-window))
+      (if (not (window-minibuffer-p cur-window))
+          (push cur-window result))
+      (setq cur-window (next-window cur-window)))
+    (reverse result)))
+
+
+(defun nav-rotate-windows-cw ()
+  "Cyclically permutes the windows other than the nav window, clockwise."
+  (interactive)
+  (nav-rotate-windows (lambda (i) (mod (+ i 1) n))))
+
+
+(defun nav-rotate-windows-ccw ()
+  "Cyclically permutes the windows other than the nav window, counter-clockwise."
+  (interactive)
+  (nav-rotate-windows (lambda (i) (mod (+ i n -1) n))))
+
+
+(defun nav-rotate-windows (next-i)
+  "Cyclically permutes the windows other than the nav window.
+The permutation is either clockwise or counter-clockwise
+depending on the passed-in function next-i."
+  (let* ((win-list (nav-get-other-windows))
+         (win-vec (apply 'vector win-list))
+         (buf-list (mapcar 'window-buffer win-list))
+         (buf-vec (apply 'vector buf-list))
+         (n (length win-vec)))
+    (dotimes (i n)
+      (set-window-buffer (aref win-vec (funcall next-i i))
+                         (buffer-name (aref buf-vec i))))))
+
+
+(defun nav-get-paths (dir-path)
+  "Recursively finds all paths starting with a given directory name."
+  (let* ((dir-path (file-name-as-directory dir-path))
+         (paths (list dir-path)))
+    (dolist (file-name (directory-files dir-path))
+      (when (not (or (string= "." file-name)
+                     (string= ".." file-name)))
+            (let ((file-path (format "%s%s" dir-path file-name)))
+              (if (and (file-directory-p file-path)
+                       (not (file-symlink-p file-path)))
+                  (let ((more-paths (nav-get-paths (format "%s/" file-path))))
+                    (setq paths (append (reverse more-paths) paths)))
+                (push file-path paths)))))
+    (reverse paths)))
+
+
+(defun nav-shell-command (command)
+  "Runs a shell command and then refreshes the Nav window."
+  (interactive "sShell command: ")
+  (shell-command command)
+  (nav-refresh))
+
+
+(defun nav-resize-frame ()
+  "Widens the frame to fit Nav without shrinking the editing space."
+  (set-frame-width (selected-frame) 
+                   (+ (frame-width) (nav-outer-width)))
+  ;; set-frame-width resizes the nav window; set it back
+  (nav-set-window-width nav-width))
+
+
+(define-derived-mode nav-mode fundamental-mode 
+  "Nav-mode is for IDE-like navigation of directories.
+
+ It's more IDEish than dired, not as heavy weight as speedbar."
+  (nav-set-window-width nav-width)
+  (setq mode-name "Navigation")
+  (use-local-map nav-mode-map)
+  (turn-on-font-lock)
+  (font-lock-add-keywords 'nav-mode '(("^.*/$" . font-lock-type-face)))
+  (setq buffer-read-only t)
+  (nav-refresh))
+
+
+;; For ELPA, the Emacs Lisp Package Archive
+;;;###autoload
+(defun nav ()
+  "Run nav-mode in a narrow window on the left side."
+  (interactive)
+  (if (nav-is-open)
+      (nav-quit)
+    (delete-other-windows)
+    (split-window-horizontally)
+    (other-window 1)
+    (ignore-errors (kill-buffer nav-buffer-name))
+    (pop-to-buffer nav-buffer-name nil)
+    (set-window-dedicated-p (selected-window) t)
+    (nav-mode)
+    (when nav-resize-frame-p
+      (nav-resize-frame))))
+
+
+(provide 'nav)
+
+;;; nav.el ends here

Binary file added.

elpa/project-local-variables-0.2/project-local-variables-autoloads.el

+;;; project-local-variables-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+
+
+;;;### (autoloads (plv-find-project-file) "project-local-variables"
+;;;;;;  "project-local-variables.el" (19270 3783))
+;;; Generated autoloads from project-local-variables.el
+
+(autoload 'plv-find-project-file "project-local-variables" "\
+Look up the project file in and above `dir'.
+
+\(fn DIR MODE-NAME)" nil nil)
+
+(defadvice hack-local-variables (before project-local-variables activate) "\
+Load the appropriate .emacs-project files for a file." (let* ((full-name (symbol-name major-mode)) (mode-name (if (string-match "\\(.*\\)-mode$" full-name) (match-string 1 full-name) full-name)) (pfile (plv-find-project-file default-directory (concat "-" mode-name))) (gfile (plv-find-project-file default-directory ""))) (save-excursion (when gfile (load gfile)) (when pfile (load pfile)))))
+
+;;;***
+
+;;;### (autoloads nil nil ("project-local-variables-pkg.el") (19270
+;;;;;;  3783 710929))
+
+;;;***
+
+(provide 'project-local-variables-autoloads)
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; coding: utf-8
+;; End:
+;;; project-local-variables-autoloads.el ends here

elpa/project-local-variables-0.2/project-local-variables-pkg.el

+(define-package "project-local-variables" "0.2" "set project-local variables from a file" (quote nil))

elpa/project-local-variables-0.2/project-local-variables.el

+;;; project-local-variables.el --- set project-local variables from a file
+
+;; Copyright (C) 2008 Ryan Davis and Phil Hagelberg
+
+;; Author: Ryan Davis and Phil Hagelberg
+;; URL: http://www.emacswiki.org/cgi-bin/wiki/ProjectLocalVariables
+;; Version: 0.2
+;; Created: 2008-03-18
+;; Keywords: project, convenience
+;; EmacsWiki: ProjectLocalVariables
+
+;; This file is NOT part of GNU Emacs.
+
+;;; License:
+
+;; 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, 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 GNU Emacs; see the file COPYING.  If not, write to the
+;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+;; Boston, MA 02110-1301, USA.
+
+;;; Commentary:
+
+;; This file allows you to create .emacs-project files that are
+;; evaluated when a file is opened. You may also create
+;; .emacs-project-$MODE files that only get loaded when you open files
+;; of a specific mode in the project. All files for which a
+;; .emacs-project file exists in an ancestor directory will have it
+;; loaded.
+
+;; It has not been tested in versions of Emacs prior to 22.
+
+(defvar plv-project-file ".emacs-project"
+  "Name prefix for project files.
+ Emacs appends name of major mode and looks for such a file in
+ the current directory and its parents.")
+
+(defmacro setl (sym val)
+  "Like setq, but makes sym a local variable first."
+  `(set (make-local-variable ',sym) ,val))
+
+;;;###autoload
+(defun plv-find-project-file (dir mode-name)
+  "Look up the project file in and above `dir'."
+ (let ((f (expand-file-name (concat plv-project-file mode-name) dir))
+       (parent (file-truename (expand-file-name ".." dir))))
+   (cond ((string= dir parent) nil)
+         ((file-exists-p f) f)
+         (t (plv-find-project-file parent mode-name)))))
+
+;;;###autoload
+(defadvice hack-local-variables (before project-local-variables activate)
+  "Load the appropriate .emacs-project files for a file."
+  (let* ((full-name (symbol-name major-mode))
+         (mode-name (if (string-match "\\(.*\\)-mode$" full-name)
+                        (match-string 1 full-name)
+                      full-name))
+         (pfile (plv-find-project-file default-directory (concat "-" mode-name)))
+         (gfile (plv-find-project-file default-directory "")))
+    (save-excursion
+      (when gfile (load gfile))
+      (when pfile (load pfile)))))
+
+(add-to-list 'auto-mode-alist '("^\.emacs-project" . emacs-lisp-mode))
+
+(provide 'project-local-variables)
+;;; project-local-variables.el ends here

eproject/.git/HEAD

+ref: refs/heads/master

eproject/.git/config

+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+[remote "origin"]
+	fetch = +refs/heads/*:refs/remotes/origin/*
+	url = git://github.com/jrockway/eproject.git
+[branch "master"]
+	remote = origin
+	merge = refs/heads/master

eproject/.git/description

+Unnamed repository; edit this file 'description' to name the repository.

eproject/.git/hooks/applypatch-msg.sample

+#!/bin/sh
+#
+# An example hook script to check the commit log message taken by
+# applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "applypatch-msg".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/commit-msg" &&
+	exec "$GIT_DIR/hooks/commit-msg" ${1+"$@"}
+:

eproject/.git/hooks/commit-msg.sample

+#!/bin/sh
+#
+# An example hook script to check the commit log message.
+# Called by git-commit with one argument, the name of the file
+# that has the commit message.  The hook should exit with non-zero
+# status after issuing an appropriate message if it wants to stop the
+# commit.  The hook is allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "commit-msg".
+
+# Uncomment the below to add a Signed-off-by line to the message.
+# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
+# hook is more suited to it.
+#
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
+
+# This example catches duplicate Signed-off-by lines.
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	exit 1
+}

eproject/.git/hooks/post-commit.sample

+#!/bin/sh
+#
+# An example hook script that is called after a successful
+# commit is made.
+#
+# To enable this hook, rename this file to "post-commit".
+
+: Nothing

eproject/.git/hooks/post-receive.sample

+#!/bin/sh
+#
+# An example hook script for the "post-receive" event.
+#
+# The "post-receive" script is run after receive-pack has accepted a pack
+# and the repository has been updated.  It is passed arguments in through
+# stdin in the form
+#  <oldrev> <newrev> <refname>
+# For example:
+#  aa453216d1b3e49e7f6f98441fa56946ddcd6a20 68f7abf4e6f922807889f52bc043ecd31b79f814 refs/heads/master
+#
+# see contrib/hooks/ for an sample, or uncomment the next line and
+# rename the file to "post-receive".
+
+#. /usr/share/doc/git-core/contrib/hooks/post-receive-email

eproject/.git/hooks/post-update.sample

+#!/bin/sh
+#
+# An example hook script to prepare a packed repository for use over
+# dumb transports.
+#
+# To enable this hook, rename this file to "post-update".
+
+exec git-update-server-info

eproject/.git/hooks/pre-applypatch.sample

+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-applypatch".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/pre-commit" &&
+	exec "$GIT_DIR/hooks/pre-commit" ${1+"$@"}
+:

eproject/.git/hooks/pre-commit.sample

+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by git-commit with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git-rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
+fi
+
+exec git diff-index --check --cached $against --

eproject/.git/hooks/pre-rebase.sample

+#!/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git-rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master.  Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git-rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next?  If so you should not be rebasing it.
+only_next_1=`git-rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git-rev-list ^master           ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git-rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up-to-date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git-rev-list --pretty=oneline ^${publish} "$topic"`
+	perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+exit 0
+
+################################################################
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+   merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+   it is deleted.  If you need to build on top of it to correct
+   earlier mistakes, a new topic branch is created by forking at
+   the tip of the "master".  This is not strictly necessary, but
+   it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+   branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next".  Young
+    topic branches can have stupid mistakes you would rather
+    clean up before publishing, and things that have not been
+    merged into other branches can be easily rebased without
+    affecting other people.  But once it is published, you would
+    not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+    Then you can delete it.  More importantly, you should not
+    build on top of it -- other people may already want to
+    change things related to the topic as patches against your
+    "master", so if you need further changes, it is better to
+    fork the topic (perhaps with the same name) afresh from the
+    tip of "master".
+
+Let's look at this example:
+
+		   o---o---o---o---o---o---o---o---o---o "next"
+		  /       /           /           /
+		 /   a---a---b A     /           /
+		/   /               /           /
+	       /   /   c---c---c---c B         /
+	      /   /   /             \         /
+	     /   /   /   b---b C     \       /
+	    /   /   /   /             \     /
+    ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished.  It has been fully merged up to "master" and "next",
+   and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git-rev-list ^master ^topic next
+	git-rev-list ^master        next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git-rev-list master..topic
+
+	if this is empty, it is fully merged to "master".

eproject/.git/hooks/prepare-commit-msg.sample

+#!/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by git-commit with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples.  The first comments out the
+# "Conflicts:" part of a merge commit.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+case "$2,$3" in
+  merge,)
+    perl -i.bak -ne 's/^/# /, s/^# #/#/ if /^Conflicts/ .. /#/; print' "$1" ;;
+
+# ,|template,)
+#   perl -i.bak -pe '
+#      print "\n" . `git diff --cached --name-status -r`
+#	 if /^#/ && $first++ == 0' "$1" ;;
+
+  *) ;;
+esac
+
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"

eproject/.git/hooks/update.sample

+#!/bin/sh
+#
+# An example hook script to blocks unannotated tags from entering.
+# Called by git-receive-pack with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+#   This boolean sets whether unannotated tags will be allowed into the
+#   repository.  By default they won't be.
+# hooks.allowdeletetag
+#   This boolean sets whether deleting tags will be allowed in the
+#   repository.  By default they won't be.
+# hooks.allowdeletebranch
+#   This boolean sets whether deleting branches will be allowed in the
+#   repository.  By default they won't be.
+# hooks.denycreatebranch
+#   This boolean sets whether remotely creating branches will be denied
+#   in the repository.  By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo "  $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "Usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --bool hooks.allowunannotated)
+allowdeletebranch=$(git config --bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --bool hooks.denycreatebranch)
+allowdeletetag=$(git config --bool hooks.allowdeletetag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero="0000000000000000000000000000000000000000"
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git-cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

Binary file added.

eproject/.git/info/exclude

+# git-ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~

eproject/.git/logs/HEAD

+0000000000000000000000000000000000000000 7c545e903421a90f99e43ca1fb8c4535d59daaf2 lhonda <lhonda@lhonda-desktop.(none)> 1262964228 -0200	clone: from git://github.com/jrockway/eproject.git

eproject/.git/logs/refs/heads/master

+0000000000000000000000000000000000000000 7c545e903421a90f99e43ca1fb8c4535d59daaf2 lhonda <lhonda@lhonda-desktop.(none)> 1262964228 -0200	clone: from git://github.com/jrockway/eproject.git

eproject/.git/logs/refs/remotes/origin/HEAD

+0000000000000000000000000000000000000000 7c545e903421a90f99e43ca1fb8c4535d59daaf2 lhonda <lhonda@lhonda-desktop.(none)> 1262964228 -0200	clone: from git://github.com/jrockway/eproject.git
Add a comment to this file

eproject/.git/objects/pack/pack-29b0332736f67dce53eb298a1e54763ccea573da.idx

Binary file added.

Add a comment to this file

eproject/.git/objects/pack/pack-29b0332736f67dce53eb298a1e54763ccea573da.pack

Binary file added.

eproject/.git/packed-refs

+# pack-refs with: peeled 
+7c545e903421a90f99e43ca1fb8c4535d59daaf2 refs/remotes/origin/master

eproject/.git/refs/heads/master

+7c545e903421a90f99e43ca1fb8c4535d59daaf2

eproject/.git/refs/remotes/origin/HEAD

+ref: refs/remotes/origin/master

eproject/.gitignore

+/eproject-extras.elc
+/eproject.elc

eproject/eproject-extras.el

+;;; eproject-extras.el --- various utilities that make eproject more enjoyable
+
+;; Copyright (C) 2009  Jonathan Rockway
+
+;; Author: Jonathan Rockway <jon@jrock.us>
+;; Keywords: eproject
+
+;; 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:
+
+;; Some of this stuff used to be in eproject "core", but it is a bit
+;; bloated, and not strictly necessary.  So now it lives here, leaving
+;; the eproject core pristine and minimal.
+
+;;; User-visible commands:
+
+;; eproject-find-file
+;;
+;; - easily visit another file in the current project
+
+;; eproject-ibuffer
+;;
+;; - open an ibuffer with current project buffers (or other project if
+;;   invoked with prefix arg)
+
+;; eproject-kill-project-buffers
+;;
+;; - kill all of the current project's buffers (or other project if
+;;   prefixed)
+
+;; eproject-open-all-project-files
+;;
+;; - open all files in the current project (or other project if
+;;   prefixed)
+
+;; eproject-revisit-project
+;;
+;; - open the named project root, or a project file if prefixed
+
+
+;;; Code:
+
+(require 'eproject)
+(require 'cl)
+(require 'iswitchb)
+(require 'ibuffer)
+(require 'ibuf-ext)
+
+;; support for visiting other project files
+(defalias 'eproject-ifind-file 'eproject-find-file)  ;; ifind is deperecated
+
+(defun eproject--shorten-filename (filename)
+  (if (string-match (format "^%s\\(.+\\)$" (regexp-quote (eproject-root))) filename)
+      (cons (funcall (eproject-attribute :file-name-map)
+                     (eproject-root)
+                     (match-string 1 filename))
+            filename)
+    (cons filename filename))) ;; should never happen, but who knows
+
+
+(defun eproject-find-file ()
+  "Present the user with a list of files in the current project
+to select from, open file when selected."
+  (interactive)
+  (find-file (eproject--icomplete-read-with-alist
+              "Project file: "
+              (mapcar #'eproject--shorten-filename (eproject-list-project-files)))))
+
+(defun eproject--completing-read (prompt choices)
+  "Use completing-read to do a completing read."
+  (completing-read prompt choices nil t))
+
+(defun eproject--icompleting-read (prompt choices)
+  "Use iswitchb to do a completing read."
+  (let ((iswitchb-make-buflist-hook
+         (lambda ()
+           (setq iswitchb-temp-buflist choices))))
+    (unwind-protect
+        (progn
+          (when (not iswitchb-mode)
+            (add-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup))
+          (iswitchb-read-buffer prompt nil t))
+      (when (not iswitchb-mode)
+        (remove-hook 'minibuffer-setup-hook 'iswitchb-minibuffer-setup)))))
+
+(defun eproject--ido-completing-read (prompt choices)
+  "Use ido to do a completing read."
+  (ido-completing-read prompt choices nil t))
+
+(defcustom eproject-completing-read-function
+  #'eproject--icompleting-read
+  "The function used to ask the user select a single file from a
+list of files; used by `eproject-find-file'."
+  :group 'eproject
+  :type '(radio (function-item :doc "Use emacs' standard completing-read function."
+                               eproject--completing-read)
+                (function-item :doc "Use iswitchb's completing-read function."
+                               eproject--icompleting-read)
+                (function-item :doc "Use ido's completing-read function."
+                               eproject--ido-completing-read)
+                (function)))
+
+(defun eproject--do-completing-read (&rest args)
+  "Do a completing read with the user's favorite completing read function."
+  (apply eproject-completing-read-function args))
+
+(defun eproject--icomplete-read-with-alist (prompt alist)
+  (let ((show (mapcar (lambda (x) (car x)) alist)))
+    (cdr (assoc (eproject--do-completing-read prompt show) alist))))
+
+(defun eproject--project-buffers ()
+  "Return an alist mapping each project root to its open buffers."
+  (let ((hash (make-hash-table :test 'equal)))
+    (loop for (root attrs) in eproject-attributes-alist
+          do (setf (gethash root hash) nil))
+    (loop for (root . buf) in
+          (delete-if #'not
+              (mapcar (lambda (b) (ignore-errors (cons (eproject-root b) b)))
+                      (buffer-list)))
+          do (push buf (gethash root hash nil)))
+    (loop for key being the hash-keys of hash
+          collect (cons key (gethash key hash)))))
+
+(defun* eproject--get-name-root-alist (&key live-only)
+  (let ((buffers (eproject--project-buffers)))
+    (when (null buffers)
+      (error "No projects yet"))
+    (loop for (root . attrs) in
+          (remove-if-not (lambda (attrs)
+                           (or (not live-only)
+                               (cdr (assoc (car attrs) buffers))))
+                     eproject-attributes-alist)
+        collect (cons (getf attrs :name) root))))
+
+(defun* eproject--read-project-name (&key live-only)
+  (eproject--icomplete-read-with-alist
+   "Project name: " (eproject--get-name-root-alist :live-only live-only)))
+
+(defun* eproject--handle-root-prefix-arg (prefix &key live-only)
+  (if (= prefix 4)
+      (eproject--read-project-name :live-only live-only)
+    (eproject-root)))
+
+;; ibuffer support
+
+(define-ibuffer-filter eproject-root
+    "Filter buffers that have the provided eproject root"
+  (:reader (read-directory-name "Project root: " (ignore-errors (eproject-root)))
+   :description "project root")
+  (with-current-buffer buf
+    (equal (file-name-as-directory (expand-file-name qualifier))
+           (ignore-errors (eproject-root)))))
+
+(define-ibuffer-filter eproject
+    "Filter buffers that have the provided eproject name"
+  (:reader (eproject--do-completing-read "Project name: " eproject-project-names)
+   :description "project name")