示例#1
0
文件: helper.py 项目: Dieterbe/ranger
def parse_arguments():
	"""Parse the program arguments"""
	from optparse import OptionParser, SUPPRESS_HELP
	from ranger import __version__
	from ranger.ext.openstruct import OpenStruct
	from os.path import expanduser

	if 'XDG_CONFIG_HOME' in os.environ and os.environ['XDG_CONFIG_HOME']:
		default_confdir = os.environ['XDG_CONFIG_HOME'] + '/ranger'
	else:
		default_confdir = '~/.config/ranger'
	usage = '%prog [options] [path/filename]'

	minor_version = __version__[2:]  # assumes major version number is <10
	if '.' in minor_version:
		minor_version = minor_version[:minor_version.find('.')]
	version_tag = ' (stable)' if int(minor_version) % 2 == 0 else ' (testing)'
	if __version__.endswith('.0'):
		version_string = 'ranger ' + __version__[:-2] + version_tag
	else:
		version_string = 'ranger ' + __version__ + version_tag

	parser = OptionParser(usage=usage, version=version_string)

	parser.add_option('-d', '--debug', action='store_true',
			help="activate debug mode")
	parser.add_option('-c', '--clean', action='store_true',
			help="don't touch/require any config files. ")
	parser.add_option('--fail-if-run', action='store_true', # COMPAT
			help=SUPPRESS_HELP)
	parser.add_option('--copy-config', type='string', metavar='which',
			help="copy the default configs to the local config directory. "
			"Possible values: all, apps, commands, keys, options, scope")
	parser.add_option('--fail-unless-cd', action='store_true',
			help="experimental: return the exit code 1 if ranger is" \
					"used to run a file (with `ranger filename`)")
	parser.add_option('-r', '--confdir', type='string',
			metavar='dir', default=default_confdir,
			help="the configuration directory. (%default)")
	parser.add_option('-m', '--mode', type='int', default=0, metavar='n',
			help="if a filename is supplied, run it with this mode")
	parser.add_option('-f', '--flags', type='string', default='',
			metavar='string',
			help="if a filename is supplied, run it with these flags.")
	parser.add_option('--choosefile', type='string', metavar='TARGET',
			help="Makes ranger act like a file chooser. When opening "
			"a file, it will quit and write the name of the selected "
			"file to TARGET.")
	parser.add_option('--choosedir', type='string', metavar='TARGET',
			help="Makes ranger act like a directory chooser. When ranger quits"
			", it will write the name of the last visited directory to TARGET")

	options, positional = parser.parse_args()
	arg = OpenStruct(options.__dict__, targets=positional)
	arg.confdir = expanduser(arg.confdir)
	if arg.fail_if_run:
		arg.fail_unless_cd = arg.fail_if_run
		del arg['fail_if_run']

	return arg
示例#2
0
    def test_openstruct(self):
        from ranger.ext.openstruct import OpenStruct
        from random import randint, choice
        from string import ascii_letters

        os = OpenStruct(a='a')
        self.assertEqual(os.a, 'a')
        self.assertRaises(AttributeError, getattr, os, 'b')

        dictionary = {'foo': 'bar', 'zoo': 'zar'}
        os = OpenStruct(dictionary)
        self.assertEqual(os.foo, 'bar')
        self.assertEqual(os.zoo, 'zar')
        self.assertRaises(AttributeError, getattr, os, 'sdklfj')

        for i in range(100):
            attr_name = ''.join(choice(ascii_letters) \
             for x in range(randint(3,9)))
            value = randint(100, 999)
            if not attr_name in os:
                self.assertRaises(AttributeError, getattr, os, attr_name)
            setattr(os, attr_name, value)
            value2 = randint(100, 999)
            setattr(os, attr_name, value2)
            self.assertEqual(value2, getattr(os, attr_name))
