svn-fixture 0.1.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,10 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+.project
+.loadpath
+*qt_temp*
+*~
+*.gem

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jared Morgan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,77 @@
+svn-fixture
+===========
+
+svn-fixture simplifies creating (or updating) a Subversion repository. It is
+designed to be used in tests that require a Subversion repo, but can also be
+used to initialize a repository according to some template. svn-fixture depends
+on the Subversion Ruby bindings (see below for Installation help).
+
+##Usage
+
+svn-fixture uses blocks to mimic the structure of the Repository, in the 
+hierarchy: Repository -> Revision -> Directory tree structure with 
+subdirectories and files. For example:
+
+    SvnFixture::repo('hello_world') do
+      revision(1, 'Create directories',
+          :author => 'jmorgan',
+          :date => Time.parse('2009-01-01 12:00:00Z')) do
+        dir 'app'
+        dir 'docs'
+        dir 'lib'
+      end
+      
+      revision 2, 'Add a file' do
+        dir 'app' do
+          file 'hello.rb' do
+            prop 'is_ruby', 'Yes'
+            body 'puts "Hello World"'
+          end
+        end
+      end
+    end
+    
+    SvnFixture::repo('hello_world').commit
+    
+See spec/svn-fixture/fixtures/hello_world.rb and 
+spec/svn-fixture/integration_spec.rb for a more complete example.
+
+Each Repository is given a name ('hello_world' in the example above), so it can
+be reopened multiple times. Repository#revision defines a new Revision. It
+requires a name--but only for informational purposes--and a log message. A
+Revision also accepts an options Hash including optional :author and :date
+revision properties.
+
+Within a Revision is a directory tree, specifying only **changes** in that
+Revision. See Directory and File classes for details on available methods.
+
+To actually (optionally) create the repository and make the changes and commits
+specified in the Revision blocks, call Repository#commit. See Repository class
+for finer tuned control over the create/checkout/commit process.
+
+##Installation
+
+Install Subversion Swig bindings for Ruby. Some distros have a package for this.
+In debian: sudo apt-get install libsvn-ruby . See 
+[https://bssvnbrowser.bountysource.com/docs/subversion_ruby_bindings](https://bssvnbrowser.bountysource.com/docs/subversion_ruby_bindings) or
+[http://svn.collab.net/repos/svn/trunk/subversion/bindings/swig/INSTALL](http://svn.collab.net/repos/svn/trunk/subversion/bindings/swig/INSTALL)
+for more information.
+
+To install the gem:
+
+    gem sources -a http://gems.github.com
+    sudo gem install jm81-svn-fixture
+    
+To require:
+
+    gem 'jm81-svn-fixture'
+    require 'svn-fixture'
+
+Note: This library could work using the svn command line client instead. I use
+the bindings regularly, so using them makes sense for me. However, if you want
+to be able to use svn-fixture without installing the bindings, please send an
+email to jmorgan at morgancreative dot net, and I'll give it a shot.
+
+##Copyright
+
+Copyright (c) 2009 Jared Morgan. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "svn-fixture"
+    gem.summary = %Q{Ruby library to create Subversion repositories useful for tests}
+    gem.email = "jmorgan@morgancreative.net"
+    gem.homepage = "http://github.com/jm81/svn-fixture"
+    gem.authors = ["Jared Morgan"]
+    gem.description = <<-EOF
+svn-fixture simplifies creating (or updating) a Subversion repository. It is
+designed to be used in tests that require a Subversion repo, but can also be
+used to initialize a repository according to some template. svn-fixture depends
+on the Subversion Ruby bindings.
+EOF
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "svn-fixture #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.1.2

data/lib/svn-fixture.rb

@@ -0,0 +1,73 @@
+require "fileutils"
+require "tmpdir"
+require "date"
+require "time"
+# Subversion Ruby bindings must be installed (see README)
+require "svn/core"
+require "svn/fs"
+require "svn/repos"
+
+module SvnFixture
+  VERSION = '0.1.2'
+  
+  CONFIG_DEFAULTS = {
+    :base_path => File.join(Dir.tmpdir, 'svn-fixture')
+  }
+  
+  class << self
+    # SvnFixture::config method returns Hash that can be edited.
+    # The only current option is
+    # +:base_path+ : The path at which repositories are created. It default
+    # to the OS tmp directory, plus "svn-fixture". For example, 
+    # "/tmp/svn-fixture". The repo name is then appended in 
+    # +SvnFixture::Repository+.
+    def config
+      @config ||= CONFIG_DEFAULTS.dup
+    end
+    
+    # Return time string formatted as expected by ::Svn::Client::Context#propset
+    # (example 2009-06-28T12:00:00.000000Z). If +val+ does not respond to 
+    # +strftime+, val will first be parsed via +Time.parse+.
+    def svn_time(val)
+      return nil if val.nil?
+      val = Time.parse(val) unless val.respond_to?(:strftime)
+      val.strftime("%Y-%m-%dT%H:%M:%S.000000Z")
+    end
+    
+    # Return a Date or Time formatted as expected by 
+    # ::Svn::Client::Context#propset (see +svn_time+); leave other values alone.
+    def svn_prop(val)
+      val.respond_to?(:strftime) ? svn_time(val) : val
+    end
+    
+    # .repo is just a shortcut to +SvnFixture::Repository.get+
+    def repo(*args, &block)
+      SvnFixture::Repository.get(*args, &block)
+    end
+    
+    # Setup and return a simple ::Svn::Client::Context. This is called by
+    # Repository#checkout, but can also be used in called Directory.new or 
+    # File.new directly. See SvnFixture::File for examples.
+    def simple_context
+      ctx = ::Svn::Client::Context.new
+ 
+      # I don't understand the auth_baton and log_baton, so I set them here,
+      # then use revision properties.
+      ctx.add_username_prompt_provider(0) do |cred, realm, username, may_save|
+         cred.username = "ANON"
+      end
+      ctx.set_log_msg_func {|items| [true, ""]}
+      ctx
+    end
+  end
+end
+
+if defined?(Merb::Plugins)
+  # Make config accessible through Merb's Merb::Plugins.config hash
+  Merb::Plugins.config[:svn_fixture] = SvnFixture.config
+end
+
+require 'svn-fixture/repository'
+require 'svn-fixture/revision'
+require 'svn-fixture/directory'
+require 'svn-fixture/file'

data/lib/svn-fixture/directory.rb

@@ -0,0 +1,99 @@
+module SvnFixture
+  # A Directory to be added to or edited within the Repository. Normally, this 
+  # would br done through Directory#dir, in a block given to a Directory or
+  # Revision, for example:
+  #
+  #     SvnFixture.repo('repo_name') do
+  #       revision(1, 'msg') do
+  #         dir('test-dir') do
+  #           prop('name', 'value')
+  #           file('file.txt')
+  #         end
+  #       end
+  #     end
+  #
+  # In that case, Revision takes care of passing the +ctx+ argument.
+  # 
+  # To call SvnFixture::Directory.new directly, you will need to set up a 
+  # context (instance of Svn::Client::Context) and check out a working copy. 
+  # +SvnFixture.simple_context+ is a quick method for settin up a Context.
+  #
+  # Assuming an existing checked out working copy:
+  #
+  #     ctx = SvnFixture.simple_context
+  #     d = SvnFixture::Directory.new(ctx, '/full/fs/path/to/dir')
+  #     d.prop('propname', 'Value')
+  #
+  # Or, call #checkout on Context:
+  #
+  #     ctx = SvnFixture.simple_context
+  #     ctx.checkout('file:///repository/uri', '/fs/path/of/wc')
+  #     d = SvnFixture::Directory.new(ctx, '/fs/path/of/wc/to/dir')
+  #     d.prop('propname', 'Value')
+  class Directory
+    
+    # +new+ is normally called through Directory#dir (a block to a Revision is
+    # applied to the root Directory).
+    #
+    # Arguments are:
+    # - +ctx+: An Svn::Client::Context, normally from Repository#ctx
+    # - +path+: The path (on the file system) of the Directory in the working 
+    #   copy.
+    def initialize(ctx, path)
+      @ctx  = ctx
+      @path = path
+      @path += "/" unless path[-1] == 47
+    end
+    
+    # Create or access a subdirectory. Takes the name of the subdirectory (not a
+    # full path) and an optional block with the subdirectory as self.
+    def dir(name, &block)
+      path = @path + name
+      unless ::File.directory?(path)
+        FileUtils.mkdir_p(path)
+        @ctx.add(path)
+      end
+      d = self.class.new(@ctx, path)
+      d.instance_eval(&block) if block_given?
+      d
+    end
+    
+    # Create or access a subdirectory. Takes the name of the file (not a
+    # full path) and an optional block with the File as self.
+    def file(name, &block)
+      path = @path + name
+      unless ::File.file?(path)
+        FileUtils.touch(path)
+        @ctx.add(path)
+      end
+      f = File.new(@ctx, path)
+      f.instance_eval(&block) if block_given?
+      f
+    end
+    
+    # Move a File or Directory. From should be an existing node. From and to can
+    # be any relative path below the directory.
+    def move(from, to)
+      @ctx.mv(@path + from, @path + to)
+    end
+
+    # Copy a File or Directory. From should be an existing node. From and to can
+    # be any relative path below the directory.
+    def copy(from, to)
+      @ctx.cp(@path + from, @path + to)
+    end
+    
+    # Delete (and remove from Repository) a child node.
+    def delete(name)
+      @ctx.delete(@path + name)
+    end
+    
+    # Set a property for the Directory
+    # (see http://svnbook.red-bean.com/en/1.1/ch07s02.html):
+    # - +name+: The property name (must be "human-readable text")
+    # - +value+: The value of the property.
+    def prop(name, value)
+      @ctx.propset(name, SvnFixture.svn_prop(value), @path[0..-2])
+    end
+  end
+end

data/lib/svn-fixture/file.rb

@@ -0,0 +1,58 @@
+module SvnFixture
+  # A File to be added to or edited within the Repository. Normally, this would 
+  # done through Directory#file, in a block given to a Directory or
+  # Revision, for example:
+  #
+  #     SvnFixture.repo('repo_name') do
+  #       revision(1, 'msg') do
+  #         file('file.txt') do
+  #           prop('name', 'value')
+  #           body('Some Text')
+  #         end
+  #       end
+  #     end
+  #
+  # In that case, Revision takes care of passing the +ctx+ argument.
+  # 
+  # To call SvnFixture::File.new directly, you will need to set up a context
+  # (instance of Svn::Client::Context) and check out a working copy. 
+  # +SvnFixture.simple_context+ is a quick method for settin up a Context.
+  #
+  # Assuming an existing checked out working copy:
+  #
+  #     ctx = SvnFixture.simple_context
+  #     f = SvnFixture::File.new(ctx, '/full/fs/path/to/file.txt')
+  #     f.prop('propname', 'Value')
+  #
+  # Or, call #checkout on Context:
+  #
+  #     ctx = SvnFixture.simple_context
+  #     ctx.checkout('file:///repository/uri', '/fs/path/of/wc')
+  #     f = SvnFixture::File.new(ctx, '/full/fs/path/to/file.txt')
+  #     f.prop('propname', 'Value')
+  class File
+    
+    # +new+ is normally called through Directory#file (a block to a Revision is
+    # applied to the root Directory).
+    #
+    # Arguments are:
+    # - +ctx+: An Svn::Client::Context, normally from Repository#ctx
+    # - +path+: The path (on the file system) of the File in the working copy
+    def initialize(ctx, path)
+      @ctx, @path = ctx, path
+    end
+    
+    # Set a property for the file
+    # (see http://svnbook.red-bean.com/en/1.1/ch07s02.html):
+    # - +name+: The property name (must be "human-readable text")
+    # - +value+: The value of the property.
+    def prop(name, value)
+      @ctx.propset(name, SvnFixture.svn_prop(value), @path)
+    end
+    
+    # Set the content of a file
+    def body(val)
+      ::File.open(@path, 'w') { |f| f.write(val) }
+    end
+  end
+end

data/lib/svn-fixture/repository.rb

@@ -0,0 +1,172 @@
+module SvnFixture
+  # Repository sets up the repository and is reponsible for checkouts and 
+  # the actual commit(s). No actual work is done until +commit+ is called.
+  class Repository   
+    attr_reader :repos, :ctx, :wc_path, :revisions
+    
+    class << self      
+      # Get an SvnFixture::Repository by name. If not found, it creates a new
+      # one. It accepts a block which is evaluated within the Repository
+      # instance. +get+ is useful for re-accessing a Repository after initially 
+      # created. For example:
+      #
+      #     SvnFixture::Repository.get('test') do
+      #       revision(1, 'log msg') ...
+      #     end
+      #     
+      #     SvnFixture::Repository.get('test') do
+      #       revision(2, 'log msg') ...
+      #       revision(3, 'log msg') ...
+      #     end
+      #     
+      #     SvnFixture::Repository.get('test').commit
+      def get(name, repos_path = nil, wc_path = nil, &block)
+        if repositories[name]
+          repositories[name].instance_eval(&block) if block_given?
+          repositories[name]
+        else
+          Repository.new(name, repos_path, wc_path, &block)
+        end
+      end
+      
+      # Hash of {name => Repository} of currently defined Repositories
+      def repositories
+        @repositories ||= {}
+      end
+      
+      # Remove all Repositories from +.repositories+ and delete repos and 
+      # working copy directories. Useful to call upon completion of tests.
+      def destroy_all
+        repositories.each {|name, repo| repo.destroy}
+      end
+    end
+    
+    # Arguments (last two are optional)
+    # - +name+: The name of the repository, used by Repository.get and used in
+    #   +repos_path+ and +wc_path+ if not given.
+    # - +repos_path+: The path where the repository is stored (defaults to
+    #   "#{config[:base_path]}/repo_#{name}"
+    # - +wc_path+: The path where the working copy is checked out (defaults to
+    #   "#{config[:base_path]}/wc_#{name}"
+    # Note: the paths should be normal file system paths, not file:/// paths.
+    #
+    # +new+ also accepts a block which is evaluated within the Repository
+    # instance:
+    #
+    #     SvnFixture::Repository.new('name') do
+    #       revision(1, 'log msg') ...
+    #     end
+    # 
+    # Otherwise, you could, for example:
+    #
+    #     r = SvnFixture::Repository.new('name')
+    #     r.revision(1, 'log msg') do
+    #       ...
+    #     end
+    #     r.commit
+    def initialize(name, repos_path = nil, wc_path = nil, &block)
+      @name = name
+      if self.class.repositories[name]
+        raise RuntimeError, "A Repository with this name (#{@name}) already exists."
+      end
+      
+      @repos_path = repos_path || ::File.join(SvnFixture::config[:base_path], "repo_#{name}")
+      @wc_path    = wc_path    || ::File.join(SvnFixture::config[:base_path], "wc_#{name}")
+      check_paths_available
+      @revisions = []
+      @dirs_created = [] # Keep track of any directories created for use by #destroy
+      self.class.repositories[name] = self
+      self.instance_eval(&block) if block_given?
+    end
+    
+    # Add a Revision to this Repository. +name+ and +msg+ are required.
+    # - +name+: A name (or number of Revision). This is used in informational
+    #   messages only.
+    # - +msg+: Log message for the revision.
+    # - +options+: :author and :date Revision properties.
+    # - Accepts a block that is processed by Revision#commit within a Directory
+    #   instance (the root directory at this revision). See +Directory+ for
+    #   more information.
+    def revision(name, msg, options = {}, &block)
+      r = Revision.new(name, msg, options, &block)
+      @revisions << r
+      r
+    end
+    
+    # Create the Subversion repository. This is called by #checkout unless 
+    # something already exists at @repos_path. It can also be called directly.
+    # This allows the flexibility of doing some work between creating the 
+    # Repository and running checkout or commit (although I've yet to think of
+    # what that work would be), or creating the repository some other way.
+    def create
+      FileUtils.mkdir_p(@repos_path)
+      @dirs_created << @repos_path
+      ::Svn::Repos.create(@repos_path)
+      self
+    end
+
+    # Checkout a working copy, and setup context. This is call by #commit unless
+    # something already exists at @wc_path. It can also be called directly.
+    # This allows the flexibility of doing some work between checking out the 
+    # Repository and commit, or checking out some other way. Also, calls #create
+    # if needed.
+    def checkout
+      create unless ::File.exist?(@repos_path)
+      @repos = ::Svn::Repos.open(@repos_path)
+      FileUtils.mkdir_p(@wc_path)
+      @dirs_created << @wc_path
+      @ctx = SvnFixture::simple_context
+      @ctx.checkout(self.uri, @wc_path)
+      self
+    end
+    
+    # Commit actually commits the changes of the revisions. It optionally 
+    # accepts Revisions or Revision names. If none are given, it commits all
+    # revisions. If any of the arguments are Revisions (not revision names),
+    # they do not need to be explicitly part of this Repository (that is, they
+    # do not need to have been created through self#revision)
+    # 
+    #     repos.commit # Commits all Revisions added through self#revision
+    #     repos.commit(1,2,4) # Commits Revisions named 1, 2, and 4, added through self#revision
+    #     repos.commit(rev1, rev3) # Assuming rev1 and rev3 are instances of
+    #                              # SvnFixture::Revision, commits them
+    #                              # whether or not they were added through self#revision
+    #
+    # A Revision can be added to the revisions Array directly:
+    #
+    #     repos.revisions << Revision.new(1, 'msg')
+    def commit(*to_commit)
+      checkout unless ::File.exist?(@wc_path)
+      to_commit = @revisions if to_commit.empty?
+      to_commit = [to_commit] if (!to_commit.respond_to?(:each) || to_commit.kind_of?(String))
+      
+      to_commit.each do | rev |
+        rev = @revisions.find{ |r| r.name == rev } unless rev.kind_of?(Revision)
+        rev.commit(self)
+      end
+    end
+    
+    # Remove Repository from +.repositories+ and delete repos and working copy
+    # directories.
+    def destroy
+      @dirs_created.each { |d| FileUtils.rm_rf(d) }
+      self.class.repositories.delete(@name)
+    end
+    
+    # URI (file://...) for accessing the Repository
+    def uri
+      "file://" + ::File.expand_path(@repos_path)
+    end
+    
+    private
+
+    # Check if either @repos_path or @wc_path exist. Called by #initialize.
+    def check_paths_available
+      if ::File.exist?(@repos_path)
+        raise RuntimeError, "repos_path already exists (#{@repos_path})"
+      elsif ::File.exist?(@wc_path)
+        raise RuntimeError, "wc_path already exists (#{@wc_path})"
+      end
+    end
+  end
+end