darcs-ruby 0.0.1

data/Rakefile

@@ -0,0 +1,51 @@
+
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+
+PRG_VERSION = '0.0.1'
+PRG_TEST_FILES = FileList['test/**/*_test.rb']
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.test_files = PRG_TEST_FILES
+  t.verbose = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'doc'
+  rdoc.title    = "Ruby Darcs -- Ruby interface to Darcs change control"
+  rdoc.options << '--line-numbers --inline-source'
+  rdoc.rdoc_files.include("lib/**/*.rb")
+end
+
+gem_spec = Gem::Specification.new do |s|
+  s.platform 	= Gem::Platform::RUBY
+  s.name        = 'darcs-ruby'
+  s.summary     = "Interface to Darcs change control system"
+  s.version     = PRG_VERSION
+  s.author      = "Jason M. Felice"
+  s.email       = "jfelice@cronosys.com"
+  s.homepage    = "http://eraserhead.net/darcs/darcs-ruby/doc/"
+  s.has_rdoc    = true
+  s.files       = FileList["lib/**/*", "test/**/*", "Rakefile", "bin/*"]
+  s.test_files  = PRG_TEST_FILES
+  s.bindir      = 'bin'
+  s.executables = [ 'darcs-import' ]
+end
+
+Rake::GemPackageTask.new(gem_spec) do |p|
+  p.need_tar    = true
+  p.need_zip    = true
+end
+
+task :install => :package do
+  sh 'gem install ./pkg/darcs-ruby-0.0.1.gem'
+end
+
+# vi:set sts=2 sw=2 ai et:

data/bin/darcs-import

@@ -0,0 +1,72 @@
+#!/usr/bin/ruby
+#
+# = darcs-import
+#
+# Script to start a large repository from a source tree.  This script takes
+# shortcuts because darcs' apparent run time for recording patches is O(n^2)
+#
+
+# Enable us to run from the source tree
+$:.push(File.join(File.dirname(File.dirname(__FILE__)),'lib'))
+
+require 'rubygems'
+require 'darcs/repository'
+require 'darcs/patchinfo'
+require 'darcs/patchwriter'
+require 'find'
+
+include Darcs
+
+repo = Repository.find
+if repo.nil?
+  system 'darcs initialize'
+  repo = Repository.find
+elsif repo.patches.count > 0
+  raise "Must be used on an empty repository!"
+end
+
+raise "Set $EMAIL first!" if !ENV['EMAIL']
+patch_info = PatchInfo.new(Time.now, 'Initial import', ENV['EMAIL'])
+repo.write_patch(patch_info) do |writer|
+  Find.find('.') do |entry|
+    next if entry == '.'
+    next if repo.boring?(entry)
+    Find.prune if !FileTest.directory?(entry)
+    writer << Chunk::AddDirectory.new(entry)
+    dstdir = File.join(repo.path,'_darcs','current',entry)
+    Dir.mkdir(dstdir)
+  end
+  Find.find('.') do |entry|
+    next if repo.boring?(entry)
+    if !FileTest.directory?(entry)
+      writer << Chunk::AddFile.new(entry)
+      dstfile = File.join(repo.path,'_darcs','current',entry)
+      File.open(entry, 'r') do |f|
+	File.open(dstfile,'w') do |d|
+          if repo.binary?(entry)
+            f.binmode
+            contents = f.read
+            writer << Chunk::Binary.new(entry, '', contents)
+            d.write(contents)
+          else
+	    data = f.read
+	    d.write(data)
+	    if data == "\n"
+	      hunk = "+\n"
+	    elsif data.size > 0 && data[-1..-1] != "\n"
+	      hunk = "-\n" + data.split("\n",-1).map{|line| '+' + line}.join("\n") + "\n"
+	    else
+	      hunk = data[0..-2].split("\n",-1).map{|line| '+' + line}.join("\n") + "\n"
+	    end
+            writer << Chunk::Hunk.new(entry, 1, hunk)
+          end
+	end
+      end
+      File.utime(0, File.mtime(entry), dstfile)
+    end
+  end
+
+end
+
+system "cp _darcs/patches/#{patch_info.filename} /tmp/foo.gz"
+

data/lib/darcs/patchinfo.rb