示例#3
0
文件: helper.py 项目: gwash/ranger
def parse_arguments():
	"""Parse the program arguments"""
	from optparse import OptionParser
	from ranger import __version__
	from ranger.ext.openstruct import OpenStruct
	from os.path import expanduser

	if 'XDG_CONFIG_HOME' in os.environ and os.environ['XDG_CONFIG_HOME']:
		default_confdir = os.environ['XDG_CONFIG_HOME'] + '/ranger'
	else:
		default_confdir = CONFDIR

	parser = OptionParser(usage=USAGE, version='ranger %s%s' \
			% (__version__, " (stable)" if STABLE else ""))

	parser.add_option('-d', '--debug', action='store_true',
			help="activate debug mode")
	parser.add_option('-c', '--clean', action='store_true',
			help="don't touch/require any config files. ")
	parser.add_option('--copy-config', type='string', metavar='which',
			help="copy the default configs to the local config directory. "
			"Possible values: all, rc, apps, commands, options, scope")
	parser.add_option('--fail-unless-cd', action='store_true',
			help="experimental: return the exit code 1 if ranger is" \
					"used to run a file (with `ranger filename`)")
	parser.add_option('-r', '--confdir', type='string',
			metavar='dir', default=default_confdir,
			help="the configuration directory. (%default)")
	parser.add_option('-m', '--mode', type='int', default=0, metavar='n',
			help="if a filename is supplied, run it with this mode")
	parser.add_option('-f', '--flags', type='string', default='',
			metavar='string',
			help="if a filename is supplied, run it with these flags.")
	parser.add_option('--choosefile', type='string', metavar='TARGET',
			help="Makes ranger act like a file chooser. When opening "
			"a file, it will quit and write the name of the selected "
			"file to TARGET.")
	parser.add_option('--choosefiles', type='string', metavar='TARGET',
			help="Makes ranger act like a file chooser for multiple files "
			"at once. When opening a file, it will quit and write the name "
			"of all selected files to TARGET.")
	parser.add_option('--choosedir', type='string', metavar='TARGET',
			help="Makes ranger act like a directory chooser. When ranger quits"
			", it will write the name of the last visited directory to TARGET")
	parser.add_option('--list-unused-keys', action='store_true',
			help="List common keys which are not bound to any action.")
	parser.add_option('--selectfile', type='string', metavar='filepath',
			help="Open ranger with supplied file selected.")
	parser.add_option('--list-tagged-files', type='string', default=None,
			metavar='tag',
			help="List all files which are tagged with the given tag, default: *")
	parser.add_option('--profile', action='store_true',
			help="Print statistics of CPU usage on exit.")

	options, positional = parser.parse_args()
	arg = OpenStruct(options.__dict__, targets=positional)
	arg.confdir = expanduser(arg.confdir)

	return arg
示例#4
0
    def test_loader(self):
        loader = Loader()
        fm = OpenStruct(loader=loader)
        SettingsAware.settings = Fake()
        FileManagerAware.fm = fm

        # initially, the loader has nothing to do
        self.assertFalse(loader.has_work())

        dir = Directory(TESTDIR)
        self.assertEqual(None, dir.files)
        self.assertFalse(loader.has_work())

        # Calling load_content() will enqueue the loading operation.
        # dir is not loaded yet, but the loader has work
        dir.load_content(schedule=True)
        self.assertEqual(None, dir.files)
        self.assertTrue(loader.has_work())

        iterations = 0
        while loader.has_work():
            iterations += 1
            loader.work()
        #print(iterations)
        self.assertNotEqual(None, dir.files)
        self.assertFalse(loader.has_work())
示例#5
0
def main():
    import ranger.container.directory
    import ranger.core.shared
    import ranger.container.settings
    import ranger.core.fm
    from ranger.ext.openstruct import OpenStruct
    ranger.args = OpenStruct()
    ranger.args.clean = True
    ranger.args.debug = False

    settings = ranger.container.settings.Settings()
    ranger.core.shared.SettingsAware.settings_set(settings)
    fm = ranger.core.fm.FM()
    ranger.core.shared.FileManagerAware.fm_set(fm)

    time1 = time.time()
    fm.initialize()
    try:
        usr = ranger.container.directory.Directory('/usr')
        usr.load_content(schedule=False)
        for fileobj in usr.files:
            if fileobj.is_directory:
                fileobj.load_content(schedule=False)
    finally:
        fm.destroy()
    time2 = time.time()
    print("%dms" % ((time2 - time1) * 1000))
