multi_git 0.0.1.alpha1

data/lib/multi_git/jgit_backend/repository.rb

@@ -0,0 +1,223 @@
+require 'multi_git/repository'
+require 'multi_git/tree_entry'
+require 'multi_git/jgit_backend/blob'
+require 'multi_git/jgit_backend/tree'
+require 'multi_git/jgit_backend/commit'
+require 'multi_git/jgit_backend/ref'
+module MultiGit::JGitBackend
+  class Repository < MultiGit::Repository
+
+    extend Forwardable
+
+  private
+    OBJECT_CLASSES = {
+      :blob => Blob,
+      :tree => Tree,
+      :commit => Commit
+    }
+
+    # These IDs are magic numbers
+    # from the Jgit code:
+    OBJECT_TYPE_IDS = {
+      :commit => 1,
+      :tree => 2,
+      :blob => 3,
+      :tag => 4
+    }
+
+    REVERSE_OBJECT_TYPE_IDS = Hash[ OBJECT_TYPE_IDS.map{|k,v| [v,k]} ]
+  public
+
+    delegate "bare?" => "@git"
+
+    def git_dir
+      @git.getDirectory.to_s
+    end
+
+    def git_work_tree
+      bare? ? nil : @git.getWorkTree.to_s
+    end
+
+    def initialize(path, options = {})
+      options = initialize_options(path,options)
+      builder = Java::OrgEclipseJgitStorageFile::FileRepositoryBuilder.new
+      builder.setGitDir(Java::JavaIO::File.new(options[:repository]))
+      if options[:working_directory]
+        builder.setWorkTree(Java::JavaIO::File.new(options[:working_directory]))
+      end
+      if options[:index]
+        builder.setIndexFile(Java::JavaIO::File.new(options[:index]))
+      end
+      @git = builder.build
+      if !@git.getObjectDatabase().exists
+        if options[:init]
+          @git.create(!!options[:bare])
+        else
+          raise MultiGit::Error::NotARepository, path
+        end
+      end
+      verify_bareness(path, options)
+    end
+
+    # {include:MultiGit::Repository#write}
+    # @param (see MultiGit::Repository#write)
+    # @raise (see MultiGit::Repository#write)
+    # @return (see MultiGit::Repository#write)
+    def write(content, type = :blob)
+      if content.kind_of? MultiGit::Builder
+        return content >> self
+      end
+      validate_type(type)
+      if content.kind_of? MultiGit::Object
+        if include?(content.oid)
+          return read(content.oid)
+        end
+        content = content.to_io
+      end
+      use_inserter do |inserter|
+        begin
+          t_id = OBJECT_TYPE_IDS[type]
+          reader = nil
+          if content.respond_to? :path
+            path = content.path
+            reader = Java::JavaIO::FileInputStream.new(path)
+            oid = inserter.insert(t_id.to_java(:int), ::File.size(content.path).to_java(:long), reader)
+          else
+            content = content.read if content.respond_to? :read
+            oid = inserter.insert(t_id, content.bytes.to_a.to_java(:byte))
+          end
+          return OBJECT_CLASSES[type].new(self, oid)
+        ensure
+          reader.close if reader
+        end
+      end
+    end
+
+    # {include:MultiGit::Repository#read}
+    # @param (see MultiGit::Repository#read)
+    # @raise (see MultiGit::Repository#read)
+    # @return (see MultiGit::Repository#read)
+    def read(read)
+      java_oid = parse_java(read)
+      object = use_reader{|rdr| rdr.open(java_oid) }
+      type = REVERSE_OBJECT_TYPE_IDS.fetch(object.getType)
+      return OBJECT_CLASSES[type].new(self, java_oid, object)
+    end
+
+    # {include:MultiGit::Repository#ref}
+    # @param (see MultiGit::Repository#ref)
+    # @raise (see MultiGit::Repository#ref)
+    # @return (see MultiGit::Repository#ref)
+    def ref(name)
+      Ref.new(self, name)
+    end
+
+    # @visibility private
+    # @api private
+    def make_tree(entries)
+      fmt = Java::OrgEclipseJgitLib::TreeFormatter.new
+      # git mktree and rugged tree builder sort entries by name
+      # jgit tree builder doesn't
+      entries.sort_by{|name, _, _| name }.each do |name, mode, oid|
+        fmt.append(name,
+                   Java::OrgEclipseJgitLib::FileMode.fromBits(mode),
+                   Java::OrgEclipseJgitLib::ObjectId.fromString(oid))
+      end
+      use_inserter do |ins|
+        oid = fmt.insertTo(ins)
+        return read(oid)
+      end
+    end
+
+    # @visibility private
+    # @api private
+    def make_commit(commit)
+      bld = Java::OrgEclipseJgitLib::CommitBuilder.new
+      commit[:parents].each do |p|
+        bld.addParentId(oid_to_java p)
+      end
+      bld.setTreeId(oid_to_java commit[:tree])
+      bld.setMessage(commit[:message])
+      bld.setCommitter(person_ident(commit[:committer], commit[:commit_time]))
+      bld.setAuthor(person_ident(commit[:author], commit[:time]))
+      read( use_inserter{|i| i.insert(bld) } )
+    end
+
+    def oid_to_java(oid)
+      Java::OrgEclipseJgitLib::ObjectId.fromString(oid)
+    end
+
+    def person_ident(handle, time)
+      tj = time.to_java(Java::OrgJodaTime::DateTime)
+      Java::OrgEclipseJgitLib::PersonIdent.new(
+        handle.name,
+        handle.email,
+        tj.toDate,
+        tj.getZone.toTimeZone)
+    end
+
+    private :person_ident, :oid_to_java
+
+    # {include:MultiGit::Repository#include?}
+    # @param (see MultiGit::Repository#include?)
+    # @raise (see MultiGit::Repository#include?)
+    # @return (see MultiGit::Repository#include?)
+    def include?(oid)
+      @git.hasObject(Java::OrgEclipseJgitLib::ObjectId.fromString(oid))
+    end
+
+    # {include:MultiGit::Repository#parse}
+    # @param (see MultiGit::Repository#parse)
+    # @raise (see MultiGit::Repository#parse)
+    # @return (see MultiGit::Repository#parse)
+    def parse(ref)
+      return Java::OrgEclipseJgitLib::ObjectId.toString(parse_java(ref))
+    end
+
+    # @visibility private
+    # @api private
+    def parse_java(oidish)
+      return oidish if oidish.kind_of? Java::OrgEclipseJgitLib::AnyObjectId
+      begin
+        oid = @git.resolve(oidish)
+        if oid.nil?
+          raise MultiGit::Error::InvalidReference, oidish
+        end
+        return oid
+      rescue Java::OrgEclipseJgitErrors::AmbiguousObjectException => e
+        raise MultiGit::Error::AmbiguousReference, e
+      rescue Java::OrgEclipseJgitErrors::RevisionSyntaxException => e
+        raise MultiGit::Error::BadRevisionSyntax, e
+      end
+    end
+
+    # @visibility private
+    # @api private
+    def use_reader
+      begin
+        rdr = @git.getObjectDatabase.newReader
+        result = yield rdr
+      ensure
+        rdr.release if rdr
+      end
+    end
+
+    # @visibility private
+    # @api private
+    def use_inserter
+      begin
+        rdr = @git.getObjectDatabase.newInserter
+        result = yield rdr
+      ensure
+        rdr.release if rdr
+      end
+    end
+
+    # @visibility private
+    # @api private
+    def __backend__
+      @git
+    end
+
+  end
+end

