use make for autojump and release tarball

autojump.py is now a source file, autojump is the 
executable with version information.
Makefile automatically looks for last tagged 
commit when making the release tar.gz

.gitignore

@@ -3,3 +3,4 @@ tags
 *~
 *.tar.gz
 *.patch
+autojump

Makefile

@@ -0,0 +1,13 @@
+.PHONY: release
+
+autojump: autojump.py
+	./git-version.sh
+
+version=`git describe $$(git rev-list --tags --max-count=1)`
+number=`git describe $$(git rev-list --tags --max-count=1) | sed "s/^[a-z]*-//"`
+release:
+	echo $(TAG)
+	@echo NOTE: make sure you\'re on a tagged commit
+	git archive --format=tar --prefix autojump_$(number)/ $(version) | gzip > autojump_$(number).tar.gz
+
+

autojump

@@ -31,7 +31,7 @@ from sys import argv, stderr, version_info, exit
 from tempfile import NamedTemporaryFile
 from operator import itemgetter
 import os
-AUTOJUMP_VERSION = "release v17"
+AUTOJUMP_VERSION = "git revision release-v17-3-gf75b11d-dirty"
 MAX_KEYWEIGHT = 1000
 MAX_STORED_PATHS = 600
 COMPLETION_SEPARATOR = '__'

autojump.py

@@ -1 +0,0 @@
-autojump

autojump.py