示例#6
0
    def get_paper_info(self, filename):
        try:
            return self.metadata_cache[filename]
        except KeyError:
            result = OpenStruct(filename=filename,
                                title=None,
                                year=None,
                                authors=None,
                                url=None)

            valid = (filename, basename(filename))
            for metafile in self._get_metafile_names(filename):
                for entry in self._get_metafile_content(metafile):
                    if entry[0] in valid:
                        self._fill_ostruct_with_data(result, entry)
                        self.metadata_cache[filename] = result
                        return result

            # Cache the value
            self.metadata_cache[filename] = result
            return result
示例#7
0
    def _set_paper_info_raw(self, filename, update_dict, metafile):
        valid = (filename, basename(filename))
        paperinfo = OpenStruct(filename=filename,
                               title=None,
                               year=None,
                               authors=None,
                               url=None)

        try:
            with open(metafile, "r") as infile:
                reader = csv.reader(infile, skipinitialspace=True)
                rows = list(reader)
        except IOError:
            rows = []

        with open(metafile, "w") as outfile:
            writer = csv.writer(outfile)
            found = False

            # Iterate through all rows and write them back to the file.
            for row in rows:
                if not found and row[0] in valid:
                    # When finding the row that corresponds to the given filename,
                    # update the items with the information from update_dict.
                    self._fill_row_with_ostruct(row, update_dict)
                    self._fill_ostruct_with_data(paperinfo, row)
                    self.metadata_cache[filename] = paperinfo
                    found = True
                writer.writerow(row)

            # If the row was never found, create a new one.
            if not found:
                row = [basename(filename), None, None, None, None]
                self._fill_row_with_ostruct(row, update_dict)
                self._fill_ostruct_with_data(paperinfo, row)
                self.metadata_cache[filename] = paperinfo
                writer.writerow(row)
