svn-transform 0.1.0

data/lib/svn-transform.rb

@@ -0,0 +1,264 @@
+require 'pathname'
+require 'svn-fixture'
+
+class SvnTransform
+  VERSION = '0.1.0'
+  
+  class << self
+    # Use diff to compare two repositories (on local file system)
+    # Where reasonable, this (or something like it) should be run to verify 
+    # expected results. I recommend trying a direct copy first to ensure your
+    # original repo doesn't have any featurs that SvnPropsToYaml won't
+    # understand.
+    #
+    # http://www.coderetard.com/2009/02/17/compare-directories-and-file-content-in-linux-without-dircmp/
+    #
+    # ==== Gotchas
+    # svn:entry fields aren't directly copied, but seem to match.
+    # repo uuid is different, but not relevant, so that file is ignored.
+    # other differences may also exist if the in_repo is an older format.
+    #
+    # ==== Parameters
+    # old_dir<String>:: FS Path to original (in) repository.
+    # new_dir<String>:: FS Path to generated (out) repository.
+    #
+    # Note that these are filesystem paths, not Subversion URI's
+    #
+    # ==== Returns
+    # True, False::
+    #   Whether the directories are the same (except db/uuid file)
+    #   If False, puts the result of running the diff command.
+    def compare(old_dir, new_dir)
+      ret = `diff --brief --exclude=uuid -r "#{old_dir}" "#{new_dir}"`
+      if ret.empty?
+        return true
+      else
+        puts ret
+        return false
+      end
+    end
+  end
+  
+  # Setup and SvnTransform with in (existing) repository URI, a name for the
+  # out (transformed) repository, and options.
+  #
+  # ==== Parameters
+  # in_repo_uri<String>::
+  #   URI of existing repository(e.g. file:///home/jm81/repo,
+  #   svn://localhost/repo)
+  # out_repo_name<String>::
+  #   Name only of out repository (e.g. "out"). See options[:out_repos_path]
+  #   for specifying full path (on local filesystem only)
+  #
+  # ==== Options
+  # :username<String>:: Username for in (existing) repository
+  # :password<String>:: Password for in (existing) repository
+  # :out_repos_path<String>::
+  #   Full path for out repository (defaults to 
+  #   "#{SvnFixture.config[:base_path]}/repo_#{out_repo_name}")
+  # :out_wc_path<String>::
+  #   Full path for out working copy (used by SvnFixture; defaults to 
+  #   "#{SvnFixture.config[:base_path]}/wc_#{out_repo_name}")
+  def initialize(in_repo_uri, out_repo_name = nil, options = {})
+    @in_username = options[:username]
+    @in_password = options[:password]
+    @in_repo_uri = in_repo_uri
+    @out_repo_name = out_repo_name
+    @out_repos_path = options[:out_repos_path]
+    @out_wc_path = options[:out_wc_path]
+    @file_transforms = []
+    @dir_transforms = []
+  end
+  
+  # Add a transform to be run on files. This can either be a class or a block
+  # (see Parameters). Each file at revision is given as an SvnTransform::File
+  # to each transform, which can alter the basename, body and/or properties
+  # of the file prior to its being committed to the new Repository.
+  # 
+  # ==== Parameters
+  # klass<Class>::
+  #   A class whose #initialize method accepts a SvnTransform::File as the first
+  #   argument and which responds to #run.
+  # args<Array>::
+  #   Additional arguments to pass to klass#initialize
+  # block<Proc>::
+  #   A block that accepts one argument (a SvnTransform::File). If a klass is
+  #   also given, the block is ignored
+  #
+  # ==== Returns
+  # Array:: The current @file_transforms Array
+  #
+  # ==== Raises
+  # ArgumentError:: Neither a Class nor a block was given.
+  def file_transform(klass = nil, *args, &block)
+    if klass
+      @file_transforms << [klass, args]
+    elsif block_given?
+      @file_transforms << block
+    else
+      raise(ArgumentError, "Class or Block required")
+    end
+  end
+  
+  # Add a transform to be run on directories. See +file_transform+
+  def dir_transform(klass = nil, *args, &block)
+    if klass
+      @dir_transforms << [klass, args]
+    elsif block_given?
+      @dir_transforms << block
+    else
+      raise(ArgumentError, "Class or Block required")
+    end
+  end
+  
+  # Run the conversion. This method sets up the connection to the existing
+  # repo and the SvnFixture that will generate the final transformed repo, then
+  # calls +changesets+ to do the actual work. Finally, commit the SvnFixture
+  # (out repo) and update its rev 0 date to match the in repo
+  def convert
+    in_repo_session = Session.new(@in_repo_uri, @in_username, @out_username)
+    @in_repo = in_repo_session.session
+    @ctx = in_repo_session.context
+    @out_repo = SvnFixture.repo(@out_repo_name, @out_repos_path, @out_wc_path)
+    
+    # Process changesets and commit
+    changesets
+    @out_repo.commit
+    
+    # Update rev 0 date
+    r0_date = @ctx.revprop_list(@in_repo_uri, 0)[0]['svn:date']
+    @out_repo.repos.fs.set_prop('svn:date', SvnFixture.svn_time(r0_date), 0)
+  end
+  
+  # Process the existing changesets and generate a SvnFixture::Revision for
+  # each.
+  #
+  # TODO This is a massive mess. It works, at least for my purposes. But it is
+  # a mess. Ideally, it should be multiple methods. Part of this is due to how
+  # I set up the SvnFixture::Revision class, which accepts a block at initialize
+  # that is process only when its #commit method is called.
+  def changesets
+    args = ['', 1, @in_repo.latest_revnum, 0, true, nil]
+    path_renames = {}
+    
+    @in_repo.log(*args) do |changes, rev_num, author, date, msg|
+      # Sort so that files are processed first (for benefit of PropsToYaml),
+      # and deletes are last
+      changes = changes.sort { |a,b| sort_for(a, rev_num) <=> sort_for(b, rev_num) }
+      # Get revision properties
+      rev_props = @ctx.revprop_list(@in_repo_uri, rev_num)[0]
+      # Create Revision, including all revprops. Note that svn:author and 
+      # svn:date are revprops. SvnFixture::Revision allows these without the
+      # svn: prefix (as Symbol), but revprops are written last, and so this
+      # should be completely accurate.
+      in_repo = @in_repo
+      out_wc_path = @out_repo.wc_path
+      svn_transform = self
+      @out_repo.revision(rev_num, msg, rev_props) do
+        # Now go through all the changes. Setup directorie structure for each
+        # node. This is easier to understand, in my opinion.
+        
+        changes.each do |full_path, change|
+          full_path = Pathname.new(full_path.sub(/\A\//, ''))
+          # Descend to parent directory
+          parent_dir = self
+          full_path.dirname.descend do |path|
+            unless path.basename == '.'
+              parent_dir = parent_dir.dir(path.basename.to_s)
+            end
+          end
+          
+          # TODO Replaces
+          
+          if change.action == 'D'
+            del_path = path_renames['/' + full_path.to_s] || full_path.to_s
+            @ctx.delete(::File.join(out_wc_path, del_path))
+          elsif in_repo.stat(full_path.to_s, rev_num).file?
+            data = in_repo.file(full_path.to_s, rev_num)
+            transform_file = ::SvnTransform::File.new(full_path, data, rev_num, rev_props)
+            original_path = transform_file.path
+            svn_transform.__send__(:process_file_transforms, transform_file)
+            
+            if change.copyfrom_path
+              from_path = path_renames[change.copyfrom_path] || change.copyfrom_path
+              @ctx.cp( 
+                ::File.join(out_wc_path, from_path),
+                ::File.join(out_wc_path, transform_file.path.to_s)
+              )
+            end
+            
+            unless transform_file.skip?
+              parent_dir.file(transform_file.basename) do
+                body(transform_file.body)
+                transform_file.properties.each_pair do |prop_k, prop_v|
+                  prop(prop_k, prop_v) unless prop_k =~ /\Asvn:entry/
+                end
+              end
+              # For benefit of copies
+              if original_path != transform_file.path
+                path_renames['/' + original_path] = '/' + transform_file.path.to_s
+              end
+            end
+          else # directory
+            parent_dir.dir(full_path.basename.to_s) do
+              data = in_repo.dir(full_path.to_s, rev_num)
+              transform_dir = ::SvnTransform::Dir.new(full_path, data, rev_num, rev_props, in_repo, self)
+              svn_transform.__send__(:process_dir_transforms, transform_dir)
+              transform_dir.properties.each_pair do |prop_k, prop_v|
+                prop(prop_k, prop_v) unless prop_k =~ /\Asvn:entry/
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  private
+  
+  # Process @file_transforms against the given File
+  #
+  # ==== Parameters
+  # file<SvnTransform::File>:: A file in the original repo at a given revision
+  def process_file_transforms(file)
+    @file_transforms.each do |transform|
+      if transform.is_a?(Proc)
+        transform.call(file)
+      else
+        transform[0].new(file, *transform[1]).run
+      end
+    end
+  end
+  
+  # Process @dir_transforms against the given Dir
+  #
+  # ==== Parameters
+  # dir<SvnTransform::Dir>:: A directory in the original repo at a given revision
+  def process_dir_transforms(dir)
+    @dir_transforms.each do |transform|
+      if transform.is_a?(Proc)
+        transform.call(dir)
+      else
+        transform[0].new(dir, *transform[1]).run
+      end
+    end
+  end
+  
+  # Return an Integer such that file changes are first, directories second
+  # and deleted nodes last (to minimize the chance of a Transformation being
+  # overridden.
+  def sort_for(change, rev_num)
+    return 2 if change[1].action == 'D'
+    return 0 if @in_repo.stat(change[0].sub(/\A\//, ''), rev_num).file?
+    return 1
+  end
+end # SvnTransform
+
+require 'svn-transform/session'
+require 'svn-transform/file'
+require 'svn-transform/dir'
+
+# Require predefined transforms
+%w{extension newline noop props_to_yaml}.each do |filename|
+  require 'svn-transform/transform/' + filename
+end

data/lib/svn-transform/dir.rb

@@ -0,0 +1,65 @@
+class SvnTransform
+  # A directory in original Subversion Repository, at a given changeset. 
+  # Instances are initialized by SvnTransform#changesets.
+  #
+  # An instance for each file in the original repo at each revision will be
+  # passed to any directory transform blocks (TODO more info)
+  #
+  # Although more could theoretically be done (see #initialize fixture_dir
+  # param), the main thing intended to be alterable are the properties.
+  class Dir
+    # Initialize Dir instance using data passed by SvnTransform#changesets.
+    # This is data that will be available to Transformation blocks. It's
+    # relevant to remember that all this happens within a block given to an
+    # SvnFixture::Revision.
+    #
+    # ==== Parameters
+    # path<Pathname>::
+    #   Full path within original Repository
+    # node_data<Array[String, Hash]>::
+    #   Array returned by SWIG::TYPE_p_svn_ra_session_t#dir. First element is
+    #   a Hash of directory entries, second is Hash of properties.
+    # rev_num<Integer>::
+    #   Number of current revision
+    # rev_props<Hash>::
+    #   Properties for current revision
+    # repos<Svn::Ra::Session>::
+    #   Repo session (made available for PropsToYaml)
+    # fixture_dir<SvnFixture::Directory>::
+    #   The SvnFixture::Directory representing this directory. This could be
+    #   used to add, delete files, subdirs, etc, but doing much of that is
+    #   likely to lead to weird results. I certainly don't intend to test this
+    #   outside of one use case (PropsToYaml)
+    def initialize(path, node_data, rev_num, rev_props, repos, fixture_dir)
+      @path = path.kind_of?(Pathname) ? path : Pathname.new(path)
+      @entries = node_data[0]
+      @properties = node_data[1]
+      @rev_num = rev_num
+      @rev_props = rev_props
+      @repos = repos
+      @fixture_dir = fixture_dir
+    end
+    
+    attr_reader :path, :entries, :properties, :rev_num, :rev_props, :repos, :fixture_dir
+    
+    # Assign a new properties Hash to the node
+    #
+    # ==== Parameters
+    # hsh<~each_pair>::
+    #   A Hash (or other object) responding to #each_pair, where keys are 
+    #   svn property keys, and values are the corresponding property values.
+    #   This method does not verify that keys are "human-readable"
+    #   (See http://svnbook.red-bean.com/en/1.0/ch07s02.html)
+    def properties=(hsh)
+      unless hsh.respond_to?(:each_pair)
+        raise ArgumentError, "Argument must respond to #each_pair, such as a Hash"
+      end
+      @properties = hsh
+    end
+    
+    # Get the base of the File
+    def basename
+      @path.basename.to_s
+    end
+  end
+end

data/lib/svn-transform/file.rb

@@ -0,0 +1,79 @@
+class SvnTransform
+  # A file in original Subversion Repository, at a given changeset. Instances
+  # are initialized by SvnTransform#changesets.
+  #
+  # An instance for each file in the original repo at each revision will be
+  # passed to any file transform blocks (TODO more info)
+  class File
+    # Initialize File instance using data passed by SvnTransform#changesets.
+    # This is data that will be available to Transformation blocks. It's
+    # relevant to remember that all this happens within a block given to an
+    # SvnFixture::Revision
+    #
+    # ==== Parameters
+    # path<Pathname>::
+    #   Full path within original Repository
+    # node_data<Array[String, Hash]>::
+    #   Array returned by SWIG::TYPE_p_svn_ra_session_t#file. First element is
+    #   node body, second is hash of properties.
+    # rev_num<Integer>::
+    #   Number of current revision
+    # rev_props<Hash>::
+    #   Properties for current revision
+    def initialize(path, node_data, rev_num, rev_props)
+      @path = path.kind_of?(Pathname) ? path : Pathname.new(path)
+      @body = node_data[0]
+      @properties = node_data[1]
+      @rev_num = rev_num
+      @rev_props = rev_props
+    end
+    
+    attr_reader :path, :body, :properties, :rev_num, :rev_props
+    
+    # Change the body of the node. The new body will be placed in the new
+    # repository.
+    #
+    # ==== Parameters
+    # value<String>:: New body
+    attr_writer :body
+    
+    # Assign a new properties Hash to the node
+    #
+    # ==== Parameters
+    # hsh<~each_pair>::
+    #   A Hash (or other object) responding to #each_pair, where keys are 
+    #   svn property keys, and values are the corresponding property values.
+    #   This method does not verify that keys are "human-readable"
+    #   (See http://svnbook.red-bean.com/en/1.0/ch07s02.html)
+    def properties=(hsh)
+      unless hsh.respond_to?(:each_pair)
+        raise ArgumentError, "Argument must respond to #each_pair, such as a Hash"
+      end
+      @properties = hsh
+    end
+    
+    # Get the base of the File
+    def basename
+      @path.basename.to_s
+    end
+    
+    # Change the basename of the File. Alters the #path
+    #
+    # ==== Parameters
+    # val<String>:: New basename
+    def basename=(val)
+      @path = @path.dirname + val
+    end
+    
+    # Skip this file at this revision (that is, don't commit it to new repo).
+    def skip!
+      @skip = true
+    end
+    
+    # Whether this file should be skipped (not committed to new repo at this
+    # revision)
+    def skip?
+      @skip == true
+    end
+  end
+end

data/lib/svn-transform/session.rb

@@ -0,0 +1,62 @@
+class SvnTransform
+  # A simplistic wrapper for Svn::Ra::Session. This takes care of setting up
+  # the context and callbacks as well as making the actual connection.
+  class Session
+    # Setup repository information
+    #
+    # ==== Parameters
+    # uri<String>:: URI of the repository (e.g. svn://example.com/repo)
+    # username<String>:: Username, if needed
+    # password<String>:: Password, if needed
+    def initialize(uri, username = nil, password = nil)
+      @uri = uri
+      @username = username
+      @password = password
+    end
+    
+    # Open and return the actual Svn::Ra::Session
+    #
+    # ==== Returns
+    # Svn::Ra::Session:: A remote access session to a repository.
+    def session
+      # This will raise some error if connection fails for whatever reason.
+      # I don't currently see a reason to handle connection errors here, as I
+      # assume the best handling would be to raise another error.
+      @session ||= ::Svn::Ra::Session.open(@uri, {}, self.callbacks)
+    end
+    
+    # Setup, if needed, and return the working context (I don't really 
+    # understand all this, but it's required to work with the working copy).
+    #
+    # ==== Returns
+    # Svn::Client::Context:: Context for working with working copy
+    def context
+      @context || begin
+        # Client::Context, which paticularly holds an auth_baton.
+        @context = ::Svn::Client::Context.new
+        if @username && @password
+          # TODO: What if another provider type is needed? Is this plausible?
+          @context.add_simple_prompt_provider(0) do |cred, realm, username, may_save|
+            cred.username = @username
+            cred.password = @password
+          end
+        elsif URI.parse(@uri).scheme == "file" 
+          @context.add_username_prompt_provider(0) do |cred, realm, username, may_save|
+            cred.username = @username || "ANON"
+          end
+        else
+          @context.auth_baton = ::Svn::Core::AuthBaton.new()
+        end
+        @context
+      end
+    end
+    
+    # Setup callbacks for Svn::Ra::Session.open.
+    #
+    # ==== Returns
+    # Svn::Ra::Callbacks
+    def callbacks
+      ::Svn::Ra::Callbacks.new(context.auth_baton)
+    end
+  end
+end