@@ -0,0 +1,78 @@
+
+require 'sha1'
+
+module Darcs
+
+  # This class holds the patch's name, log, author, date, and other
+  # meta-info.
+  class PatchInfo
+    def initialize(date, name, author, log = nil, inverted = false)
+      if date.kind_of?(String)
+        @date = parse_date(date)
+      else
+        @date = date
+      end
+      @name = name
+      @author = author
+      @log = log
+      @inverted = inverted
+    end
+
+    attr_reader :date, :name, :author, :log
+    def inverted?
+      @inverted
+    end
+
+    # Reads a patch from a stream using the inventory format
+    def self.read(f)
+      line = f.gets
+      return nil if line.nil?
+      if line[0..0] != '['
+        raise "Invalid inventory entry (starts with \"#{line[0..-2]}\")"
+      end
+
+      name = line[1..-2]
+      line = f.readline
+      raise "Invalid inventory entry" if !line[/^(.*)\*\*([0-9]{14})\]?\s*$/]
+      author = $1
+      date = $2
+      log = nil
+      if !line[/\]\s*$/]
+        log = ""
+        log += line[1..-1] while !((line = f.readline) =~ /^\]/)
+      end
+
+      return self.new(date, name, author, log)
+    end
+
+    # Retrieve the patch's date in string timestamp format
+    def timestamp
+      date.strftime("%Y%m%d%H%M%S") 
+    end
+
+    # Retrieve the patch's name
+    def filename
+      author_hash = SHA1.new(author).to_s[0..4]
+      hash = SHA1.new(name + author + timestamp +
+                      (log.nil? ? '' : log.gsub(/\n/, '')) +
+                      (inverted? ? 't' : 'f'))
+      "#{timestamp}-#{author_hash}-#{hash}.gz"
+    end
+
+    def to_s
+      if log
+        the_log = log.gsub(/[\n\s]+$/, '').gsub(/\n/, "\n ")
+      end
+      "[#{name}\n#{author}**#{timestamp}" +
+      (log.nil? ? '' : "\n " + the_log + "\n") + "]"
+    end
+
+  protected
+    def parse_date(str)
+      # Format is YYYYMMDDHHMMSS
+      Time.gm(str[0..3].to_i, str[4..5].to_i, str[6..7].to_i, str[8..9].to_i,
+              str[10..11].to_i, str[12..13].to_i)
+    end
+  end
+
+end

data/lib/darcs/patchwriter.rb

@@ -0,0 +1,138 @@
+
+require 'zlib'
+
+module Darcs
+  
+  # A PatchWriter is used to write PatchChunks into a patch.
+  class PatchWriter
+    
+    # Create a new PatchWriter for writing the patch file associated with the
+    # given patch object
+    def initialize(patch)
+      @patch = patch
+      @file = File.open(patch.filename, 'w')
+      @gz = Zlib::GzipWriter.new(@file)
+      @gz.write(patch.info.to_s + " {\n")
+    end
+
+    attr_reader :patch
+
+    # Finishes writing the patch and close files
+    def finish
+      @gz.write("}\n")
+      @gz.close
+    end
+
+    # Closes files and deletes the patch file
+    def abort
+      begin
+        @gz.close
+      rescue
+      end
+      begin
+        File.delete(patch.filename)
+      rescue
+      end
+    end
+
+    # Writes a patch chunk to the file
+    def << (chunk)
+      chunk.write(@gz, patch)
+    end
+
+  end
+
+  module Chunk
+
+    # Base class for other chunks
+    class Base
+    end
+    
+    # Chunk representing the addition of a directory to a repository
+    class AddDirectory <Base
+      def initialize(path)
+        @path = path
+      end
+
+      attr_reader :path
+
+      def write(io, patch)
+        io.write("adddir #{path}\n")
+      end
+    end
+
+    # Chunk which adds record of a file to the repository.  The file contents
+    # are not a part of this; those must be added separately with Chunk::Hunk
+    # or Chunk::Binary.
+    class AddFile <Base
+      def initialize(path)
+        @path = path
+      end
+
+      attr_reader :path
+
+      def write(io, patch)
+        io.write("addfile #{path}\n")
+      end
+    end
+
+    # Chunk which makes a modification to a text file.  If the file is binary,
+    # you will need to use Darcs::Chunk::Binary instead
+    #
+    # FIXME: We should create aggregate chunks to do a lot of the foot work
+    # for diffing, what not.  An AddFileWithData chunk, A DiffFile chunk,
+    # whatnot.  Or maybe a different method will present itself?
+    #
+    class Hunk <Base
+      # Creates a new hunk chunk for the specified file and line.
+      def initialize(path, line, data)
+        @path = path
+        @line = line
+        @data = data
+      end
+
+      attr_reader :path, :line, :data
+
+      def write(io, patch)
+        io.write("hunk #{path} #{line}\n#{data}")
+      end
+    end
+
+    # Chunk which replaces a binary file's contents
+    class Binary <Base
+
+      ENCODED_LINE_LENGTH = 78 
+
+      # Creates a new Binary chunk.  Old and new data are in their binary
+      # (non-encoded) form.
+      def initialize(path, old, new)
+        @path = path
+        @old = old
+        @new = new
+      end
+
+      attr_reader :path, :old, :new
+
+      def write(io, patch)
+        io.write("binary #{path}\noldhex\n#{hex_encode old}newhex\n#{hex_encode new}")
+      end
+
+    private
+      def chunk(data, size)
+        block_max = (data.size - 1) / size
+        (0..block_max).map do |chunk_number|
+          data[(chunk_number * size)...((chunk_number + 1) * size)]
+        end
+      end
+
+      def hex_encode(data)
+        return '' if data.size == 0
+        chunk(data, ENCODED_LINE_LENGTH / 2).map do |this_chunk|
+          '*' + this_chunk.unpack('H*').first + "\n"
+        end.join
+      end
+
+    end
+
+  end
+end