示例#8
0
文件: main.py 项目: mullikine/ranger
def main(
    # pylint: disable=too-many-locals,too-many-return-statements
    # pylint: disable=too-many-branches,too-many-statements
):
    """initialize objects and run the filemanager"""
    import ranger.api
    from ranger.container.settings import Settings
    from ranger.core.shared import FileManagerAware, SettingsAware
    from ranger.core.fm import FM
    from ranger.ext.logutils import setup_logging
    from ranger.ext.openstruct import OpenStruct

    ranger.args = args = parse_arguments()
    ranger.arg = OpenStruct(args.__dict__)  # COMPAT
    setup_logging(debug=args.debug, logfile=args.logfile)

    for line in VERSION_MSG:
        LOG.info(line)
    LOG.info('Process ID: %s', os.getpid())

    try:
        locale.setlocale(locale.LC_ALL, '')
    except locale.Error:
        print("Warning: Unable to set locale.  Expect encoding problems.")

    # so that programs can know that ranger spawned them:
    level = 'RANGER_LEVEL'
    if level in os.environ and os.environ[level].isdigit():
        os.environ[level] = str(int(os.environ[level]) + 1)
    else:
        os.environ[level] = '1'

    if 'SHELL' not in os.environ:
        os.environ['SHELL'] = 'sh'

    LOG.debug("cache dir: '%s'", args.cachedir)
    LOG.debug("config dir: '%s'", args.confdir)
    LOG.debug("data dir: '%s'", args.datadir)

    if args.copy_config is not None:
        fm = FM()
        fm.copy_config_files(args.copy_config)
        return 0
    if args.list_tagged_files:
        if args.clean:
            print("Can't access tag data in clean mode", file=sys.stderr)
            return 1
        fm = FM()
        try:
            if sys.version_info[0] >= 3:
                fobj = open(fm.datapath('tagged'), 'r', errors='replace')
            else:
                fobj = open(fm.datapath('tagged'), 'r')
        except OSError as ex:
            print('Unable to open `tagged` data file: {0}'.format(ex),
                  file=sys.stderr)
            return 1
        for line in fobj.readlines():
            if len(line) > 2 and line[1] == ':':
                if line[0] in args.list_tagged_files:
                    sys.stdout.write(line[2:])
            elif line and '*' in args.list_tagged_files:
                sys.stdout.write(line)
        return 0

    SettingsAware.settings_set(Settings())

    # TODO: deprecate --selectfile
    if args.selectfile:
        args.selectfile = os.path.abspath(args.selectfile)
        args.paths.insert(0, os.path.dirname(args.selectfile))

    paths = get_paths(args)
    paths_inaccessible = []
    for path in paths:
        try:
            path_abs = os.path.abspath(path)
        except OSError:
            paths_inaccessible += [path]
            continue
        if not os.access(path_abs, os.F_OK):
            paths_inaccessible += [path]
    if paths_inaccessible:
        print('Inaccessible paths: {0}'.format(', '.join(paths_inaccessible)),
              file=sys.stderr)
        return 1

    profile = None
    exit_msg = ''
    exit_code = 0
    try:  # pylint: disable=too-many-nested-blocks
        # Initialize objects
        fm = FM(paths=paths)
        FileManagerAware.fm_set(fm)
        load_settings(fm, args.clean)

        if args.show_only_dirs:
            from ranger.container.directory import InodeFilterConstants
            fm.settings.global_inode_type_filter = InodeFilterConstants.DIRS

        if args.list_unused_keys:
            from ranger.ext.keybinding_parser import (special_keys,
                                                      reversed_special_keys)
            maps = fm.ui.keymaps['browser']
            for key in sorted(special_keys.values(), key=str):
                if key not in maps:
                    print("<%s>" % reversed_special_keys[key])
            for key in range(33, 127):
                if key not in maps:
                    print(chr(key))
            return 0

        if not sys.stdin.isatty():
            sys.stderr.write("Error: Must run ranger from terminal\n")
            raise SystemExit(1)

        if fm.username == 'root':
            fm.settings.preview_files = False
            fm.settings.use_preview_script = False
            LOG.info("Running as root, disabling the file previews.")
        if not args.debug:
            from ranger.ext import curses_interrupt_handler
            curses_interrupt_handler.install_interrupt_handler()

        if not args.clean:
            # Create data directory
            if not os.path.exists(args.datadir):
                os.makedirs(args.datadir)

            # Restore saved tabs
            tabs_datapath = fm.datapath('tabs')
            if fm.settings.save_tabs_on_exit and os.path.exists(
                    tabs_datapath) and not args.paths:
                try:
                    with open(tabs_datapath, 'r') as fobj:
                        tabs_saved = fobj.read().partition('\0\0')
                        fm.start_paths += tabs_saved[0].split('\0')
                    if tabs_saved[-1]:
                        with open(tabs_datapath, 'w') as fobj:
                            fobj.write(tabs_saved[-1])
                    else:
                        os.remove(tabs_datapath)
                except OSError as ex:
                    LOG.error('Unable to restore saved tabs')
                    LOG.exception(ex)

        # Run the file manager
        fm.initialize()
        ranger.api.hook_init(fm)
        fm.ui.initialize()

        if args.selectfile:
            fm.select_file(args.selectfile)

        if args.cmd:
            fm.enter_dir(fm.thistab.path)
            for command in args.cmd:
                fm.execute_console(command)

        if int(os.environ[level]) > 1:
            warning = 'Warning:'
            nested_warning = "You're in a nested ranger instance!"
            warn_when_nested = fm.settings.nested_ranger_warning.lower()
            if warn_when_nested == 'true':
                fm.notify(' '.join((warning, nested_warning)), bad=False)
            elif warn_when_nested == 'error':
                fm.notify(' '.join((warning.upper(), nested_warning + '!!')),
                          bad=True)

        if ranger.args.profile:
            import cProfile
            import pstats
            ranger.__fm = fm  # pylint: disable=protected-access
            profile_file = tempfile.gettempdir() + '/ranger_profile'
            cProfile.run('ranger.__fm.loop()', profile_file)
            profile = pstats.Stats(profile_file, stream=sys.stderr)
        else:
            fm.loop()

    except Exception:  # pylint: disable=broad-except
        import traceback
        ex_traceback = traceback.format_exc()
        exit_msg += '\n'.join(VERSION_MSG) + '\n'
        try:
            exit_msg += "Current file: {0}\n".format(repr(fm.thisfile.path))
        except Exception:  # pylint: disable=broad-except
            pass
        exit_msg += '''
{0}
ranger crashed. Please report this traceback at:
https://github.com/ranger/ranger/issues
'''.format(ex_traceback)

        exit_code = 1

    except SystemExit as ex:
        if ex.code is not None:
            if not isinstance(ex.code, int):
                exit_msg = ex.code
                exit_code = 1
            else:
                exit_code = ex.code

    finally:
        if exit_msg:
            LOG.critical(exit_msg)
        try:
            fm.ui.destroy()
        except (AttributeError, NameError):
            pass
        # If profiler is enabled print the stats
        if ranger.args.profile and profile:
            profile.strip_dirs().sort_stats('cumulative').print_callees()
        # print the exit message if any
        if exit_msg:
            sys.stderr.write(exit_msg)
        return exit_code  # pylint: disable=lost-exception