data/lib/multi_git/jgit_backend/rewindeable_io.rb

@@ -0,0 +1,33 @@
+# A IO subclass that implements
+# rewind for java streams with mark set.
+#
+# @note This is a Hack
+# @note Remember to mark the stream before you build this.
+# @api private
+class MultiGit::JGitBackend::RewindeableIO < IO
+  import "org.jruby.RubyIO"
+  import "org.jruby.util.io.OpenFile"
+  import "org.jruby.util.io.ChannelStream"
+  import "org.jruby.util.io.ChannelDescriptor"
+  import "java.nio.channels.Channels"
+  def self.new(inputStream)
+    jruby_io = RubyIO.new(JRuby.runtime, self)
+    jruby_io.openFile.setMainStream(
+       ChannelStream.open(
+         JRuby.runtime,
+         ChannelDescriptor.new(
+           Channels.newChannel(inputStream)
+         )
+       )
+     )
+    jruby_io.openFile.setMode(OpenFile::READABLE)
+    io = JRuby.dereference(jruby_io)
+    io.instance_variable_set(:@backend, inputStream)
+    return io
+  end
+
+  def rewind
+    @backend.reset
+  end
+end
+

data/lib/multi_git/jgit_backend/tree.rb

@@ -0,0 +1,28 @@
+require 'multi_git/tree'
+require 'multi_git/jgit_backend/object'
+module MultiGit::JGitBackend
+
+  class Tree < Object
+
+    EMPTY_BYTES = [].to_java :byte
+
+    import 'org.eclipse.jgit.treewalk.CanonicalTreeParser'
+
+    include MultiGit::Tree
+
+    def raw_entries
+      return @raw_entries if @raw_entries
+      repository.use_reader do |reader|
+        entries = []
+        it = CanonicalTreeParser.new(EMPTY_BYTES, reader, java_oid)
+        until it.eof
+          mode = it.getEntryRawMode
+          entries << [it.getEntryPathString, mode, ObjectId.toString(it.getEntryObjectId)]
+          it.next
+        end
+        @raw_entries = entries
+      end
+      return @raw_entries
+    end
+  end
+end

data/lib/multi_git/jgit_backend.rb

@@ -0,0 +1,15 @@
+module MultiGit
+  module JGitBackend
+    class << self
+
+      def load!
+      end
+
+      def open(path, options = {})
+        Repository.new(path, options)
+      end
+
+    end
+  end
+end
+require 'multi_git/jgit_backend/repository'

data/lib/multi_git/object.rb

@@ -0,0 +1,59 @@
+require 'multi_git/utils'
+module MultiGit
+
+  # This is a base-module for all objects.
+  module Object
+
+    extend Utils::AbstractMethods
+
+    # @return [Repository]
+    attr :repository
+
+    # @return [String]
+    attr :oid
+
+    # @visibility private
+    def hash
+      oid.hash
+    end
+
+    # @visibility private
+    def ==(other)
+      if other.respond_to? :oid
+        return oid == other.oid
+      end
+      return false
+    end
+
+    alias eql? ==
+
+    # @visibility private
+    def inspect
+      ['#<', self.class.name,' ', oid, '>'].join
+    end
+
+    # @!method to_builder
+    #   @abstract
+    #   Creates a builder which contains everything this object contains.
+    #   @return [MultiGit::Builder] a builder
+    abstract :to_builder
+
+    # @!method content
+    #   @abstract
+    #   Returns an String containing the content of this object.
+    #   @return [String]
+    abstract :content
+
+    # @!method to_io
+    #   @abstract
+    #   Returns an IO with the content of this object.
+    #   @return [IO]
+    abstract :to_io
+
+    # @!method bytesize
+    #   @abstract
+    #   @return [Integer] size in bytes
+    abstract :bytesize
+
+  end
+end