Example #1
0
    def _call_process(self, method, *args, **kwargs):
        """Run the given git command with the specified arguments and return
        the result as a String

        :param method:
            is the command. Contained "_" characters will be converted to dashes,
            such as in 'ls_files' to call 'ls-files'.

        :param args:
            is the list of arguments. If None is included, it will be pruned.
            This allows your commands to call git more conveniently as None
            is realized as non-existent

        :param kwargs:
            is a dict of keyword arguments.
            This function accepts the same optional keyword arguments
            as execute().

        ``Examples``::
            git.rev_list('master', max_count=10, header=True)

        :return: Same as ``execute``"""
        # Handle optional arguments prior to calling transform_kwargs
        # otherwise these'll end up in args, which is bad.
        _kwargs = {k: v for k, v in kwargs.items() if k in execute_kwargs}
        kwargs = {k: v for k, v in kwargs.items() if k not in execute_kwargs}

        insert_after_this_arg = kwargs.pop('insert_kwargs_after', None)

        # Prepare the argument list
        opt_args = self.transform_kwargs(**kwargs)
        ext_args = self.__unpack_args([a for a in args if a is not None])

        if insert_after_this_arg is None:
            args = opt_args + ext_args
        else:
            try:
                index = ext_args.index(insert_after_this_arg)
            except ValueError:
                raise ValueError("Couldn't find argument '%s' in args %s to insert kwargs after"
                                 % (insert_after_this_arg, str(ext_args)))
            # end handle error
            args = ext_args[:index + 1] + opt_args + ext_args[index + 1:]
        # end handle kwargs

        call = [self.GIT_PYTHON_GIT_EXECUTABLE]

        # add the git options, the reset to empty
        # to avoid side_effects
        call.extend(self._git_options)
        self._git_options = ()

        call.append(dashify(method))
        call.extend(args)

        return self.execute(call, **_kwargs)
Example #2
0
    def _call_process(self, method, *args, **kwargs):
        """Run the given git command with the specified arguments and return
		the result as a String

		:param method:
			is the command. Contained "_" characters will be converted to dashes,
			such as in 'ls_files' to call 'ls-files'.

		:param args:
			is the list of arguments. If None is included, it will be pruned.
			This allows your commands to call git more conveniently as None
			is realized as non-existent

		:param kwargs:
			is a dict of keyword arguments.
			This function accepts the same optional keyword arguments
			as execute().

		``Examples``::
			git.rev_list('master', max_count=10, header=True)

		:return: Same as ``execute``"""
        # Handle optional arguments prior to calling transform_kwargs
        # otherwise these'll end up in args, which is bad.
        _kwargs = dict()
        for kwarg in execute_kwargs:
            try:
                _kwargs[kwarg] = kwargs.pop(kwarg)
            except KeyError:
                pass

        # Prepare the argument list
        opt_args = self.transform_kwargs(**kwargs)

        ext_args = self.__unpack_args([a for a in args if a is not None])
        args = opt_args + ext_args

        call = ["git", dashify(method)]
        call.extend(args)

        return self.execute(call, **_kwargs)
	def _call_process(self, method, *args, **kwargs):
		"""Run the given git command with the specified arguments and return
		the result as a String

		:param method:
			is the command. Contained "_" characters will be converted to dashes,
			such as in 'ls_files' to call 'ls-files'.

		:param args:
			is the list of arguments. If None is included, it will be pruned.
			This allows your commands to call git more conveniently as None
			is realized as non-existent

		:param kwargs:
			is a dict of keyword arguments.
			This function accepts the same optional keyword arguments
			as execute().

		``Examples``::
			git.rev_list('master', max_count=10, header=True)

		:return: Same as ``execute``"""
		# Handle optional arguments prior to calling transform_kwargs
		# otherwise these'll end up in args, which is bad.
		_kwargs = dict()
		for kwarg in execute_kwargs:
			try:
				_kwargs[kwarg] = kwargs.pop(kwarg)
			except KeyError:
				pass

		# Prepare the argument list
		opt_args = self.transform_kwargs(**kwargs)
		
		ext_args = self.__unpack_args([a for a in args if a is not None])
		args = opt_args + ext_args

		call = ["git", dashify(method)]
		call.extend(args)

		return self.execute(call, **_kwargs)