示例#9
0
def parse_arguments():
    """Parse the program arguments"""
    from optparse import OptionParser, SUPPRESS_HELP
    from os.path import expanduser
    from ranger import CONFDIR, USAGE, VERSION
    from ranger.ext.openstruct import OpenStruct

    if 'XDG_CONFIG_HOME' in os.environ and os.environ['XDG_CONFIG_HOME']:
        default_confdir = os.environ['XDG_CONFIG_HOME'] + '/ranger'
    else:
        default_confdir = CONFDIR

    parser = OptionParser(usage=USAGE, version=VERSION)

    parser.add_option('-d', '--debug', action='store_true',
            help="activate debug mode")
    parser.add_option('-c', '--clean', action='store_true',
            help="don't touch/require any config files. ")
    parser.add_option('-r', '--confdir', type='string',
            metavar='dir', default=default_confdir,
            help="change the configuration directory. (%default)")
    parser.add_option('--copy-config', type='string', metavar='which',
            help="copy the default configs to the local config directory. "
            "Possible values: all, rc, rifle, commands, scope")
    parser.add_option('--fail-unless-cd', action='store_true',
            help=SUPPRESS_HELP)  # COMPAT
    parser.add_option('-m', '--mode', type='int', default=0, metavar='n',
            help=SUPPRESS_HELP)  # COMPAT
    parser.add_option('-f', '--flags', type='string', default='',
            metavar='string', help=SUPPRESS_HELP)  # COMPAT
    parser.add_option('--choosefile', type='string', metavar='TARGET',
            help="Makes ranger act like a file chooser. When opening "
            "a file, it will quit and write the name of the selected "
            "file to TARGET.")
    parser.add_option('--choosefiles', type='string', metavar='TARGET',
            help="Makes ranger act like a file chooser for multiple files "
            "at once. When opening a file, it will quit and write the name "
            "of all selected files to TARGET.")
    parser.add_option('--choosedir', type='string', metavar='TARGET',
            help="Makes ranger act like a directory chooser. When ranger quits"
            ", it will write the name of the last visited directory to TARGET")
    parser.add_option('--selectfile', type='string', metavar='filepath',
            help="Open ranger with supplied file selected.")
    parser.add_option('--list-unused-keys', action='store_true',
            help="List common keys which are not bound to any action.")
    parser.add_option('--list-tagged-files', type='string', default=None,
            metavar='tag',
            help="List all files which are tagged with the given tag, default: *")
    parser.add_option('--profile', action='store_true',
            help="Print statistics of CPU usage on exit.")
    parser.add_option('--cmd', action='append', type='string', metavar='COMMAND',
            help="Execute COMMAND after the configuration has been read. "
            "Use this option multiple times to run multiple commands.")

    options, positional = parser.parse_args()
    arg = OpenStruct(options.__dict__, targets=positional)
    arg.confdir = expanduser(arg.confdir)

    if arg.fail_unless_cd: # COMPAT
        sys.stderr.write("Warning: The option --fail-unless-cd is deprecated.\n"
            "It was used to faciliate using ranger as a file launcher.\n"
            "Now, please use the standalone file launcher 'rifle' instead.\n")

    return arg