data/lib/darcs/repository.rb

@@ -0,0 +1,129 @@
+
+require 'darcs/patchwriter'
+
+module Darcs
+
+  class Repository
+
+    attr_reader :path
+    
+    def initialize(path)
+      @path = path
+      @prefs_regexps = {}
+    end
+
+    # Finds the repository we are in.  Returns nil if we are not in a
+    # repository
+    def self.find
+      path = Dir.getwd
+      while !repository?(path)
+        return nil if File.dirname(path) == path
+        path = File.dirname(path)
+      end
+      self.new(path)
+    end
+
+    # Determines whether the specified path is a repository
+    def self.repository?(path)
+      FileTest.directory?(File.join(path, '_darcs', 'patches')) &&
+        FileTest.exists?(File.join(path, '_darcs', 'inventory'))
+    end
+
+    def patches
+      if @patches.nil?
+        @patches = []
+        pi = nil
+        File.open(inventory_file, 'r') do |f|
+          @patches << Patch.new(self, pi) while pi = PatchInfo.read(f)
+        end
+      end
+      @patches
+    end
+
+    def inventory_file
+      File.join(path, '_darcs', 'inventory')
+    end
+
+    # Determines whether this file a binary file according to the patterns
+    # found in _darcs/prefs/binaries.
+    def binary?(name)
+      prefs_regexp_file_matches(name, 'binaries') 
+    end
+
+    # Determines whether this file a boring file according to the patterns
+    # found in _darcs/prefs/boring.
+    def boring?(name)
+      prefs_regexp_file_matches(name, 'boring')
+    end
+
+    def write_patch(patch_info)
+      patch = Patch.new(self, patch_info)
+      patch.write do |writer|
+        yield writer
+      end
+    end
+
+  protected
+    def prefs_regexp_file_matches(str, filename)
+      prefs_regexp(filename).match(str)
+    end
+
+    # Constructs a compound regular expression from the lines of a file in
+    # the 'prefs' directory which contains one expression per line, except
+    # for comment lines which start with '#'.  The regular expression is
+    # cached so it is not recomputed every time.
+    def prefs_regexp(filename)
+      if @prefs_regexps[filename].nil?
+        fpath = File.join(path, '_darcs', 'prefs', filename)
+        @prefs_regexps[filename] = Regexp.new('(' +
+          IO.readlines(fpath).delete_if {|l|
+            l[0..0] == '#'
+          }.map {|l|
+            (l[-1..-1] == "\n") ? l[0..-2] : l
+          }.join('|') + ')'
+        )
+      end
+      @prefs_regexps[filename]
+    end
+
+  end
+
+  # A Patch is the full representation of a patch file in a repository
+  # (PatchInfo is simply the inventory information).
+  #
+  # Patch acts as an aggregate of PatchInfo
+  class Patch
+
+    attr_accessor :repository, :info
+
+    def initialize(repository, info)
+      @repository = repository
+      @info = info
+    end
+
+    def method_missing(*args)
+      info.send(*args)
+    end
+
+    # Retrieves the full path to the patch file
+    def filename
+      File.join(repository.path,'_darcs','patches',info.filename)
+    end
+
+    def write
+      patch_writer = PatchWriter.new(self)
+      begin
+        yield patch_writer
+        patch_writer.finish
+        File.open(repository.inventory_file, 'a') do |inv|
+          inv.write(info.to_s + "\n")
+        end
+      rescue
+        patch_writer.abort
+        raise $!
+      end
+    end
+
+  end
+
+end