Example #4
0
    def _call_process(self, method, *args, **kwargs):
        """Run the given git command with the specified arguments and return
        the result as a String

        :param method:
            is the command. Contained "_" characters will be converted to dashes,
            such as in 'ls_files' to call 'ls-files'.

        :param args:
            is the list of arguments. If None is included, it will be pruned.
            This allows your commands to call git more conveniently as None
            is realized as non-existent

        :param kwargs:
            is a dict of keyword arguments.
            This function accepts the same optional keyword arguments
            as execute().

        ``Examples``::
            git.rev_list('master', max_count=10, header=True)

        :return: Same as ``execute``"""
        # Handle optional arguments prior to calling transform_kwargs
        # otherwise these'll end up in args, which is bad.
        _kwargs = {k: v for k, v in kwargs.items() if k in execute_kwargs}
        kwargs = {k: v for k, v in kwargs.items() if k not in execute_kwargs}

        insert_after_this_arg = kwargs.pop('insert_kwargs_after', None)

        # Prepare the argument list
        opt_args = self.transform_kwargs(**kwargs)
        ext_args = self.__unpack_args([a for a in args if a is not None])

        if insert_after_this_arg is None:
            args = opt_args + ext_args
        else:
            try:
                index = ext_args.index(insert_after_this_arg)
            except ValueError:
                raise ValueError("Couldn't find argument '%s' in args %s to insert kwargs after"
                                 % (insert_after_this_arg, str(ext_args)))
            # end handle error
            args = ext_args[:index + 1] + opt_args + ext_args[index + 1:]
        # end handle kwargs

        call = [self.GIT_PYTHON_GIT_EXECUTABLE]

        # add persistent git options
        call.extend(self._persistent_git_options)

        # add the git options, then reset to empty
        # to avoid side_effects
        call.extend(self._git_options)
        self._git_options = ()

        call.append(dashify(method))
        call.extend(args)

        return self.execute(call, **_kwargs)
Example #5
0
        def make_call():
            call = [self.GIT_PYTHON_GIT_EXECUTABLE]

            # add the git options, the reset to empty
            # to avoid side_effects
            call.extend(self._git_options)
            self._git_options = ()

            call.extend([dashify(method)])
            call.extend(args)
            return call
Example #6
0
        def make_call():
            call = [self.GIT_PYTHON_GIT_EXECUTABLE]

            # add the git options, the reset to empty
            # to avoid side_effects
            call.extend(self._git_options)
            self._git_options = ()

            call.extend([dashify(method)])
            call.extend(args)
            return call
