subversion 1.6.6-x86-mswin32-60

data/ruby/lib/svn/repos.rb

@@ -0,0 +1,472 @@
+require "English"
+require "svn/error"
+require "svn/util"
+require "svn/core"
+require "svn/fs"
+require "svn/client"
+require "svn/ext/repos"
+
+module Svn
+  module Repos
+    Util.set_constants(Ext::Repos, self)
+    Util.set_methods(Ext::Repos, self)
+
+
+    @@alias_targets = %w(create hotcopy recover db_logfiles)
+    class << self
+      @@alias_targets.each do |target|
+        alias_method "_#{target}", target
+      end
+    end
+    @@alias_targets.each do |target|
+      alias_method "_#{target}", target
+    end
+    @@alias_targets = nil
+
+    module_function
+    def create(path, config={}, fs_config={}, &block)
+      _create(path, nil, nil, config, fs_config, &block)
+    end
+
+    def hotcopy(src, dest, clean_logs=true)
+      _hotcopy(src, dest, clean_logs)
+    end
+
+    def recover(path, nonblocking=false, cancel_func=nil, &start_callback)
+      recover3(path, nonblocking, start_callback, cancel_func)
+    end
+
+    def db_logfiles(path, only_unused=true)
+      _db_logfiles(path, only_unused)
+    end
+
+    def read_authz(file, must_exist=true)
+      Repos.authz_read(file, must_exist)
+    end
+
+    ReposCore = SWIG::TYPE_p_svn_repos_t
+    class ReposCore
+      class << self
+        def def_simple_delegate(*ids)
+          ids.each do |id|
+            module_eval(<<-EOC, __FILE__, __LINE__)
+            def #{id.to_s}
+              Repos.#{id.to_s}(self)
+            end
+            EOC
+          end
+        end
+      end
+
+      def_simple_delegate :path, :db_env, :conf_dir
+      def_simple_delegate :svnserve_conf, :lock_dir
+      def_simple_delegate :db_lockfile, :db_logs_lockfile
+      def_simple_delegate :hook_dir, :start_commit_hook
+      def_simple_delegate :pre_commit_hook, :post_commit_hook
+      def_simple_delegate :pre_revprop_change_hook, :post_revprop_change_hook
+      def_simple_delegate :pre_lock_hook, :post_lock_hook
+      def_simple_delegate :pre_unlock_hook, :post_unlock_hook
+
+      attr_reader :authz_read_func
+
+      def fs
+        Repos.fs_wrapper(self)
+      end
+
+      def set_authz_read_func(&block)
+        @authz_read_func = block
+      end
+
+      def report(rev, username, fs_base, target, tgt_path,
+                 editor, text_deltas=true, recurse=true,
+                 ignore_ancestry=false, authz_read_func=nil)
+        authz_read_func ||= @authz_read_func
+        args = [
+          rev, username, self, fs_base, target, tgt_path,
+          text_deltas, recurse, ignore_ancestry, editor,
+          authz_read_func,
+        ]
+        report_baton = Repos.begin_report(*args)
+        setup_report_baton(report_baton)
+        if block_given?
+          report_baton.set_path("", rev)
+          result = yield(report_baton)
+          report_baton.finish_report unless report_baton.aborted?
+          result
+        else
+          report_baton
+        end
+      end
+
+      def report2(rev, fs_base, target, tgt_path, editor, text_deltas=true,
+                  ignore_ancestry=false, depth=nil, authz_read_func=nil,
+                  send_copyfrom_args=nil)
+        authz_read_func ||= @authz_read_func
+        args = [
+          rev, self, fs_base, target, tgt_path, text_deltas,
+          depth, ignore_ancestry, send_copyfrom_args, editor,
+          authz_read_func,
+        ]
+        report_baton = Repos.begin_report2(*args)
+        setup_report_baton(report_baton)
+        if block_given?
+          report_baton.set_path("", rev, false, nil, depth)
+          result = yield(report_baton)
+          report_baton.finish_report unless report_baton.aborted?
+          result
+        else
+          report_baton
+        end
+      end
+
+      def commit_editor(repos_url, base_path, txn=nil, user=nil,
+                        log_msg=nil, commit_callback=nil,
+                        authz_callback=nil)
+        editor, baton = Repos.get_commit_editor3(self, txn, repos_url,
+                                                 base_path, user, log_msg,
+                                                 commit_callback,
+                                                 authz_callback)
+        editor.baton = baton
+        editor
+      end
+
+      def commit_editor2(repos_url, base_path, txn=nil, user=nil,
+                         log_msg=nil, commit_callback=nil,
+                         authz_callback=nil)
+        editor, baton = Repos.get_commit_editor4(self, txn, repos_url,
+                                                 base_path, user, log_msg,
+                                                 commit_callback,
+                                                 authz_callback)
+        editor.baton = baton
+        editor
+      end
+
+      def commit_editor3(repos_url, base_path, txn=nil, rev_props=nil,
+                         commit_callback=nil, authz_callback=nil)
+        rev_props ||= {}
+        editor, baton = Repos.get_commit_editor5(self, txn, repos_url,
+                                                 base_path, rev_props,
+                                                 commit_callback,
+                                                 authz_callback)
+        editor.baton = baton
+        editor
+      end
+
+      def youngest_revision
+        fs.youngest_rev
+      end
+      alias_method :youngest_rev, :youngest_revision
+
+      def dated_revision(date)
+        Repos.dated_revision(self, date.to_apr_time)
+      end
+
+      def logs(paths, start_rev, end_rev, limit,
+               discover_changed_paths=true,
+               strict_node_history=false,
+               authz_read_func=nil)
+        authz_read_func ||= @authz_read_func
+        paths = [paths] unless paths.is_a?(Array)
+        infos = []
+        receiver = Proc.new do |changed_paths, revision, author, date, message|
+          if block_given?
+            yield(changed_paths, revision, author, date, message)
+          end
+          infos << [changed_paths, revision, author, date, message]
+        end
+        Repos.get_logs3(self, paths, start_rev, end_rev,
+                        limit, discover_changed_paths,
+                        strict_node_history, authz_read_func,
+                        receiver)
+        infos
+      end
+
+      def file_revs(path, start_rev, end_rev, authz_read_func=nil)
+        args = [path, start_rev, end_rev, authz_read_func]
+        if block_given?
+          revs = file_revs2(*args) do |path, rev, rev_props, prop_diffs|
+            yield(path, rev, rev_props, Util.hash_to_prop_array(prop_diffs))
+          end
+        else
+          revs = file_revs2(*args)
+        end
+        revs.collect do |path, rev, rev_props, prop_diffs|
+          [path, rev, rev_props, Util.hash_to_prop_array(prop_diffs)]
+        end
+      end
+
+      def file_revs2(path, start_rev, end_rev, authz_read_func=nil)
+        authz_read_func ||= @authz_read_func
+        revs = []
+        handler = Proc.new do |path, rev, rev_props, prop_diffs|
+          yield(path, rev, rev_props, prop_diffs) if block_given?
+          revs << [path, rev, rev_props, prop_diffs]
+        end
+        Repos.get_file_revs(self, path, start_rev, end_rev,
+                            authz_read_func, handler)
+        revs
+      end
+
+      def commit_txn(txn)
+        Repos.fs_commit_txn(self, txn)
+      end
+
+      def transaction_for_commit(*args)
+        if args.first.is_a?(Hash)
+          props, rev = args
+        else
+          author, log, rev = args
+          props = {
+            Svn::Core::PROP_REVISION_AUTHOR => author,
+            Svn::Core::PROP_REVISION_LOG => log,
+          }
+        end
+        txn = Repos.fs_begin_txn_for_commit2(self, rev || youngest_rev, props)
+
+        if block_given?
+          yield(txn)
+          commit(txn) if fs.transactions.include?(txn.name)
+        else
+          txn
+        end
+      end
+
+      def transaction_for_update(author, rev=nil)
+        txn = Repos.fs_begin_txn_for_update(self, rev || youngest_rev, author)
+
+        if block_given?
+          yield(txn)
+          txn.abort if fs.transactions.include?(txn.name)
+        else
+          txn
+        end
+      end
+
+      def commit(txn)
+        Repos.fs_commit_txn(self, txn)
+      end
+
+      def lock(path, token=nil, comment=nil, dav_comment=true,
+               expiration_date=nil, current_rev=nil, steal_lock=false)
+        if expiration_date
+          expiration_date = expiration_date.to_apr_time
+        else
+          expiration_date = 0
+        end
+        current_rev ||= youngest_rev
+        Repos.fs_lock(self, path, token, comment,
+                      dav_comment, expiration_date,
+                      current_rev, steal_lock)
+      end
+
+      def unlock(path, token, break_lock=false)
+        Repos.fs_unlock(self, path, token, break_lock)
+      end
+
+      def get_locks(path, authz_read_func=nil)
+        authz_read_func ||= @authz_read_func
+        Repos.fs_get_locks(self, path, authz_read_func)
+      end
+
+      def set_prop(author, name, new_value, rev=nil, authz_read_func=nil,
+                   use_pre_revprop_change_hook=true,
+                   use_post_revprop_change_hook=true)
+        authz_read_func ||= @authz_read_func
+        rev ||= youngest_rev
+        Repos.fs_change_rev_prop3(self, rev, author, name, new_value,
+                                  use_pre_revprop_change_hook,
+                                  use_post_revprop_change_hook,
+                                  authz_read_func)
+      end
+
+      def prop(name, rev=nil, authz_read_func=nil)
+        authz_read_func ||= @authz_read_func
+        rev ||= youngest_rev
+        value = Repos.fs_revision_prop(self, rev, name, authz_read_func)
+        if name == Svn::Core::PROP_REVISION_DATE
+          value = Time.from_svn_format(value)
+        end
+        value
+      end
+
+      def proplist(rev=nil, authz_read_func=nil)
+        authz_read_func ||= @authz_read_func
+        rev ||= youngest_rev
+        props = Repos.fs_revision_proplist(self, rev, authz_read_func)
+        if props.has_key?(Svn::Core::PROP_REVISION_DATE)
+          props[Svn::Core::PROP_REVISION_DATE] =
+            Time.from_svn_format(props[Svn::Core::PROP_REVISION_DATE])
+        end
+        props
+      end
+
+      def node_editor(base_root, root)
+        editor, baton = Repos.node_editor(self, base_root, root)
+        def baton.node
+          Repos.node_from_baton(self)
+        end
+        editor.baton = baton
+        editor
+      end
+
+      def dump_fs(dumpstream, feedback_stream, start_rev, end_rev,
+                  incremental=true, use_deltas=true, &cancel_func)
+        Repos.dump_fs2(self, dumpstream, feedback_stream,
+                       start_rev, end_rev, incremental,
+                       use_deltas, cancel_func)
+      end
+
+      def load_fs(dumpstream, feedback_stream=nil, uuid_action=nil,
+                  parent_dir=nil, use_pre_commit_hook=true,
+                  use_post_commit_hook=true, &cancel_func)
+        uuid_action ||= Svn::Repos::LOAD_UUID_DEFAULT
+        Repos.load_fs2(self, dumpstream, feedback_stream,
+                       uuid_action, parent_dir,
+                       use_pre_commit_hook, use_post_commit_hook,
+                       cancel_func)
+      end
+
+      def build_parser(uuid_action, parent_dir,
+                       use_history=true, outstream=nil)
+        outstream ||= StringIO.new
+        parser, baton = Repos.get_fs_build_parser2(use_history,
+                                                   uuid_action,
+                                                   outstream,
+                                                   parent_dir)
+        def parser.parse_dumpstream(stream, &cancel_func)
+          Repos.parse_dumpstream2(stream, self, @baton, cancel_func)
+        end
+
+        def parser.outstream=(new_stream)
+          @outstream = new_stream
+        end
+
+        def parser.baton=(new_baton)
+          @baton = new_baton
+        end
+
+        def parser.baton
+          @baton
+        end
+
+        parser.outstream = outstream
+        parser.baton = baton
+        parser
+      end
+
+      def delta_tree(root, base_rev)
+        base_root = fs.root(base_rev)
+        editor = node_editor(base_root, root)
+        root.replay(editor)
+        editor.baton.node
+      end
+
+      def mergeinfo(paths, revision=nil, inherit=nil,
+                    include_descendants=false, &authz_read_func)
+        path = nil
+        unless paths.is_a?(Array)
+          path = paths
+          paths = [path]
+        end
+        revision ||= Svn::Core::INVALID_REVNUM
+        results = Repos.fs_get_mergeinfo(self, paths, revision,
+                                         inherit, include_descendants,
+                                         authz_read_func)
+        results = results[path] if path
+        results
+      end
+
+      private
+      def setup_report_baton(baton)
+        baton.instance_variable_set("@aborted", false)
+
+        def baton.aborted?
+          @aborted
+        end
+
+        def baton.set_path(path, revision, start_empty=false, lock_token=nil,
+                           depth=nil)
+          Repos.set_path3(self, path, revision, depth, start_empty, lock_token)
+        end
+
+        def baton.link_path(path, link_path, revision, start_empty=false,
+                            lock_token=nil, depth=nil)
+          Repos.link_path3(self, path, link_path, revision, depth,
+                           start_empty, lock_token)
+        end
+
+        def baton.delete_path(path)
+          Repos.delete_path(self, path)
+        end
+
+        def baton.finish_report
+          Repos.finish_report(self)
+        end
+
+        def baton.abort_report
+          Repos.abort_report(self)
+          @aborted = true
+        end
+
+      end
+    end
+
+
+    class Node
+
+      alias text_mod? text_mod
+      alias prop_mod? prop_mod
+
+      def copy?
+        Util.copy?(copyfrom_path, copyfrom_rev)
+      end
+
+      def add?
+        action == "A"
+      end
+
+      def delete?
+        action == "D"
+      end
+
+      def replace?
+        action == "R"
+      end
+
+      def file?
+        kind == Core::NODE_FILE
+      end
+
+      def dir?
+        kind == Core::NODE_DIR
+      end
+
+      def none?
+        kind == Core::NODE_NONE
+      end
+
+      def unknown?
+        kind == Core::NODE_UNKNOWN
+      end
+
+    end
+
+    Authz = SWIG::TYPE_p_svn_authz_t
+    class Authz
+
+      class << self
+        def read(file, must_exist=true)
+          Repos.authz_read(file, must_exist)
+        end
+      end
+
+      def can_access?(repos_name, path, user, required_access)
+        Repos.authz_check_access(self,
+                                 repos_name,
+                                 path,
+                                 user,
+                                 required_access)
+      end
+    end
+  end
+end