示例#10
0
def parse_arguments():
    """Parse the program arguments"""
    from optparse import OptionParser, SUPPRESS_HELP
    from os.path import expanduser
    from ranger import CONFDIR, CACHEDIR, USAGE, VERSION
    from ranger.ext.openstruct import OpenStruct

    if 'XDG_CONFIG_HOME' in os.environ and os.environ['XDG_CONFIG_HOME']:
        default_confdir = os.environ['XDG_CONFIG_HOME'] + '/ranger'
    else:
        default_confdir = CONFDIR

    if 'XDG_CACHE_HOME' in os.environ and os.environ['XDG_CACHE_HOME']:
        default_cachedir = os.environ['XDG_CACHE_HOME'] + '/ranger'
    else:
        default_cachedir = CACHEDIR

    parser = OptionParser(usage=USAGE, version=VERSION)

    parser.add_option('-d',
                      '--debug',
                      action='store_true',
                      help="activate debug mode")
    parser.add_option('-c',
                      '--clean',
                      action='store_true',
                      help="don't touch/require any config files. ")
    parser.add_option('-r',
                      '--confdir',
                      type='string',
                      metavar='dir',
                      default=default_confdir,
                      help="change the configuration directory. (%default)")
    parser.add_option(
        '--copy-config',
        type='string',
        metavar='which',
        help="copy the default configs to the local config directory. "
        "Possible values: all, rc, rifle, commands, commands_full, scope")
    parser.add_option('--fail-unless-cd',
                      action='store_true',
                      help=SUPPRESS_HELP)  # COMPAT
    parser.add_option('-m',
                      '--mode',
                      type='int',
                      default=0,
                      metavar='n',
                      help=SUPPRESS_HELP)  # COMPAT
    parser.add_option('-f',
                      '--flags',
                      type='string',
                      default='',
                      metavar='string',
                      help=SUPPRESS_HELP)  # COMPAT
    parser.add_option(
        '--choosefile',
        type='string',
        metavar='TARGET',
        help="Makes ranger act like a file chooser. When opening "
        "a file, it will quit and write the name of the selected "
        "file to TARGET.")
    parser.add_option(
        '--choosefiles',
        type='string',
        metavar='TARGET',
        help="Makes ranger act like a file chooser for multiple files "
        "at once. When opening a file, it will quit and write the name "
        "of all selected files to TARGET.")
    parser.add_option(
        '--choosedir',
        type='string',
        metavar='TARGET',
        help="Makes ranger act like a directory chooser. When ranger quits"
        ", it will write the name of the last visited directory to TARGET")
    parser.add_option('--selectfile',
                      type='string',
                      metavar='filepath',
                      help="Open ranger with supplied file selected.")
    parser.add_option(
        '--list-unused-keys',
        action='store_true',
        help="List common keys which are not bound to any action.")
    parser.add_option(
        '--list-tagged-files',
        type='string',
        default=None,
        metavar='tag',
        help="List all files which are tagged with the given tag, default: *")
    parser.add_option('--profile',
                      action='store_true',
                      help="Print statistics of CPU usage on exit.")
    parser.add_option(
        '--cmd',
        action='append',
        type='string',
        metavar='COMMAND',
        help="Execute COMMAND after the configuration has been read. "
        "Use this option multiple times to run multiple commands.")

    options, positional = parser.parse_args()
    arg = OpenStruct(options.__dict__, targets=positional)
    arg.confdir = expanduser(arg.confdir)
    arg.cachedir = expanduser(default_cachedir)

    if arg.fail_unless_cd:  # COMPAT
        sys.stderr.write(
            "Warning: The option --fail-unless-cd is deprecated.\n"
            "It was used to faciliate using ranger as a file launcher.\n"
            "Now, please use the standalone file launcher 'rifle' instead.\n")

    return arg
