def __init__(self, alias, url): if hg.islocal(url.encode("utf-8")): url = p(url).abspath() # Force git to use an absolute path in the future remote_name = os.path.basename(sys.argv[0]).replace("git-remote-", "") cmd = ["git", "config", "remote.%s.url" % alias, "%s::%s" % (remote_name, url)] subprocess.call(cmd) # use hash of URL as unique identifier in various places. # this has the advantage over 'alias' that it stays constant # when the user does a "git remote rename old new". if hg_version() >= "4.0.1": d = digester(["md5", "sha1"]) d.update(url.encode("utf-8")) self.uuid = d["sha1"] else: self.uuid = sha1(url.encode("utf-8")).hexdigest() gitdir = p(os.environ["GIT_DIR"].decode("utf-8")) self.remotedir = gitdir.joinpath("hg", self.uuid) self.marks_git_path = self.remotedir.joinpath("marks-git") self.marks_hg_path = self.remotedir.joinpath("marks-hg") self.marks = HGMarks(self.marks_hg_path) self.git_marks = GitMarks(self.marks_git_path) self.parsed_refs = {} self.blob_marks = {} self.branches = {} self.bookmarks = {} self.prefix = "refs/hg/%s" % alias self.alias = alias self.url = url self.build_repo(url)
def __init__(self, alias, url): if hg.islocal(url.encode('utf-8')): url = p(url).abspath() # Force git to use an absolute path in the future cmd = ['git', 'config', 'remote.%s.url' % alias, "gitifyhg::%s" % url] subprocess.call(cmd) # use hash of URL as unique identifier in various places. # this has the advantage over 'alias' that it stays constant # when the user does a "git remote rename old new". self.uuid = sha1(url.encode('utf-8')).hexdigest() gitdir = p(os.environ['GIT_DIR'].decode('utf-8')) self.remotedir = gitdir.joinpath('hg', self.uuid) self.marks_git_path = self.remotedir.joinpath('marks-git') self.marks = HGMarks(self.remotedir.joinpath('marks-hg')) self.parsed_refs = {} self.blob_marks = {} self.branches = {} self.bookmarks = {} self.prefix = 'refs/hg/%s' % alias self.alias = alias self.url = url self.build_repo(url)
def __init__(self, alias, url): if hg.islocal(url.encode('utf-8')): url = p(url).abspath() # Force git to use an absolute path in the future remote_name = os.path.basename(sys.argv[0]).replace( "git-remote-", "") cmd = [ 'git', 'config', 'remote.%s.url' % alias, "%s::%s" % (remote_name, url) ] subprocess.call(cmd) # use hash of URL as unique identifier in various places. # this has the advantage over 'alias' that it stays constant # when the user does a "git remote rename old new". self.uuid = sha1(url.encode('utf-8')).hexdigest() gitdir = p(os.environ['GIT_DIR'].decode('utf-8')) self.remotedir = gitdir.joinpath('hg', self.uuid) self.marks_git_path = self.remotedir.joinpath('marks-git') self.marks_hg_path = self.remotedir.joinpath('marks-hg') self.marks = HGMarks(self.marks_hg_path) self.git_marks = GitMarks(self.marks_git_path) self.parsed_refs = {} self.blob_marks = {} self.branches = {} self.bookmarks = {} self.prefix = 'refs/hg/%s' % alias self.alias = alias self.url = url self.build_repo(url)
def test_clone_replace_file_by_dir(git_dir, hg_repo): sh.cd(hg_repo) make_hg_commit("b", filename="dir_or_file") sh.hg.rm("dir_or_file") sh.mkdir("dir_or_file") make_hg_commit("c", filename="dir_or_file/test_file") git_repo = clone_repo(git_dir, hg_repo) sh.cd(git_repo) assert p('dir_or_file').isdir() assert p('dir_or_file/test_file').exists()
def test_clone_replace_symlink_by_file(git_dir, hg_repo): sh.cd(hg_repo) sh.ln("-s", "test_file", "link_or_file") sh.hg.add("link_or_file") sh.hg.commit(message="b") sh.hg.rm("link_or_file") make_hg_commit("c", filename="link_or_file") git_repo = clone_repo(git_dir, hg_repo) sh.cd(git_repo) assert p('link_or_file').isfile() assert not p('link_or_file').islink()
def test_clone_replace_dir_by_symlink(git_dir, hg_repo): sh.cd(hg_repo) sh.mkdir("dir_or_link") make_hg_commit("b", filename="dir_or_link/test_file") sh.hg.rm("dir_or_link/test_file") sh.ln("-s", "test_file", "dir_or_link") sh.hg.add("dir_or_link") sh.hg.commit(message="c") git_repo = clone_repo(git_dir, hg_repo) sh.cd(git_repo) assert p('dir_or_link').isfile() assert p('dir_or_link').islink()
def handle(self, *args, **options): # make sure we're at project root chdir_dmd() self.json_folder = options.get('json_folder') logger.info("Importing Entities from JSON files from `{}`" .format(self.json_folder)) if not p(self.json_folder).isdir(): logger.error("JSON folder `{}` is not a directory." .format(self.json_folder)) for level in range(5): self.enforced_level = level for fpath in os.listdir(self.json_folder): if not fpath.endswith('.json'): continue # import entity eid = fpath[:-5] self.import_entity(eid) self.enforced_level = None
def test_unicode_path(tmpdir, git_dir, monkeypatch): monkeypatch.setenv('LANG', 'en_US.utf8') tmpdir = p(tmpdir.strpath).abspath() hg_base = tmpdir.joinpath(u'hg\u2020base') # an hg repo to clone from hg_base.mkdir() sh.cd(hg_base) write_to_test_file(u'\u2020\n'.encode('utf-8'), u'\u2020') sh.hg.init() sh.hg.add(u'\u2020') sh.hg.commit(message=u"\u2020") sh.cd('..') sh.cd(git_dir) sh.git.clone("gitifyhg::" + hg_base, _err=sys.stderr) git_repo = git_dir.joinpath(u'hg\u2020base') sh.cd(git_repo) assert_git_messages([u"\u2020"]) write_to_test_file(u'\u2020\n'.encode('utf-8'), u'\u2020') sh.git.add(u'\u2020') sh.git.commit(message=u"\u2020") sh.git.push() sh.cd(hg_base) sh.hg.update() assert_hg_count(2) write_to_test_file(u'\u2020\u2015'.encode('utf-8'), u'\u2020\u2015') sh.hg.add(u'\u2020\u2015') sh.hg.commit(message=u"\u2015") sh.cd(git_repo) sh.git.pull() assert_git_messages([u'\u2015', u"\u2020", u"\u2020"])
def setup_pkg(virtualenv, pkg_dir, options, test=True, indent_txt='', deps=True): """ Sets up a package in the given virtualenv Parameters ---------- virtualenv : `str` virtulenv base dir pkg_dir : `str` package checkout dir options : `optparse.Options` command-line options test : `bool` True/False will install test packages deps : `bool` True/False will install dependencies """ from path import path as p get_log().info("%s Setting up package in %s" % (indent_txt, pkg_dir)) if getattr(options, 'no_action', False): return python = p(virtualenv) / 'bin' / 'python' cmd = [python, 'setup.py'] if options.verbose: cmd.append('-v') cmd.append('develop') if not test: cmd.append('--no-test') if getattr(options, 'prefer_final', False): cmd.append('--prefer-final') if not deps: cmd.append('--no-deps') with chdir(pkg_dir): run(cmd, capture_stdout=not options.verbose)
def handle(self, *args, **options): # make sure we're at project root chdir_dmd() self.json_folder = options.get('json_folder') logger.info("Importing Entities from JSON files from `{}`".format( self.json_folder)) if not p(self.json_folder).isdir(): logger.error("JSON folder `{}` is not a directory.".format( self.json_folder)) for level in range(5): self.enforced_level = level for fpath in os.listdir(self.json_folder): if not fpath.endswith('.json'): continue # import entity eid = fpath[:-5] self.import_entity(eid) self.enforced_level = None
def format(s): "Recursively formats string using the `env` dict." is_path = isinstance(s, p) prev = None while prev != s: prev = s s = s.format(**env) return p(s) if is_path else s
def expand(s): "Recursively expands given string using the `env` dict." is_path = isinstance(s, p) prev = None while prev != s: prev = s s = s % env return p(s) if is_path else s
def cleanup(): dirname = Path.cwd() seven_days_ago = time.time() - 7 * 86400 base = p(os.path.join(dirname, Path('csv/'))) for file in base.walkfiles(): if file.mtime < seven_days_ago: file.remove()
def make_hg_commit(message, filename="test_file", user="******"): """Assuming we are in a mercurial repository, write the message to the filename and commit it.""" add = not p(filename).exists() write_to_test_file(message, filename) if add: sh.hg.add(filename) sh.hg.commit(message=message, user=user)
def test_sym_link(git_dir, hg_repo): sh.cd(hg_repo) write_to_test_file('b') sh.hg.add('test_file') sh.hg.commit(message="b") sh.ln('-s', 'test_file', 'linked') sh.hg.add('linked') sh.hg.commit(message="c") git_repo = clone_repo(git_dir, hg_repo) sh.cd(git_repo) assert p('linked').islink() sh.ln('-s', 'test_file', 'second_link') sh.git.add('second_link') sh.git.commit(message="d") sh.git.push() sh.cd(hg_repo) sh.hg.update() assert p('second_link').islink()
def test_clone_remove_file(git_dir, hg_repo): sh.cd(hg_repo) make_hg_commit("b") sh.hg.rm("test_file") sh.hg.commit(message="c") git_repo = clone_repo(git_dir, hg_repo) sh.cd(git_repo) assert not p('a').exists()
def _create_folder_tree(service_name, dest_filename): # create recursing folders on destination walked_folders = [] for folder in p(dest_filename).splitall()[:-1]: if not folder: continue walked_folders.append(folder) path = os.path.join(*walked_folders) _create_folder(service_name, path)
def write_to_test_file(message, filename="test_file"): """Append the message to the 'test_file' file in the current working directory or filename if it was passed. This is normally done to stage a commit in hg or git. :param message: Something to be appended to the test file. Use \\n judiciously. :param filename: A filename to commit to. If unsupplied, test_file will be updated.""" with p(filename).open("a") as file: file.write(message)
def git_dir(tmpdir): """Fixture that creates a subdirectory in the tmpdir to hold the git clone. :param tmpdir: the temporary directory for the current test :return: a py.path inside the test's temporary directory that is an empty but existing directory.""" os.environ["DEBUG_GITIFYHG"] = "on" tmpdir = p(tmpdir.strpath).abspath() git_dir = tmpdir.joinpath("git_dir") git_dir.mkdir() return git_dir
def test_empty_repo(tmpdir): tmpdir = p(tmpdir.strpath).abspath() hg_base = tmpdir.joinpath('hg_base') hg_base.mkdir() sh.cd(hg_base) sh.hg.init() sh.cd(tmpdir) sh.git.clone("gitifyhg::" + hg_base, "git_clone") sh.cd("git_clone") assert "Initial commit" in sh.git.status().stdout make_git_commit("a") sh.git.push("origin", "master") sh.cd(hg_base) assert_hg_count(1) sh.hg.update() with open(hg_base.joinpath('test_file')) as file: assert file.read() == "a"
def hg_repo(tmpdir): '''Fixture that creates an hg repository in a temporary directory gitifyhg can then be tested by cloaning that repo. Also sets the DEBUG_GITIFYHG environment variable. :param tmpdir: A temporary directory for the current test :return: a py.path inside the test's temporary directory that contains an initialized hg repository with a single commit''' os.environ['DEBUG_GITIFYHG'] = "on" os.environ['GIT_PAGER'] = 'cat' os.environ['HGPLAIN'] = '1' tmpdir = p(tmpdir.strpath).abspath() hg_base = tmpdir.joinpath('hg_base') # an hg repo to clone from hg_base.mkdir() sh.cd(hg_base) write_to_test_file('a\n') sh.hg.init() sh.hg.add('test_file') sh.hg.commit(message="a") sh.cd('..') return hg_base
def hg_repo(tmpdir): """Fixture that creates an hg repository in a temporary directory gitifyhg can then be tested by cloaning that repo. Also sets the DEBUG_GITIFYHG environment variable. :param tmpdir: A temporary directory for the current test :return: a py.path inside the test's temporary directory that contains an initialized hg repository with a single commit""" os.environ["DEBUG_GITIFYHG"] = "on" os.environ["GIT_PAGER"] = "cat" os.environ["HGRCPATH"] = "" # So extensions like pager don't interfere tmpdir = p(tmpdir.strpath).abspath() hg_base = tmpdir.joinpath("hg_base") # an hg repo to clone from hg_base.mkdir() sh.cd(hg_base) write_to_test_file("a\n") sh.hg.init() sh.hg.add("test_file") sh.hg.commit(message="a") sh.cd("..") return hg_base
browserify_js = 'vendor/browserify.js', work_browserify_js = '%(work_dir)s/%(browserify_js)s', vendor_search_dirs = ['static', 'var', '%(work_dir)s'], vendor_bundle = '%(work_dir)s/vendor/vendor-bundle.min.js', app_bundle = '%(work_dir)s/js/limn/app-bundle.js', )) env_paths = ( 'dist', 'local_tmp', 'work_dir', 'browserify_js', 'work_browserify_js', 'vendor_bundle', 'app_bundle', ) for k in env_paths: env[k] = p(env[k]) env.vendor_search_dirs = [ expand(p(vd)) for vd in env.vendor_search_dirs ] env.app_bundle_min = p(env.app_bundle.replace('.js', '.min.js')) ### Setup Staging Environments # Envs aren't declared with @task in the stages module so that we can # decorate them here and have them show up at the top level. import stages for name in stages.STAGE_NAMES: globals()[name] = task(getattr(stages, name))
from path import path as p path = p(1) print '-' * 50 print path.g_hash_index() print path.g_word_wide()
from path import path as p path = p(1) print '-'*50 print path.g_hash_index() print path.g_word_wide()