data/ruby/lib/svn/util.rb

@@ -0,0 +1,129 @@
+if /cygwin|mingw|mswin32|bccwin32/.match(RUBY_PLATFORM)
+  $LOAD_PATH.each do |load_path|
+    svn_ext_path = File.join(load_path, "svn", "ext")
+    if File.exists?(svn_ext_path)
+      svn_ext_path_win = File.expand_path(svn_ext_path)
+      svn_ext_path_win = svn_ext_path.gsub(File::SEPARATOR, File::ALT_SEPARATOR)
+      unless ENV["PATH"].split(";").find {|path| path == svn_ext_path_win}
+        ENV["PATH"] = "#{svn_ext_path_win};#{ENV['PATH']}"
+      end
+    end
+  end
+end
+
+require 'tempfile'
+
+unless respond_to?(:__send!)
+  module Kernel
+    alias __send! __send__
+  end
+end
+
+module Svn
+  module Util
+    module_function
+    def to_ruby_class_name(name)
+      name.split("_").collect do |x|
+        "#{x[0,1].upcase}#{x[1..-1].downcase}"
+      end.join("")
+    end
+
+    def to_ruby_const_name(name)
+      name.upcase
+    end
+
+    def valid_rev?(rev)
+      rev and rev >= 0
+    end
+
+    def copy?(copyfrom_path, copyfrom_rev)
+      Util.valid_rev?(copyfrom_rev) && !copyfrom_path.nil?
+    end
+
+    def hash_to_prop_array(hash)
+      hash.collect do |key, value|
+        Svn::Core::Prop.new(key, value)
+      end
+    end
+
+    def set_constants(ext_mod, target_mod=self)
+      target_name = nil
+      ext_mod.constants.each do |const|
+        target_name = nil
+        case const
+        when /^SVN__/
+          # ignore private constants
+        when /^SVN_(?:#{target_mod.name.split("::").last.upcase}_)?/
+          target_name = $POSTMATCH
+        when /^SWIG_SVN_/
+          target_name = $POSTMATCH
+        when /^Svn_(?:#{target_mod.name.split("::").last.downcase}_)?(.+)_t$/
+          target_name = to_ruby_class_name($1)
+        when /^Svn_(?:#{target_mod.name.split("::").last.downcase}_)?/
+          target_name = to_ruby_const_name($POSTMATCH)
+#         else
+#           puts const
+        end
+        unless target_name.nil?
+          target_mod.const_set(target_name, ext_mod.const_get(const))
+        end
+      end
+    end
+
+    def set_methods(ext_mod, target_mod=self)
+      target_name = nil
+      ext_mod.public_methods(false).each do |meth|
+        target_name = nil
+        case meth
+        when /^svn_(?:#{target_mod.name.split("::").last.downcase}_)?/
+          target_name = $POSTMATCH
+        when /^apr_/
+          target_name = meth
+        end
+        unless target_name.nil?
+          target_mod.module_eval(<<-EOC, __FILE__, __LINE__ + 1)
+            def #{target_name}(*args, &block)
+              #{ext_mod.name}.#{meth}(*args, &block)
+            end
+            module_function :#{target_name}
+EOC
+        end
+      end
+    end
+
+    def filename_to_temp_file(filename)
+      file = Tempfile.new("svn-ruby")
+      file.binmode
+      file.print(File.open(filename, "rb") {|f| f.read})
+      file.close
+      file.open
+      file.binmode
+      file
+    end
+
+    def reset_message_directory
+      if /cygwin|mingw|mswin32|bccwin32/.match(RUBY_PLATFORM)
+        top_directory = File.join(File.dirname(__FILE__), "..", "..")
+        top_directory = File.expand_path(top_directory)
+        locale_directory = File.join(top_directory, "share", "locale")
+        locale_directory_win = locale_directory.tr(File::SEPARATOR,
+                                                   File::ALT_SEPARATOR)
+        GetText.bindtextdomain(locale_directory_win)
+      end
+    end
+
+    def validate_options(options, optional_keys, required_keys=[])
+      unknown_keys = options.keys - (optional_keys + required_keys)
+      unless unknown_keys.empty?
+        raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}")
+      end
+      missing_keys = []
+      required_keys.each do |key|
+        missing_keys << key if options[key].nil?
+      end
+      unless missing_keys.empty?
+        raise(ArgumentError, "Missing key(s): #{missing_keys.join(", ")}")
+      end
+    end
+  end
+end