From ceab9f505a81d8b97a672024b48a7be4f89fd87e Mon Sep 17 00:00:00 2001 From: Johnny Kuan Date: Wed, 21 Sep 2011 09:59:01 -0700 Subject: [PATCH] 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 | 1 + Makefile | 13 +++ autojump | 2 +- autojump.py | 252 +++++++++++++++++++++++++++++++++++++++++++++++- git-version.sh | 7 +- install.sh | 2 +- install.zsh | 2 +- make_release.sh | 18 ---- 8 files changed, 271 insertions(+), 26 deletions(-) create mode 100644 Makefile mode change 120000 => 100755 autojump.py delete mode 100755 make_release.sh diff --git a/.gitignore b/.gitignore index 3d125c5..bf8d346 100644 --- a/.gitignore +++ b/.gitignore @@ -3,3 +3,4 @@ tags *~ *.tar.gz *.patch +autojump diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..011b38b --- /dev/null +++ b/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 + + diff --git a/autojump b/autojump index d17d2f3..78af8e8 100755 --- a/autojump +++ b/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 = '__' diff --git a/autojump.py b/autojump.py deleted file mode 120000 index ee78df4..0000000 --- a/autojump.py +++ /dev/null @@ -1 +0,0 @@ -autojump \ No newline at end of file diff --git a/autojump.py b/autojump.py new file mode 100755 index 0000000..d17d2f3 --- /dev/null +++ b/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 . + +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 ") + 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) diff --git a/git-version.sh b/git-version.sh index 2744110..20fb036 100755 --- a/git-version.sh +++ b/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 diff --git a/install.sh b/install.sh index f9a37ef..b70a71f 100755 --- a/install.sh +++ b/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/ diff --git a/install.zsh b/install.zsh index 2a8d1e8..70a4eeb 100755 --- a/install.zsh +++ b/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/ diff --git a/make_release.sh b/make_release.sh deleted file mode 100755 index 103e85f..0000000 --- a/make_release.sh +++ /dev/null @@ -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