subversion 1.6.6-x86-mswin32-60

data/ruby/lib/svn/info.rb

@@ -0,0 +1,321 @@
+require "English"
+require "time"
+require "digest/sha2"
+require "tempfile"
+
+require "nkf"
+begin
+  require "uconv"
+rescue LoadError
+  module Uconv
+    class Error < StandardError
+    end
+    def self.u8toeuc(str)
+      raise Error
+    end
+  end
+end
+
+require "svn/core"
+require "svn/repos"
+require "svn/fs"
+require "svn/delta"
+
+module Svn
+  class Info
+
+    attr_reader :author, :log, :date, :changed_dirs
+    attr_reader :added_files, :deleted_files, :updated_files, :copied_files
+    attr_reader :added_dirs, :deleted_dirs, :updated_dirs, :copied_dirs
+    attr_reader :path, :revision, :diffs
+    attr_reader :sha256, :entire_sha256
+
+    def initialize(path, rev)
+      setup(path, rev)
+      get_info
+      get_dirs_changed
+      get_changed
+      get_diff
+      get_sha256
+      teardown
+    end
+
+    def paths
+      files + directories
+    end
+
+    def files
+      @added_files + @deleted_files + @updated_files + @copied_files
+    end
+
+    def directories
+      @added_dirs + @deleted_dirs + @updated_dirs + @copied_dirs
+    end
+
+    def sub_paths(prefix)
+      prefixes = prefix.split(/\/+/)
+      results = []
+      paths.each do |path,|
+        paths = path.split(/\/+/)
+        if prefixes.size < paths.size and prefixes == paths[0, prefixes.size]
+          results << paths[prefixes.size]
+        end
+      end
+      results
+    end
+
+    private
+    def setup(path, rev)
+      @path = path
+      @revision = Integer(rev)
+      @prev_rev = @revision - 1
+      @repos = Repos.open(@path)
+      @fs = @repos.fs
+      @root = @fs.root(@revision)
+    end
+
+    def teardown
+      @repos.close
+      @repos = @root = @fs = nil
+    end
+
+    def get_info
+      @author = force_to_utf8(prop(Core::PROP_REVISION_AUTHOR))
+      @date = prop(Core::PROP_REVISION_DATE)
+      @log = force_to_utf8(prop(Core::PROP_REVISION_LOG))
+    end
+
+    def get_dirs_changed
+      editor = traverse(Delta::ChangedDirsEditor)
+      @changed_dirs = editor.changed_dirs
+    end
+
+    def get_changed
+      editor = traverse(Delta::ChangedEditor, true)
+      @copied_files = editor.copied_files
+      @copied_dirs = editor.copied_dirs
+      @added_files = editor.added_files
+      @added_dirs = editor.added_dirs
+      @deleted_files = editor.deleted_files
+      @deleted_dirs = editor.deleted_dirs
+      @updated_files = editor.updated_files
+      @updated_dirs = editor.updated_dirs
+    end
+
+    def get_diff
+      tree = @repos.delta_tree(@root, @prev_rev)
+      @diffs = {}
+      get_diff_recurse(tree, @fs.root(@prev_rev), "", "")
+      @diffs.each do |key, values|
+        values.each do |type, diff|
+          diff.body = force_to_utf8(diff.body)
+        end
+      end
+    end
+
+    TYPE_TABLE = [
+      [:copy?, :copied],
+      [:add?, :added],
+      [:delete?, :deleted],
+      [:replace?, :modified],
+    ]
+
+    def get_type(node)
+      TYPE_TABLE.each do |meth, type|
+        return type if node.__send__(meth)
+      end
+      nil
+    end
+
+    def get_diff_recurse(node, base_root, path, base_path)
+      if node.copy?
+        base_path = node.copyfrom_path.sub(/\A\//, '')
+        base_root = base_root.fs.root(node.copyfrom_rev)
+      end
+
+      if node.file?
+        try_diff(node, base_root, path, base_path)
+      end
+
+      if node.prop_mod? and !node.delete?
+        get_prop_diff(node, base_root, path, base_path)
+      end
+
+      node = node.child
+      if node
+        get_diff_recurse(node, base_root,
+                         "#{path}/#{node.name}",
+                         "#{base_path}/#{node.name}")
+        while node.sibling
+          node = node.sibling
+          get_diff_recurse(node, base_root,
+                           "#{path}/#{node.name}",
+                           "#{base_path}/#{node.name}")
+        end
+      end
+    end
+
+    def get_prop_diff(node, base_root, path, base_path)
+      local_props = @root.node_prop_list(path)
+      if node.add?
+        base_props = {}
+      else
+        base_props = base_root.node_prop_list(base_path)
+      end
+      prop_changes = Core::Property.diffs2(local_props, base_props)
+      prop_changes.each do |name, value|
+        entry = diff_entry(path, :property_changed)
+        entry.body << "Name: #{force_to_utf8(name)}\n"
+        orig_value = base_props[name]
+        entry.body << "   - #{force_to_utf8(orig_value)}\n" if orig_value
+        entry.body << "   + #{force_to_utf8(value)}\n" if value
+      end
+    end
+
+    def try_diff(node, base_root, path, base_path)
+      if node.replace? and node.text_mod?
+        differ = Fs::FileDiff.new(base_root, base_path, @root, path)
+        do_diff(node, base_root, path, base_path, differ)
+      elsif node.add? and node.text_mod?
+        differ = Fs::FileDiff.new(nil, base_path, @root, path)
+        do_diff(node, base_root, path, base_path, differ)
+      elsif node.delete?
+        differ = Fs::FileDiff.new(base_root, base_path, nil, path)
+        do_diff(node, base_root, path, base_path, differ)
+      elsif node.copy?
+        diff_entry(path, get_type(node))
+      end
+    end
+
+    def do_diff(node, base_root, path, base_path, differ)
+      entry = diff_entry(path, get_type(node))
+
+      if differ.binary?
+        entry.body = "(Binary files differ)\n"
+      else
+        base_rev = base_root.revision
+        rev = @root.revision
+        base_date = base_root.fs.prop(Core::PROP_REVISION_DATE, base_rev)
+        date = @root.fs.prop(Core::PROP_REVISION_DATE, rev)
+        base_date = format_date(base_date)
+        date = format_date(date)
+        stripped_base_path = base_path.sub(/\A\//, '')
+        stripped_path = path.sub(/\A\//, '')
+        base_label = "#{stripped_base_path}\t#{base_date} (rev #{base_rev})"
+        label = "#{stripped_path}\t#{date} (rev #{rev})"
+        entry.body = differ.unified(base_label, label, "UTF-8")
+        parse_diff_unified(entry)
+      end
+    end
+
+    def parse_diff_unified(entry)
+      in_content = false
+      entry.body.each do |line|
+        case line
+        when /^@@/
+          in_content = true
+        else
+          if in_content
+            case line
+            when /^\+/
+              entry.count_up_added_line!
+            when /^-/
+              entry.count_up_deleted_line!
+            end
+          end
+        end
+      end
+    end
+
+    def dump_contents(root, path)
+      root.file_contents(path) do |f|
+        if block_given?
+          yield f
+        else
+          f.read
+        end
+      end
+    end
+
+    def diff_entry(target, type)
+      target = target.sub(/\A\//, '')
+      @diffs[target] ||= {}
+      @diffs[target][type] ||= DiffEntry.new(type)
+      @diffs[target][type]
+    end
+
+    def get_sha256
+      sha = Digest::SHA256.new
+      @sha256 = {}
+      [
+        @added_files,
+#        @deleted_files,
+        @updated_files,
+      ].each do |files|
+        files.each do |file|
+          content = dump_contents(@root, file)
+          sha << content
+          @sha256[file] = {
+            :file => file,
+            :revision => @revision,
+            :sha256 => Digest::SHA256.hexdigest(content),
+          }
+        end
+      end
+      @entire_sha256 = sha.hexdigest
+    end
+
+    def prop(name)
+      @fs.prop(name, @revision)
+    end
+
+    def force_to_utf8(str)
+      str = str.to_s
+      begin
+        # check UTF-8 or not
+        Uconv.u8toeuc(str)
+        str
+      rescue Uconv::Error
+        NKF.nkf("-w", str)
+      end
+    end
+
+    def traverse(editor_class, pass_root=false)
+      base_rev = @prev_rev
+      base_root = @fs.root(base_rev)
+      if pass_root
+        editor = editor_class.new(@root, base_root)
+      else
+        editor = editor_class.new
+      end
+      base_root.dir_delta("", "", @root, "", editor)
+      editor
+    end
+
+    def format_date(date)
+      formatted = date.strftime("%Y-%m-%d %H:%M:%S")
+      formatted << (" %+03d:00" % (date.hour - date.getutc.hour))
+      formatted
+    end
+
+    class DiffEntry
+      attr_reader :type, :added_line, :deleted_line
+      attr_accessor :body
+
+      def initialize(type)
+        @type = type
+        @added_line = 0
+        @deleted_line = 0
+        @body = ""
+      end
+
+      def count_up_added_line!
+        @added_line += 1
+      end
+
+      def count_up_deleted_line!
+        @deleted_line += 1
+      end
+    end
+  end
+end

data/ruby/lib/svn/ra.rb

@@ -0,0 +1,353 @@
+require "English"
+require "tempfile"
+require "svn/error"
+require "svn/util"
+require "svn/core"
+require "svn/repos"
+require "svn/ext/ra"
+
+module Svn
+  module Ra
+    Util.set_constants(Ext::Ra, self)
+    Util.set_methods(Ext::Ra, self)
+
+    @@ra_pool = Svn::Core::Pool.new
+    Ra.initialize(@@ra_pool)
+
+    class << self
+      def modules
+        print_modules("")
+      end
+    end
+
+    Session = SWIG::TYPE_p_svn_ra_session_t
+
+    class Session
+      class << self
+        def open(url, config=nil, callbacks=nil)
+          pool = Core::Pool.new
+          session = Ra.open2(url, callbacks, config || Svn::Core::Config.get, pool)
+          session.instance_variable_set(:@pool, pool)
+          return session unless block_given?
+          begin
+            yield session
+          ensure
+            session.close
+          end
+        end
+      end
+
+      def close
+        @pool.destroy
+      end
+
+      def latest_revnum
+        Ra.get_latest_revnum(self)
+      end
+      alias latest_revision latest_revnum
+
+      def dated_revision(time)
+        Ra.get_dated_revision(self, time.to_apr_time)
+      end
+
+      def set_prop(name, value, rev=nil)
+        Ra.change_rev_prop(self, rev || latest_revnum, name, value)
+      end
+
+      def []=(name, *args)
+        value = args.pop
+        set_prop(name, value, *args)
+        value
+      end
+
+      def proplist(rev=nil)
+        Ra.rev_proplist(self, rev || latest_revnum)
+      end
+      alias properties proplist
+
+      def prop(name, rev=nil)
+        Ra.rev_prop(self, rev || latest_revnum, name)
+      end
+      alias [] prop
+
+      def commit_editor(log_msg, lock_tokens={}, keep_lock=false)
+        callback = Proc.new do |new_revision, date, author|
+          yield(new_revision, date, author)
+        end
+        editor, editor_baton = Ra.get_commit_editor(self, log_msg, callback,
+                                                    lock_tokens, keep_lock)
+        editor.baton = editor_baton
+        [editor, editor_baton]
+      end
+
+      def commit_editor2(log_msg_or_rev_props, lock_tokens={},
+                         keep_lock=false, &callback)
+        if log_msg_or_rev_props.is_a?(Hash)
+          rev_props = log_msg_or_rev_props
+        else
+          rev_props = {Svn::Core::PROP_REVISION_LOG => log_msg_or_rev_props}
+        end
+        editor, editor_baton = Ra.get_commit_editor3(self, rev_props, callback,
+                                                     lock_tokens, keep_lock)
+        editor.baton = editor_baton
+        editor
+      end
+
+      def file(path, rev=nil)
+        output = StringIO.new
+        rev ||= latest_revnum
+        fetched_rev, props = Ra.get_file(self, path, rev, output)
+        output.rewind
+        props_filter(props)
+        [output.read, props]
+      end
+
+      def dir(path, rev=nil, fields=nil)
+        rev ||= latest_revnum
+        fields ||= Core::DIRENT_ALL
+        entries, fetched_rev, props = Ra.get_dir2(self, path, rev, fields)
+        props_filter(props)
+        [entries, props]
+      end
+
+      def update(revision_to_update_to, update_target,
+                 editor, editor_baton, depth=nil, &block)
+        editor.baton = editor_baton
+        update2(revision_to_update_to, update_target,
+                editor, depth, &block)
+      end
+
+      def update2(revision_to_update_to, update_target, editor, depth=nil,
+                  send_copyfrom_args=nil)
+        reporter, reporter_baton = Ra.do_update2(self, revision_to_update_to,
+                                                 update_target, depth,
+                                                 send_copyfrom_args, editor)
+        reporter.baton = reporter_baton
+        if block_given?
+          yield(reporter)
+          reporter.finish_report
+          nil
+        else
+          reporter
+        end
+      end
+
+      def switch(revision_to_switch_to, switch_target, switch_url,
+                 editor, editor_baton, depth=nil, &block)
+        editor.baton = editor_baton
+        switch2(revision_to_switch_to, switch_target, switch_url,
+                editor, depth, &block)
+      end
+
+      def switch2(revision_to_switch_to, switch_target, switch_url,
+                  editor, depth=nil)
+        reporter, reporter_baton = Ra.do_switch2(self, revision_to_switch_to,
+                                                 switch_target, depth,
+                                                 switch_url, editor)
+        reporter.baton = reporter_baton
+        if block_given?
+          yield(reporter)
+          reporter.finish_report
+          nil
+        else
+          reporter
+        end
+      end
+
+      def status(revision, status_target, editor, editor_baton,
+                 recurse=true, &block)
+        editor.baton = editor_baton
+        status2(revision, status_target, editor, recurse, &block)
+      end
+
+      def status2(revision, status_target, editor, recurse=true)
+        reporter, reporter_baton = Ra.do_status2(self, status_target,
+                                                 revision, recurse, editor)
+        reporter.baton = reporter_baton
+        if block_given?
+          yield(reporter)
+          reporter.finish_report
+          nil
+        else
+          reporter
+        end
+      end
+
+      def diff(rev, target, versus_url, editor,
+               depth=nil, ignore_ancestry=true, text_deltas=true)
+        args = [self, rev, target, depth, ignore_ancestry,
+                text_deltas, versus_url, editor]
+        reporter, baton = Ra.do_diff3(*args)
+        reporter.baton = baton
+        reporter
+      end
+
+      def log(paths, start_rev, end_rev, limit,
+              discover_changed_paths=true,
+              strict_node_history=false)
+        paths = [paths] unless paths.is_a?(Array)
+        receiver = Proc.new do |changed_paths, revision, author, date, message|
+          yield(changed_paths, revision, author, date, message)
+        end
+        Ra.get_log(self, paths, start_rev, end_rev, limit,
+                   discover_changed_paths, strict_node_history,
+                   receiver)
+      end
+
+      def check_path(path, rev=nil)
+        Ra.check_path(self, path, rev || latest_revnum)
+      end
+
+      def stat(path, rev=nil)
+        Ra.stat(self, path, rev || latest_revnum)
+      end
+
+      def uuid
+        Ra.get_uuid(self)
+      end
+
+      def repos_root
+        Ra.get_repos_root(self)
+      end
+
+      def locations(path, location_revisions, peg_revision=nil)
+        peg_revision ||= latest_revnum
+        Ra.get_locations(self, path, peg_revision, location_revisions)
+      end
+
+      def file_revs(path, start_rev, end_rev=nil)
+        args = [path, start_rev, end_rev]
+        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=nil)
+        end_rev ||= latest_revnum
+        revs = []
+        handler = Proc.new do |path, rev, rev_props, prop_diffs|
+          revs << [path, rev, rev_props, prop_diffs]
+          yield(path, rev, rev_props, prop_diffs) if block_given?
+        end
+        Ra.get_file_revs(self, path, start_rev, end_rev, handler)
+        revs
+      end
+
+      def lock(path_revs, comment=nil, steal_lock=false)
+        lock_func = Proc.new do |path, do_lock, lock, ra_err|
+          yield(path, do_lock, lock, ra_err)
+        end
+        Ra.lock(self, path_revs, comment, steal_lock, lock_func)
+      end
+
+      def unlock(path_tokens, break_lock=false, &lock_func)
+        Ra.unlock(self, path_tokens, break_lock, lock_func)
+      end
+
+      def get_lock(path)
+        Ra.get_lock(self, path)
+      end
+
+      def get_locks(path)
+        Ra.get_locks(self, path)
+      end
+
+      def replay(rev, low_water_mark, editor, send_deltas=true)
+        Ra.replay(self, rev, low_water_mark, send_deltas, editor)
+      end
+
+      def reparent(url)
+        Ra.reparent(self, url)
+      end
+
+      def mergeinfo(paths, revision=nil, inherit=nil, include_descendants=false)
+        paths = [paths] unless paths.is_a?(Array)
+        revision ||= Svn::Core::INVALID_REVNUM
+        info = Ra.get_mergeinfo(self, paths, revision, inherit,
+                                include_descendants)
+        unless info.nil?
+          info.each_key do |key|
+            info[key] = Core::MergeInfo.new(info[key])
+          end
+        end
+        info
+      end
+
+      private
+      def props_filter(props)
+        date_str = props[Svn::Core::PROP_ENTRY_COMMITTED_DATE]
+        if date_str
+          date = Time.parse_svn_format(date_str)
+          props[Svn::Core::PROP_ENTRY_COMMITTED_DATE] = date
+        end
+        props
+      end
+    end
+
+    class Reporter3
+      attr_accessor :baton
+      def set_path(path, revision, depth=nil, start_empty=true,
+                   lock_token=nil)
+        Ra.reporter3_invoke_set_path(self, @baton, path, revision,
+                                     depth, start_empty, lock_token)
+      end
+
+      def delete_path(path)
+        Ra.reporter3_invoke_delete_path(self, @baton, path)
+      end
+
+      def link_path(path, url, revision, depth=nil,
+                    start_empty=true, lock_token=nil)
+        Ra.reporter3_invoke_link_path(self, @baton, path, url,
+                                      revision, depth, start_empty, lock_token)
+      end
+
+      def finish_report
+        Ra.reporter3_invoke_finish_report(self, @baton)
+      end
+
+      def abort_report
+        Ra.reporter3_invoke_abort_report(self, @baton)
+      end
+    end
+
+    remove_const(:Callbacks)
+    class Callbacks
+      include Core::Authenticatable
+
+      def initialize(auth_baton=nil)
+        self.auth_baton = auth_baton || Core::AuthBaton.new
+      end
+
+      def open_tmp_file
+        tmp = Tempfile.new("Svn::Ra")
+        path = tmp.path
+        tmp.close(true)
+        path
+      end
+
+      def get_wc_prop(relpath, name)
+        nil
+      end
+
+      def set_wc_prop(path, name, value)
+      end
+
+      def push_wc_prop(path, name, value)
+      end
+
+      def invalidate_wc_props(path, name)
+      end
+
+      def progress_func(progress, total)
+      end
+    end
+  end
+end