Example #7
0
    def _call_process(self, method, *args, **kwargs):
        """Run the given git command with the specified arguments and return
        the result as a String

        :param method:
            is the command. Contained "_" characters will be converted to dashes,
            such as in 'ls_files' to call 'ls-files'.

        :param args:
            is the list of arguments. If None is included, it will be pruned.
            This allows your commands to call git more conveniently as None
            is realized as non-existent

        :param kwargs:
            It contains key-values for the following:
            - the :meth:`execute()` kwds, as listed in :var:`execute_kwargs`;
            - "command options" to be converted by :meth:`transform_kwargs()`;
            - the `'insert_kwargs_after'` key which its value must match one of ``*args``,
              and any cmd-options will be appended after the matched arg.

        Examples::

            git.rev_list('master', max_count=10, header=True)

        turns into::

           git rev-list max-count 10 --header master

        :return: Same as ``execute``"""
        # Handle optional arguments prior to calling transform_kwargs
        # otherwise these'll end up in args, which is bad.
        exec_kwargs = dict(
            (k, v) for k, v in kwargs.items() if k in execute_kwargs)
        opts_kwargs = dict(
            (k, v) for k, v in kwargs.items() if k not in execute_kwargs)

        insert_after_this_arg = opts_kwargs.pop('insert_kwargs_after', None)

        # Prepare the argument list
        opt_args = self.transform_kwargs(**opts_kwargs)
        ext_args = self.__unpack_args([a for a in args if a is not None])

        if insert_after_this_arg is None:
            args = opt_args + ext_args
        else:
            try:
                index = ext_args.index(insert_after_this_arg)
            except ValueError:
                raise ValueError(
                    "Couldn't find argument '%s' in args %s to insert cmd options after"
                    % (insert_after_this_arg, str(ext_args)))
            # end handle error
            args = ext_args[:index + 1] + opt_args + ext_args[index + 1:]
        # end handle opts_kwargs

        call = [self.GIT_PYTHON_GIT_EXECUTABLE]

        # add persistent git options
        call.extend(self._persistent_git_options)

        # add the git options, then reset to empty
        # to avoid side_effects
        call.extend(self._git_options)
        self._git_options = ()

        call.append(dashify(method))
        call.extend(args)

        return self.execute(call, **exec_kwargs)
Example #8
0
 def make_call():
     call = [self.GIT_PYTHON_GIT_EXECUTABLE, dashify(method)]
     call.extend(args)
     return call
Example #9
0
    def _call_process(self, method, *args, **kwargs):
        """Run the given git command with the specified arguments and return
        the result as a String

        :param method:
            is the command. Contained "_" characters will be converted to dashes,
            such as in 'ls_files' to call 'ls-files'.

        :param args:
            is the list of arguments. If None is included, it will be pruned.
            This allows your commands to call git more conveniently as None
            is realized as non-existent

        :param kwargs:
            It contains key-values for the following:
            - the :meth:`execute()` kwds, as listed in :var:`execute_kwargs`;
            - "command options" to be converted by :meth:`transform_kwargs()`;
            - the `'insert_kwargs_after'` key which its value must match one of ``*args``,
              and any cmd-options will be appended after the matched arg.
        
        Examples::
        
            git.rev_list('master', max_count=10, header=True)
        
        turns into::
        
           git rev-list max-count 10 --header master

        :return: Same as ``execute``"""
        # Handle optional arguments prior to calling transform_kwargs
        # otherwise these'll end up in args, which is bad.
        exec_kwargs = dict((k, v) for k, v in kwargs.items() if k in execute_kwargs)
        opts_kwargs = dict((k, v) for k, v in kwargs.items() if k not in execute_kwargs)

        insert_after_this_arg = opts_kwargs.pop('insert_kwargs_after', None)

        # Prepare the argument list
        opt_args = self.transform_kwargs(**opts_kwargs)
        ext_args = self.__unpack_args([a for a in args if a is not None])

        if insert_after_this_arg is None:
            args = opt_args + ext_args
        else:
            try:
                index = ext_args.index(insert_after_this_arg)
            except ValueError:
                raise ValueError("Couldn't find argument '%s' in args %s to insert cmd options after"
                                 % (insert_after_this_arg, str(ext_args)))
            # end handle error
            args = ext_args[:index + 1] + opt_args + ext_args[index + 1:]
        # end handle opts_kwargs

        call = [self.GIT_PYTHON_GIT_EXECUTABLE]

        # add persistent git options
        call.extend(self._persistent_git_options)

        # add the git options, then reset to empty
        # to avoid side_effects
        call.extend(self._git_options)
        self._git_options = ()

        call.append(dashify(method))
        call.extend(args)

        return self.execute(call, **exec_kwargs)
Example #10
0
 def make_call():
     call = [self.GIT_PYTHON_GIT_EXECUTABLE, dashify(method)]
     call.extend(args)
     return call