@@ -0,0 +1,251 @@
+#!/usr/bin/env python
+"""Copyright Joel Schaerer 2008-2010
+This file is part of autojump
+
+autojump 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.
+
+autojump 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 autojump.  If not, see <http://www.gnu.org/licenses/>.
+
+Autojump is a small tool that maintains a database of your most
+used directories, and finds the best match to help you jump to
+frequently used places."""
+
+from __future__ import division, print_function
+
+try: # fix to get optimised pickle in python < 3
+    import cPickle as pickle
+except ImportError:
+    import pickle
+
+import getopt
+from sys import argv, stderr, version_info, exit
+from tempfile import NamedTemporaryFile
+from operator import itemgetter
+import os
+AUTOJUMP_VERSION = "release v17"
+MAX_KEYWEIGHT = 1000
+MAX_STORED_PATHS = 600
+COMPLETION_SEPARATOR = '__'
+if "AUTOJUMP_DATA_DIR" in os.environ:
+    CONFIG_DIR = os.environ.get("AUTOJUMP_DATA_DIR")
+else:
+    xdg_data_dir = os.environ.get('XDG_DATA_HOME') or os.path.join(os.environ['HOME'], '.local', 'share')
+    CONFIG_DIR=os.path.join(xdg_data_dir, 'autojump')
+
+def uniqadd(collection, key):
+    """Adds a key to a list only if it is not already present"""
+    if key not in collection:
+        collection.append(key)
+
+def dicadd(dic, key, increment=1):
+    """Increment a value in a dic, set it to 0
+    if is is not already present"""
+    dic[key] = dic.get(key, 0.)+increment
+
+def save(path_dict, dic_file):
+    """Save the database in an atomic way, and preserve
+       a backup file."""
+    # If the dic_file exists, check that it belongs to us
+    # Otherwise, fail quietly
+    if (not os.path.exists(dic_file)) or os.getuid() == os.stat(dic_file)[4]:
+        temp = NamedTemporaryFile(dir=CONFIG_DIR, delete=False)
+        pickle.dump(path_dict, temp, 2)
+        temp.flush()
+        os.fsync(temp)
+        temp.close()
+        #cf. http://thunk.org/tytso/blog/2009/03/15/dont-fear-the-fsync/
+        os.rename(temp.name, dic_file) 
+        try: #backup file
+            import time 
+            if (not os.path.exists(dic_file+".bak") or
+                    time.time()-os.path.getmtime(dic_file+".bak")>86400):
+                import shutil
+                shutil.copy(dic_file, dic_file+".bak")
+        except OSError as ex:
+            print("Error while creating backup autojump file. (%s)" %
+                    ex, file=stderr)
+
+def forget(path_dict, dic_file):
+    """Gradually forget about directories. Only call
+    from the actual jump since it can take time"""
+    keyweight = sum(path_dict.values()) 
+    if keyweight > MAX_KEYWEIGHT: 
+        for k in path_dict.keys():
+            path_dict[k] *= 0.9 * MAX_KEYWEIGHT / keyweight
+        save(path_dict, dic_file)
+
+def clean_dict(sorted_dirs, path_dict):
+    """Limits the sized of the path_dict to MAX_STORED_PATHS. 
+    Returns True if keys were deleted"""
+    if len(sorted_dirs) > MAX_STORED_PATHS:
+        #remove 25 more than needed, to avoid doing it every time
+        for path, dummy in sorted_dirs[MAX_STORED_PATHS-25:]:
+            del path_dict[path]
+        return True
+    else: return False
+
+def match(path, pattern, ignore_case=False, only_end=False):
+    """Check whether a path matches a particular pattern"""
+    try:
+        if os.path.realpath(os.curdir) == path :
+            return False
+    #Sometimes the current path doesn't exist anymore.
+    #In that case, jump if possible.
+    except OSError:
+        pass
+    if only_end:
+        match_string = "/".join(path.split('/')[-1-pattern.count('/'):])
+    else:
+        match_string = path
+    if ignore_case:
+        does_match = (match_string.lower().find(pattern.lower()) != -1)
+    else:
+        does_match = (match_string.find(pattern) != -1)
+    #return True if there is a match and the path exists 
+    #(useful in the case of external drives, for example)
+    return does_match and os.path.exists(path) 
+
+def find_matches(dirs, patterns, result_list, ignore_case, max_matches):
+    """Find max_matches paths that match the pattern, 
+    and add them to the result_list"""
+    for path, count in dirs:
+        if len(result_list) >= max_matches :
+            break
+        #For the last pattern, only match the end of the pattern
+        if all(match(path, p, ignore_case,
+            only_end=(n == len(patterns)-1)) for n, p in enumerate(patterns)):
+            uniqadd(result_list, path)
+
+def open_dic(dic_file, error_recovery=False):
+    """Try hard to open the database file, recovering
+       from backup if needed. """
+    try:
+        aj_file = open(dic_file, 'rb')
+        if version_info[0] > 2:
+            #encoding is only specified for python2.x compatibility
+            path_dict = pickle.load(aj_file, encoding="utf-8")
+        else:
+            path_dict = pickle.load(aj_file)
+        aj_file.close()
+        return path_dict
+    except (IOError, EOFError, pickle.UnpicklingError):
+        if not error_recovery and os.path.exists(dic_file+".bak"):
+            print('Problem with autojump database,\
+                    trying to recover from backup...', file=stderr)
+            import shutil
+            shutil.copy(dic_file+".bak", dic_file)
+            return open_dic(dic_file, True)
+        else: return {} #if everything fails, return an empty file
+
+def get_dic_file():
+    if CONFIG_DIR == os.path.expanduser("~"):
+        dic_file = CONFIG_DIR+"/.autojump_py"
+    else:
+        dic_file = CONFIG_DIR+"/autojump_py"
+    return dic_file
+
+def shell_utility():
+    """Run this when autojump is called as a shell utility"""
+    try:
+        optlist, args = getopt.getopt(argv[1:], 'a',
+                ['stat', 'import', 'completion', 'bash', 'version', 'help'])
+    except getopt.GetoptError as ex:
+        print("Unknown command line argument: %s" % ex)
+        exit(1)
+
+    dic_file = get_dic_file()
+    path_dict = open_dic(dic_file)
+    if ('-a', '') in optlist:
+        # The home dir can be reached quickly by "cd"
+        # and may interfere with other directories
+        if(args[-1] != os.path.expanduser("~")): 
+            dicadd(path_dict, args[-1])
+            save(path_dict, dic_file)
+    elif ('--stat', '') in optlist:
+        paths = list(path_dict.items())
+        paths.sort(key=itemgetter(1))
+        for path, count in paths[-100:]:
+            print("%.1f:\t%s" % (count, path))
+        print("Total key weight: %d. Number of stored paths: %d" %
+                (sum(path_dict.values()), len(paths)))
+    elif ('--version', '') in optlist:
+        print("autojump %s" % AUTOJUMP_VERSION)
+    elif ('--help', '') in optlist:
+        print("usage: j <dirspec>")
+        print("where dirspec is a few characters of the directory you want to jump to.")
+    else:
+        import re
+        completion = False
+        #userchoice is i if the pattern is __pattern__i, otherwise -1
+        userchoice = -1 
+        results = []
+        if ('--completion', '') in optlist:
+            completion = True
+        else:
+            forget(path_dict, dic_file) #gradually forget about old directories
+        if not args: patterns = [""]
+        else: patterns = args
+
+        # If the last pattern contains a full path, jump there
+        # The regexp is because we need to support stuff like
+        # "j wo jo__3__/home/joel/workspace/joel" for zsh
+        last_pattern_path = re.sub("(.*)"+COMPLETION_SEPARATOR, "", patterns[-1])
+        if (len(last_pattern_path)>0 and
+              last_pattern_path[0] == "/" and
+              os.path.exists(last_pattern_path)):
+            if not completion: print(last_pattern_path)
+        else:
+            #check for ongoing completion, and act accordingly
+            endmatch = re.search(COMPLETION_SEPARATOR+"([0-9]+)", patterns[-1])
+            if endmatch:  #user has selected a completion
+                userchoice = int(endmatch.group(1))
+                patterns[-1] = re.sub(COMPLETION_SEPARATOR+"[0-9]+.*",
+                        "", patterns[-1])
+            else: #user hasn't selected a completion, display the same choices again
+                endmatch = re.match("(.*)"+COMPLETION_SEPARATOR, patterns[-1])
+                if endmatch: patterns[-1] = endmatch.group(1)
+
+            dirs = list(path_dict.items())
+            dirs.sort(key=itemgetter(1), reverse=True)
+            if completion or userchoice != -1:
+                max_matches = 9
+            else:
+                max_matches = 1
+            find_matches(dirs, patterns, results, False, max_matches)
+            # If not found, try ignoring case.
+            # On completion always show all results
+            if completion or not results: 
+                find_matches(dirs, patterns, results,
+                        ignore_case=True, max_matches=max_matches) 
+            # Keep the database to a reasonable size
+            if not completion and clean_dict(dirs, path_dict):
+                save(path_dict, dic_file)
+
+            if completion and ('--bash', '') in optlist: quotes = "'"
+            else: quotes = ""
+
+            if userchoice != -1:
+                if len(results) > userchoice-1 : 
+                    print(quotes+results[userchoice-1]+quotes)
+            elif len(results) > 1 and completion:
+                print("\n".join(("%s%s%d%s%s" % (patterns[-1],
+                    COMPLETION_SEPARATOR, n+1, COMPLETION_SEPARATOR, r)
+                    for n, r in enumerate(results[:8]))))
+            elif results: print(quotes+results[0]+quotes)
+            else:
+                return False
+            return True
+
+
+if __name__ == "__main__":
+    success=shell_utility()
+    if not success: exit(1)