data/test/darcs-import_test.rb

@@ -0,0 +1,39 @@
+
+require 'test/unit'
+require 'test_helper'
+
+class DarcsImportTestCase < Test::Unit::TestCase
+
+  include TestHelper
+
+  def test_import
+    exe = File.join(File.dirname(File.dirname(File.expand_path(__FILE__))),
+                    'bin', 'darcs-import')
+
+    TestDir.with do |td|
+      td.play <<EOF
+echo "Hello, World" >test.gif
+mkdir foo
+printf 'no newline' >foo/bar.txt
+printf 'two newlines at end\\n\\n' >foo/bar2.txt
+printf '\\n' >foo/bar3.txt
+mkdir foo/bar
+mkdir baz
+echo "File 2">baz/slime.txt
+EMAIL='Joe Fabetes <joe@example.com>' ruby #{exe} 2>&1
+darcs check
+EOF
+      assert(/No changes/.match(`darcs whatsnew -s`),
+             "Changes found!")
+      output = `darcs changes -s`
+      assert(/A \.\/test\.gif/.match(output))
+      assert(/A \.\/foo\//.match(output))
+      assert(/A \.\/foo\/bar\.txt/.match(output))
+      assert(/A \.\/foo\/bar\//.match(output))
+      assert(/A \.\/baz\//.match(output))
+      assert(/A \.\/baz\/slime\.txt/.match(output))
+    end
+  end
+
+end
+

data/test/patchinfo_test.rb

@@ -0,0 +1,53 @@
+
+require 'darcs/patchinfo'
+require 'test/unit'
+
+class PatchInfoTestCase < Test::Unit::TestCase
+
+  def test_initialize
+    pi = Darcs::PatchInfo.new('20051220115522', 'Test patch',
+                              'Joe Fabetes <joe@example.com>')
+
+    assert_kind_of Darcs::PatchInfo, pi
+    assert_equal 'Test patch', pi.name
+    assert_equal 'Joe Fabetes <joe@example.com>', pi.author
+    assert !pi.inverted?
+
+    assert_kind_of Time, pi.date
+    assert_equal 2005, pi.date.year
+    assert_equal 12, pi.date.month
+    assert_equal 20, pi.date.day
+    assert_equal 11, pi.date.hour
+    assert_equal 55, pi.date.min
+    assert_equal 22, pi.date.sec
+  end
+
+  def test_filename
+    pi = Darcs::PatchInfo.new('20051220170424', 'Rakefile, directories',
+                              'Jason M. Felice <jfelice@cronosys.com>')
+    assert_equal '20051220170424-e0cd7-00d5859bbcf77c9b726e7c4fd6fb8a536cd3cfcd.gz', pi.filename
+  end
+
+  def test_to_s
+    pi = Darcs::PatchInfo.new('20051220170424', 'Rakefile, directories',
+                              'Jason M. Felice <jfelice@cronosys.com>')
+    assert_equal "[Rakefile, directories\nJason M. Felice <jfelice@cronosys.com>**20051220170424]", pi.to_s
+
+    pi = Darcs::PatchInfo.new('20051220170424', 'Rakefile, directories',
+                              'Jason M. Felice <jfelice@cronosys.com>',
+"And here is
+a test log
+message."
+)
+
+    expect = "[Rakefile, directories
+Jason M. Felice <jfelice@cronosys.com>**20051220170424
+ And here is
+ a test log
+ message.
+]"
+    assert_equal expect, pi.to_s
+  end
+
+end
+

data/test/patchwriter_test.rb

@@ -0,0 +1,86 @@
+
+require 'darcs/patchinfo'
+require 'darcs/repository'
+require 'darcs/patchwriter'
+require 'test/unit'
+require 'test_helper'
+
+# Make some things accessible so we can unit test them
+module Darcs
+  module Chunk
+    class Binary
+      def public_chunk(*args); chunk(*args); end
+      def public_hex_encode(*args); hex_encode(*args); end
+    end
+  end
+end
+
+class PatchWriterTestCase < Test::Unit::TestCase
+
+  include TestHelper
+
+  def test_new
+    TestDir.with do |td|
+      td.play <<EOF
+darcs initialize
+mkdir foo_dir
+echo "Hello, World!"> foo_file
+echo "Hello, World!"> bar_file
+EOF
+      
+      repo = Darcs::Repository.new(td.path)
+      patch_info = Darcs::PatchInfo.new(Time.now, 'Test Patch',
+                                        'joe@example.com')
+      repo.write_patch(patch_info) do |writer|
+
+        assert_kind_of Darcs::PatchWriter, writer
+        assert_kind_of Darcs::Patch, writer.patch
+        assert_equal patch_info, writer.patch.info
+
+        writer << Darcs::Chunk::AddDirectory.new('./foo_dir')
+        writer << Darcs::Chunk::AddFile.new('./foo_file')
+        writer << Darcs::Chunk::Hunk.new('./foo_file', 1, "+Hello, World!\n")
+        writer << Darcs::Chunk::AddFile.new('./bar_file')
+        writer << Darcs::Chunk::Binary.new('./bar_file', "", "Hello, World!\n")
+      end
+
+      # We just recorded a patch, we didn't apply it, so...
+      td.play <<EOF
+mkdir _darcs/current/foo_dir
+echo 'Hello, World!'> _darcs/current/foo_file
+echo 'Hello, World!'> _darcs/current/bar_file
+EOF
+
+      plist = repo.patches
+      assert_equal 1, plist.size
+      assert_equal 'Test Patch', plist[0].name
+      assert_equal 'joe@example.com', plist[0].author
+      assert FileTest.exists?(plist[0].filename)
+
+      # Check repo consistency
+      td.play "darcs check"
+
+      # Verify that darcs can read it
+      output = `darcs changes -s`
+      assert(/  joe@example.com\n  \* Test Patch\n$/.match(output))
+      assert(/A \.\/foo_dir\//.match(output))
+      assert(/A \.\/foo_file/.match(output))
+      assert(/A \.\/bar_file/.match(output))
+
+      output = `darcs whatsnew`
+      assert(/No changes/.match(output),
+             "darcs is seeing changes!:\n#{output}")
+    end
+  end
+
+  def test_binary_hex_encode
+    binary_chunk = Darcs::Chunk::Binary.new('foo', '', 'baz')
+
+    assert_equal [ '1234567890', '12345' ],
+                 binary_chunk.public_chunk('123456789012345', 10)
+
+    assert_equal "*313233343536373839\n",
+                 binary_chunk.public_hex_encode('123456789')
+  end
+
+end

data/test/repository_test.rb

@@ -0,0 +1,96 @@
+
+require 'test/unit'
+require 'darcs/repository'
+require 'darcs/patchinfo'
+require 'find'
+require 'test_helper'
+require 'tempfile'
+
+class RepostioryTestCase < Test::Unit::TestCase
+
+  include TestHelper
+
+  def test_create
+    repo = Darcs::Repository.new('/tmp')
+    assert_kind_of Darcs::Repository, repo
+    assert_equal '/tmp', repo.path
+  end
+
+  def test_patches
+    TestDir.with do |td|
+      tf = Tempfile.new('test')
+      File.open(tf.path, 'w') do |f|
+        f.write("Test patch 3\nHere is log line 1\nHere is log line 2\nend\n")
+      end
+      td.play <<EOF
+darcs initialize
+echo 'this is foo' >> foo.txt
+darcs add foo.txt
+darcs record -a -A 'Joe Fabetes <joe@example.com>' -m 'Test patch 1'
+echo 'hi' >> bar.txt
+darcs add bar.txt
+darcs record -a -A 'Joe Fabetes <joe@example.com>' -m 'Test patch 2'
+echo 'bazfile' >> baz.txt
+darcs add baz.txt
+darcs record -a -A 'Joe Fabetes <joe@example.com>' --logfile #{tf.path}
+EOF
+      repo = Darcs::Repository.new(td.path)
+      patches = repo.patches
+
+      assert_equal 3, patches.size
+      patches.each do |patch|
+        assert_kind_of Darcs::Patch, patch
+        assert_equal 'Joe Fabetes <joe@example.com>', patch.author
+        assert FileTest.exists?(patch.filename),
+               "patch.filename isn't valid."
+      end
+      assert_equal "Test patch 3", patches[2].name
+    end
+  end
+
+  def test_repository?
+    TestDir.with do |td|
+      td.play "darcs initialize"
+
+      assert Darcs::Repository.repository?(td.path)
+      assert !Darcs::Repository.repository?('/tmp')
+    end
+  end
+
+  def test_find
+    TestDir.with do |td|
+      td.play "darcs initialize"
+
+      repo = Darcs::Repository.find
+      assert_kind_of Darcs::Repository, repo
+      assert_equal td.path, repo.path
+
+      Dir.mkdir('foo')
+      td.play "darcs add foo"
+      Dir.chdir('foo')
+
+      repo = Darcs::Repository.find
+      assert_kind_of Darcs::Repository, repo
+      assert_equal td.path, repo.path
+
+      Dir.chdir('/tmp')
+      repo = Darcs::Repository.find
+      assert_equal nil, repo
+    end
+  end
+
+  def test_boring_and_binary
+    TestDir.with do |td|
+      td.play "darcs initialize"
+
+      repo = Darcs::Repository.find
+
+      assert repo.boring?('./foo/CVS/Shucks'), "CVS files are not boring!"
+      assert repo.binary?('./foo.jpg'), "JPEG files are not binary!"
+      assert !repo.boring?('./foo.c'), "C files are boring?!"
+      assert !repo.binary?('./foo.pl'), "Perl files are binary? (Well, close..)"
+
+    end
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,72 @@
+
+module TestHelper
+
+  # Utility class for tests to work with a temporary directory, play commands
+  # in it, automatically clean up files, etc.
+  #
+  # Use like so:
+  #
+  #   TestHelper::TestDir.with do |td|
+  #     td.play <<EOF
+  #   echo hi >>foo.txt
+  #   touch bar.txt
+  #   EOF
+  #   end
+  #
+  class TestDir
+
+    def initialize
+      @path = "/tmp/rdarcs_#{$$}_#{rand(100000)}"
+      Dir.mkdir(@path)
+    end
+
+    attr_reader :path
+
+    def in
+      old_path = Dir.getwd
+      Dir.chdir(path)
+      begin
+        yield
+      ensure
+        Dir.chdir(old_path)
+      end
+    end
+    
+    # Retrieves this temporary directory's path
+    def play (script)
+      script.split(/\n/).each do |cmd|
+        output = `#{cmd}`
+        raise "#{cmd} -> #{output} (error_code = #{$?})" if $? != 0
+      end
+    end
+    
+    # Removes the directory and all files and sub-directories in it
+    def delete
+      directories = []
+      Find.find(path) do |ent|
+        if FileTest.directory?(ent)
+          directories << ent
+        else
+          File.unlink(ent)
+        end
+      end
+      directories.sort{|a, b| b.size <=> a.size}.each do |dir|
+        Dir.rmdir(dir)
+      end
+    end
+
+    # Creates a new temporary directory, runs a block of code in it, and 
+    # cleans up afterward.
+    def self.with
+      repo = self.new
+      begin
+        repo.in do
+          yield repo
+        end
+      ensure
+        repo.delete
+      end
+    end
+  end
+
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: darcs-ruby
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2005-12-22 00:00:00 -05:00
+summary: Interface to Darcs change control system
+require_paths: 
+  - lib
+email: jfelice@cronosys.com
+homepage: http://eraserhead.net/darcs/darcs-ruby/doc/
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+  - Jason M. Felice
+files: 
+  - lib/darcs
+  - lib/darcs/repository.rb
+  - lib/darcs/patchinfo.rb
+  - lib/darcs/patchwriter.rb
+  - test/test_helper.rb
+  - test/patchwriter_test.rb
+  - test/repository_test.rb
+  - test/patchinfo_test.rb
+  - test/darcs-import_test.rb
+  - Rakefile
+  - bin/darcs-import
+test_files: 
+  - test/patchwriter_test.rb
+  - test/repository_test.rb
+  - test/patchinfo_test.rb
+  - test/darcs-import_test.rb
+rdoc_options: []
+extra_rdoc_files: []
+executables: 
+  - darcs-import
+extensions: []
+requirements: []
+dependencies: []