示例#11
0
def main(
    # pylint: disable=too-many-locals,too-many-return-statements
    # pylint: disable=too-many-branches,too-many-statements
):
    """initialize objects and run the filemanager"""
    import locale
    import ranger.api
    from ranger.container.settings import Settings
    from ranger.core.shared import FileManagerAware, SettingsAware
    from ranger.core.fm import FM
    from ranger.ext.logutils import setup_logging
    from ranger.ext.openstruct import OpenStruct

    ranger.args = args = parse_arguments()
    ranger.arg = OpenStruct(args.__dict__)  # COMPAT
    setup_logging(debug=args.debug, logfile=args.logfile)

    LOG.info("Ranger version %s", __version__)
    LOG.info('Running on Python ' + sys.version.replace('\n', ''))
    LOG.info("Process ID is %s", os.getpid())

    try:
        locale.setlocale(locale.LC_ALL, '')
    except locale.Error:
        print("Warning: Unable to set locale.  Expect encoding problems.")

    # so that programs can know that ranger spawned them:
    level = 'RANGER_LEVEL'
    if level in os.environ and os.environ[level].isdigit():
        os.environ[level] = str(int(os.environ[level]) + 1)
    else:
        os.environ[level] = '1'

    if 'SHELL' not in os.environ:
        os.environ['SHELL'] = 'sh'

    LOG.debug("config dir: '%s'", args.confdir)
    LOG.debug("cache dir: '%s'", args.cachedir)

    if args.copy_config is not None:
        fm = FM()
        fm.copy_config_files(args.copy_config)
        return 0
    if args.list_tagged_files:
        fm = FM()
        try:
            if sys.version_info[0] >= 3:
                fobj = open(fm.confpath('tagged'), 'r', errors='replace')
            else:
                fobj = open(fm.confpath('tagged'), 'r')
        except OSError:
            pass
        else:
            for line in fobj.readlines():
                if len(line) > 2 and line[1] == ':':
                    if line[0] in args.list_tagged_files:
                        sys.stdout.write(line[2:])
                elif line and '*' in args.list_tagged_files:
                    sys.stdout.write(line)
        return 0

    SettingsAware.settings_set(Settings())

    if args.selectfile:
        args.selectfile = os.path.abspath(args.selectfile)
        args.paths.insert(0, os.path.dirname(args.selectfile))

    paths = args.paths or ['.']
    paths_inaccessible = []
    for path in paths:
        try:
            path_abs = os.path.abspath(path)
        except OSError:
            paths_inaccessible += [path]
            continue
        if not os.access(path_abs, os.F_OK):
            paths_inaccessible += [path]
    if paths_inaccessible:
        print("Inaccessible paths: %s" % paths)
        return 1

    profile = None
    exit_msg = ''
    exit_code = 0
    try:
        # Initialize objects
        fm = FM(paths=paths)
        FileManagerAware.fm_set(fm)
        load_settings(fm, args.clean)

        if args.list_unused_keys:
            from ranger.ext.keybinding_parser import (special_keys,
                                                      reversed_special_keys)
            maps = fm.ui.keymaps['browser']
            for key in sorted(special_keys.values(), key=str):
                if key not in maps:
                    print("<%s>" % reversed_special_keys[key])
            for key in range(33, 127):
                if key not in maps:
                    print(chr(key))
            return 0

        if not sys.stdin.isatty():
            sys.stderr.write("Error: Must run ranger from terminal\n")
            raise SystemExit(1)

        if fm.username == 'root':
            fm.settings.preview_files = False
            fm.settings.use_preview_script = False
            LOG.info("Running as root, disabling the file previews.")
        if not args.debug:
            from ranger.ext import curses_interrupt_handler
            curses_interrupt_handler.install_interrupt_handler()

        # Create cache directory
        if fm.settings.preview_images and fm.settings.use_preview_script:
            if not os.path.exists(args.cachedir):
                os.makedirs(args.cachedir)

        # Run the file manager
        fm.initialize()
        ranger.api.hook_init(fm)
        fm.ui.initialize()

        if args.selectfile:
            fm.select_file(args.selectfile)

        if args.cmd:
            for command in args.cmd:
                fm.execute_console(command)

        if ranger.args.profile:
            import cProfile
            import pstats
            ranger.__fm = fm  # pylint: disable=protected-access
            profile_file = tempfile.gettempdir() + '/ranger_profile'
            cProfile.run('ranger.__fm.loop()', profile_file)
            profile = pstats.Stats(profile_file, stream=sys.stderr)
        else:
            fm.loop()
    except Exception:  # pylint: disable=broad-except
        import traceback
        exit_msg += '''\
ranger version: {0}
Python version: {1}
Locale: {2}
'''.format(ranger.__version__,
           sys.version.split()[0],
           '.'.join(str(s) for s in locale.getlocale()))
        try:
            exit_msg += "Current file: '{0}'\n".format(fm.thisfile.path)
        except AttributeError:
            pass
        exit_msg += '''
{0}
ranger crashed. Please report this traceback at:
https://github.com/hut/ranger/issues
'''.format(traceback.format_exc())
        exit_code = 1

    except SystemExit as ex:
        if ex.code is not None:
            if not isinstance(ex.code, int):
                exit_msg = ex.code
                exit_code = 1
            else:
                exit_code = ex.code
    finally:
        if exit_msg:
            LOG.critical(exit_msg)
        try:
            fm.ui.destroy()
        except (AttributeError, NameError):
            pass
        # If profiler is enabled print the stats
        if ranger.args.profile and profile:
            profile.strip_dirs().sort_stats('cumulative').print_callees()
        # print the exit message if any
        if exit_msg:
            sys.stderr.write(exit_msg)
        return exit_code  # pylint: disable=lost-exception