git-version.sh

@@ -1,11 +1,10 @@
 #!/usr/bin/env bash
 # add git revision to autojump
-gitrevision=`git rev-parse HEAD`
+gitrevision=`git describe`
 if [[ $(git diff --shortstat 2> /dev/null | tail -n1) != "" ]]; then
     gitrevision=$gitrevision"-dirty"
 fi
-sed -e "s/^AUTOJUMP_VERSION = \".*\"$/AUTOJUMP_VERSION = \"git revision $gitrevision\"/" autojump > autojump-version
-mv -f autojump-version autojump
-chmod a+rw autojump
+sed -e "s/^AUTOJUMP_VERSION = \".*\"$/AUTOJUMP_VERSION = \"git revision $gitrevision\"/" autojump.py > autojump
+chmod a+rx autojump
 
 

install.sh

@@ -41,7 +41,7 @@ done
 echo "Installing to ${prefix} ..."
 
 # add git revision to autojump
-./git-version.sh
+make autojump
 
 # INSTALL AUTOJUMP
 sudo mkdir -p ${prefix}/share/autojump/

install.zsh

@@ -40,7 +40,7 @@ done
 echo "Installing main files to ${prefix} ..."
 
 # add git revision to autojump
-./git-version.sh
+make autojump
 
 sudo mkdir -p ${prefix}/share/autojump/
 sudo mkdir -p ${prefix}/bin/

make_release.sh

@@ -1,18 +0,0 @@
-#!/bin/bash
-
-if [ $# -ne 1 ]
-then
-  echo "Usage: `basename $0` release"
-  echo "where release is of the form v11, v12, ..."
-  exit 1
-fi
-version=$1
-
-#check for tag existence
-git describe release-$1 2>&1 >/dev/null ||
-{
-    echo "Invalid version $1"
-    exit 1
-}
-
-git archive --format=tar --prefix autojump_${version}/ release-${version} | gzip > autojump_${version}.tar.gz