view release on metacpan or  search on metacpan

src/subversion/subversion/bindings/swig/ruby/svn/client.rb  view on Meta::CPAN

      end

      def commit(targets, recurse=true, keep_locks=false,
                 keep_changelist=false, changelist_name=nil,
                 revprop_table=nil)
        targets = [targets] unless targets.is_a?(Array)
        Client.commit4(targets, recurse, keep_locks, keep_changelist,
                       changelist_name, revprop_table, self)
      end
      alias ci commit

      def status(path, rev=nil, depth_or_recurse=nil, get_all=false,
                 update=true, no_ignore=false,
                 ignore_externals=false, changelists_names=nil, &status_func)
        depth = Core::Depth.infinity_or_immediates_from_recurse(depth_or_recurse)
        changelists_names = [changelists_names] unless changelists_names.is_a?(Array) or changelists_names.nil?
        Client.status3(path, rev, status_func,
                       depth, get_all, update, no_ignore,
                       ignore_externals, changelists_names, self)
      end
      alias st status

      def add(path, recurse=true, force=false, no_ignore=false)
        Client.add3(path, recurse, force, no_ignore, self)
      end

      def delete(paths, force=false, keep_local=false, revprop_table=nil)
        paths = [paths] unless paths.is_a?(Array)
        Client.delete3(paths, force, keep_local, revprop_table, self)
      end
      alias del delete
      alias remove delete
      alias rm remove

      def rm_f(*paths)
        paths = paths.first if paths.size == 1 and paths.first.is_a?(Array)
        rm(paths, true)
      end

      def update(paths, rev="HEAD", depth=nil, ignore_externals=false,
                 allow_unver_obstruction=false, depth_is_sticky=false)
        paths_is_array = paths.is_a?(Array)
        paths = [paths] unless paths_is_array
        result = Client.update3(paths, rev, depth, depth_is_sticky,
                                ignore_externals, allow_unver_obstruction,
                                self)
        result = result.first unless paths_is_array
        result
      end
      alias up update

      def import(path, uri, depth_or_recurse=true, no_ignore=false, revprop_table=nil)
        depth = Core::Depth.infinity_or_immediates_from_recurse(depth_or_recurse)
        Client.import3(path, uri, depth, no_ignore, false, revprop_table, self)
      end

      def cleanup(dir)
        Client.cleanup(dir, self)
      end

      def relocate(dir, from, to, recurse=true)
        Client.relocate(dir, from, to, recurse, self)
      end

      def revert(paths, recurse=true)
        paths = [paths] unless paths.is_a?(Array)
        Client.revert(paths, recurse, self)
      end

      def resolved(path, recurse=true)
        Client.resolved(path, recurse, self)
      end

      RESOLVE_REQUIRED_ARGUMENTS_KEYS = [:path]
      def resolve(arguments={})
        arguments = arguments.reject {|k, v| v.nil?}
        optional_arguments_defaults = {
          :depth => nil,
          :conflict_choice => Wc::CONFLICT_CHOOSE_POSTPONE
        }
        arguments = optional_arguments_defaults.merge(arguments)
        Util.validate_options(arguments,
                              optional_arguments_defaults.keys,
                              RESOLVE_REQUIRED_ARGUMENTS_KEYS)

        Client.resolve(arguments[:path], arguments[:depth], arguments[:conflict_choice], self)
      end

      def propset(name, value, target, depth_or_recurse=nil, force=false,
                  base_revision_for_url=nil, changelists_names=nil,
                  revprop_table=nil)
        base_revision_for_url ||= Svn::Core::INVALID_REVNUM
        depth = Core::Depth.infinity_or_empty_from_recurse(depth_or_recurse)
        changelists_names = [changelists_names] unless changelists_names.is_a?(Array) or changelists_names.nil?
        Client.propset3(name, value, target, depth, force,
                        base_revision_for_url, changelists_names,
                        revprop_table, self)
      end
      alias prop_set propset
      alias pset propset
      alias ps propset

      def propdel(name, *args)
        propset(name, nil, *args)
      end
      alias prop_del propdel
      alias pdel propdel
      alias pd propdel

      # Returns a value of a property, with +name+ attached to +target+,
      # as a Hash such as <tt>{uri1 => value1, uri2 => value2, ...}</tt>.
      def propget(name, target, rev=nil, peg_rev=nil, depth_or_recurse=nil,
                  changelists_names=nil)
        rev ||= "HEAD"
        peg_rev ||= rev
        depth = Core::Depth.infinity_or_empty_from_recurse(depth_or_recurse)
        changelists_names = [changelists_names] unless changelists_names.is_a?(Array) or changelists_names.nil?
        Client.propget3(name, target, peg_rev, rev, depth, changelists_names, self).first
      end
      alias prop_get propget
      alias pget propget
      alias pg propget