示例#12
0
def parse_arguments():
    """Parse the program arguments"""
    from optparse import OptionParser, SUPPRESS_HELP
    from ranger import __version__
    from ranger.ext.openstruct import OpenStruct
    from os.path import expanduser

    if 'XDG_CONFIG_HOME' in os.environ and os.environ['XDG_CONFIG_HOME']:
        default_confdir = os.environ['XDG_CONFIG_HOME'] + '/ranger'
    else:
        default_confdir = '~/.config/ranger'
    usage = '%prog [options] [path/filename]'

    minor_version = __version__[2:]  # assumes major version number is <10
    if '.' in minor_version:
        minor_version = minor_version[:minor_version.find('.')]
    version_tag = ' (stable)' if int(minor_version) % 2 == 0 else ' (testing)'
    if __version__.endswith('.0'):
        version_string = 'ranger ' + __version__[:-2] + version_tag
    else:
        version_string = 'ranger ' + __version__ + version_tag

    parser = OptionParser(usage=usage, version=version_string)

    parser.add_option('-d',
                      '--debug',
                      action='store_true',
                      help="activate debug mode")
    parser.add_option('-c',
                      '--clean',
                      action='store_true',
                      help="don't touch/require any config files. ")
    parser.add_option(
        '--fail-if-run',
        action='store_true',  # COMPAT
        help=SUPPRESS_HELP)
    parser.add_option(
        '--copy-config',
        type='string',
        metavar='which',
        help="copy the default configs to the local config directory. "
        "Possible values: all, apps, commands, keys, options, scope")
    parser.add_option('--fail-unless-cd', action='store_true',
      help="experimental: return the exit code 1 if ranger is" \
        "used to run a file (with `ranger filename`)")
    parser.add_option('-r',
                      '--confdir',
                      type='string',
                      metavar='dir',
                      default=default_confdir,
                      help="the configuration directory. (%default)")
    parser.add_option('-m',
                      '--mode',
                      type='int',
                      default=0,
                      metavar='n',
                      help="if a filename is supplied, run it with this mode")
    parser.add_option(
        '-f',
        '--flags',
        type='string',
        default='',
        metavar='string',
        help="if a filename is supplied, run it with these flags.")
    parser.add_option(
        '--choosefile',
        type='string',
        metavar='TARGET',
        help="Makes ranger act like a file chooser. When opening "
        "a file, it will quit and write the name of the selected "
        "file to TARGET.")
    parser.add_option(
        '--choosedir',
        type='string',
        metavar='TARGET',
        help="Makes ranger act like a directory chooser. When ranger quits"
        ", it will write the name of the last visited directory to TARGET")

    options, positional = parser.parse_args()
    arg = OpenStruct(options.__dict__, targets=positional)
    arg.confdir = expanduser(arg.confdir)
    if arg.fail_if_run:
        arg.fail_unless_cd = arg.fail_if_run
        del arg['fail_if_run']

    return arg
示例#13
0
 def settings(self):
     from ranger.ext.openstruct import OpenStruct
     return OpenStruct()
示例#14
0
 def __init__(self):
     self.loader = Loader()
     fm = OpenStruct(loader=self.loader)
     SettingsAware.settings = Fake()
     FileManagerAware.fm = fm
     self.dir = Directory(TESTDIR)