multi_git 0.0.1.alpha1

data/lib/multi_git/git_backend/commit.rb

@@ -0,0 +1,75 @@
+require 'multi_git/git_backend/object'
+require 'multi_git/commit'
+module MultiGit
+  module GitBackend
+    class Commit < Object
+      include MultiGit::Commit
+
+      def parents
+        read!
+        @parents ||= @parent_oids.map{|oid| repository.read(oid) }
+      end
+
+      def tree
+        read!
+        @tree ||= repository.read(@tree_oid)
+      end
+
+      def message
+        read!
+        @message
+      end
+
+      def committer
+        read!
+        @committer
+      end
+
+      def author
+        read!
+        @author
+      end
+
+      def time
+        read!
+        @time
+      end
+
+      def commit_time
+        read!
+        @commit_time
+      end
+
+      def read!
+        return if @read
+        @read = true
+        @header, @message = content.split("\n\n")
+        @parent_oids = []
+        @header.each_line do |line|
+          type, content = line.split(' ',2)
+          case(type)
+          when 'tree' then @tree_oid = content.chomp
+          when 'parent' then @parent_oids << content.chomp
+          when 'author' then
+            @author, @time = parse_signature(content)
+          when 'committer' then
+            @committer, @commit_time = parse_signature(content)
+          else
+            raise "Commit line type: #{type}"
+          end
+        end
+      end
+
+    private
+
+      SIGNATURE_RX = /\A(.+) <([^>]+)> (\d+) ([\-+]\d{2})(\d{2})\Z/
+
+      def parse_signature(content)
+        match = SIGNATURE_RX.match(content)
+        return MultiGit::Handle.new(match[1],match[2]), Time.at(match[3].to_i).localtime(match[4]+':'+match[5])
+      end
+
+    end
+  end
+end
+

data/lib/multi_git/git_backend/object.rb

@@ -0,0 +1,34 @@
+require 'multi_git/object'
+require 'forwardable'
+class MultiGit::GitBackend::Object
+
+  extend Forwardable
+
+  include MultiGit::Object
+
+  def initialize(repository, oid, content = nil)
+    @repository = repository
+    @git = repository.__backend__
+    @oid = oid
+    @content = content ? content.dup.freeze : nil
+  end
+
+  def bytesize
+    @size ||= begin
+      if @content
+        @content.bytesize
+      else
+        @git['cat-file',:s,@oid].to_i
+      end
+    end
+  end
+
+  def content
+    @content ||= @git['cat-file',type.to_s,@oid].freeze
+  end
+
+  def to_io
+    StringIO.new(content)
+  end
+
+end

data/lib/multi_git/git_backend/ref.rb

@@ -0,0 +1,36 @@
+require 'fileutils'
+require 'multi_git/ref'
+module MultiGit
+  module GitBackend
+    class Ref
+
+      include MultiGit::Ref
+
+      attr :target
+
+      def initialize(repository, name)
+        super(repository, name)
+        read!
+      end
+
+    private
+
+      SHOW_REF_LINE = /\A(\h{40}) ([^\n]+)\Z/.freeze
+
+      def read!
+        begin
+          if symbolic?
+            content = repository.__backend__['symbolic-ref', name]
+            @target = repository.ref(content.chomp)
+          else
+            lines = repository.__backend__['show-ref', name].lines
+            match = SHOW_REF_LINE.match(lines.first)
+            @target = repository.read(match[1])
+          end
+        rescue Cmd::Error::ExitCode1
+          # doesn't exists
+        end
+      end
+    end
+  end
+end

data/lib/multi_git/git_backend/repository.rb

@@ -0,0 +1,162 @@
+require 'multi_git/utils'
+require 'multi_git/tree_entry'
+require 'multi_git/repository'
+require 'multi_git/git_backend/cmd'
+require 'multi_git/git_backend/blob'
+require 'multi_git/git_backend/tree'
+require 'multi_git/git_backend/commit'
+require 'multi_git/git_backend/ref'
+module MultiGit::GitBackend
+
+  class Repository < MultiGit::Repository
+
+    # @api private
+    def __backend__
+      @git
+    end
+
+    Utils = MultiGit::Utils
+
+    OBJECT_CLASSES = {
+      :blob => Blob,
+      :tree => Tree,
+      :commit => Commit
+    }
+
+    def bare?
+      git_work_tree.nil?
+    end
+
+    attr :git_dir
+    attr :git_work_tree
+    attr :git_binary
+
+    def initialize(path, options = {})
+      @git_binary = `which git`.chomp
+      options = initialize_options(path, options)
+      git_dir = options[:repository]
+      @git = Cmd.new(git_binary, :git_dir => git_dir )
+      if !::File.exists?(git_dir) || MultiGit::Utils.empty_dir?(git_dir)
+        if options[:init]
+          if options[:bare]
+            @git['init', :bare, git_dir]
+          else
+            @git['init', git_dir]
+          end
+        else
+          raise MultiGit::Error::NotARepository, options[:repository]
+        end
+      end
+      @git_dir = git_dir
+      @git_work_tree = options[:working_directory]
+      @index = options[:index]
+      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)
+      oid = nil
+      if content.kind_of? MultiGit::Object
+        if include?(content.oid)
+          return read(content.oid)
+        end
+        content = content.to_io
+      end
+      if content.respond_to? :path
+        oid = @git["hash-object",:t, type.to_s,:w,'--', content.path].chomp
+      else
+        content = content.read if content.respond_to? :read
+        @git.call('hash-object',:t,type.to_s, :w, :stdin) do |stdin, stdout|
+          stdin.write(content)
+          stdin.close
+          oid = stdout.read.chomp
+        end
+      end
+      return OBJECT_CLASSES[type].new(self,oid)
+    end
+
+    # {include:MultiGit::Repository#read}
+    # @param (see MultiGit::Repository#read)
+    # @raise (see MultiGit::Repository#read)
+    # @return (see MultiGit::Repository#read)
+    def read(oidish)
+      oid = parse(oidish)
+      type = @git['cat-file',:t, oid].chomp
+      return OBJECT_CLASSES[type.to_sym].new(self, oid)
+    end
+
+    # {include:MultiGit::Repository#parse}
+    # @param (see MultiGit::Repository#parse)
+    # @raise (see MultiGit::Repository#parse)
+    # @return (see MultiGit::Repository#parse)
+    def parse(oidish)
+      begin
+        result = @git['rev-parse', :revs_only, :validate, oidish.to_s].chomp
+        if result == ""
+          raise MultiGit::Error::InvalidReference, oidish
+        end
+        return result
+      rescue Cmd::Error::ExitCode128
+        raise MultiGit::Error::InvalidReference, oidish
+      end
+    end
+
+    # {include:MultiGit::Repository#include?}
+    # @param (see MultiGit::Repository#include?)
+    # @raise (see MultiGit::Repository#include?)
+    # @return (see MultiGit::Repository#include?)
+    def include?(oid)
+      begin
+        @git['cat-file', :e, oid.to_s]
+        return true
+      rescue Cmd::Error::ExitCode1
+        return false
+      end
+    end
+
+    def ref(name)
+      MultiGit::GitBackend::Ref.new(self, name)
+    end
+
+    # @visibility private
+    MKTREE_FORMAT = "%06o %s %s\t%s\n"
+
+    # @visibility private
+    # @api private
+    def make_tree(entries)
+      @git.call('mktree') do |stdin, stdout|
+        entries.each do |name, mode, oid|
+          stdin.printf(MKTREE_FORMAT, mode, Utils.type_from_mode(mode), oid, name)
+        end
+        stdin.close
+        read(stdout.read.chomp)
+      end
+    end
+
+    # @visibility private
+    # @api private
+    def make_commit(commit)
+      env = {
+        'GIT_AUTHOR_NAME'=>commit[:author].name,
+        'GIT_AUTHOR_EMAIL'=>commit[:author].email,
+        'GIT_AUTHOR_DATE' =>commit[:time].strftime('%s %z'),
+        'GIT_COMMITTER_NAME'=>commit[:committer].name,
+        'GIT_COMMITTER_EMAIL'=>commit[:committer].email,
+        'GIT_COMMITTER_DATE' =>commit[:commit_time].strftime('%s %z')
+      }
+      @git.call_env(env, 'commit-tree', commit[:tree], commit[:parents].map{|p| [:p, p] } ) do |stdin, stdout|
+        stdin << commit[:message]
+        stdin.close
+        return read(stdout.read.chomp)
+      end
+    end
+
+  end
+end

data/lib/multi_git/git_backend/tree.rb

@@ -0,0 +1,22 @@
+require 'multi_git/tree'
+require 'multi_git/git_backend/object'
+module MultiGit::GitBackend
+  class Tree < Object
+
+    LS_TREE_REGEX = /^([0-7]{6}) (?:blob|tree|commit) (\h{40})\t(.+)$/
+
+    include MultiGit::Tree
+
+    def raw_entries
+      @raw_entries ||= begin
+        @git.call('ls-tree', oid) do |stdout|
+          stdout.each_line.map do |line|
+            raise unless LS_TREE_REGEX =~ line
+            [$3,$1.to_i(8),$2]
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/multi_git/git_backend.rb

@@ -0,0 +1,19 @@
+module MultiGit
+  module GitBackend
+    class << self
+
+      def load!
+      end
+
+      def available?
+        true
+      end
+
+      def open(directory, options = {})
+        Repository.new(directory, options)
+      end
+
+    end
+  end
+end
+require 'multi_git/git_backend/repository'

data/lib/multi_git/handle.rb

@@ -0,0 +1,33 @@
+module MultiGit
+  # Encapsulates name + email. Mostly used for commits.
+  class Handle < Struct.new(:name, :email)
+
+  private
+    EMAIL = /\A\w+@\w+\.\w+\z/ # close enough, but
+    NAME_WITH_EMAIL = /\A(.*) <(\S+@\S+\.\S+)>\z/
+  public
+
+    # Parses a handle from a string
+    # 
+    # Currently two formats are recognized. Either just a mail address 
+    # (e.g. 'user@example.com') or user + mail address in brackets ( e.g. 
+    # 'User <user@example.com>' ).
+    #
+    # @param string [String] a string containing a handle.
+    # @return [Handle]
+    #
+    # @example
+    #   MultiGit::Handle.parse('me@mydom.ain') #=> be_a MultiGit::Handle
+    #
+    def self.parse(string)
+      case(string)
+      when EMAIL then return new(string, string)
+      when NAME_WITH_EMAIL then return new($1,$2)
+      else raise ArgumentError, "Unknown handle format: #{string}. Please use either 'user@example.com' or 'User <user@example.com>'"
+      end
+    end
+
+    DEFAULT = parse("MultiGit #{MultiGit::VERSION} <#{MultiGit::VERSION}@multi.git>")
+
+  end
+end

data/lib/multi_git/jgit_backend/blob.rb

@@ -0,0 +1,10 @@
+require 'multi_git/blob'
+require 'multi_git/jgit_backend/object'
+module MultiGit::JGitBackend
+
+  class Blob < Object
+
+    include MultiGit::Blob
+
+  end
+end

data/lib/multi_git/jgit_backend/commit.rb

@@ -0,0 +1,45 @@
+require 'multi_git/commit'
+require 'multi_git/jgit_backend/object'
+module MultiGit
+  module JGitBackend
+    class Commit < Object
+      include MultiGit::Commit
+
+     import 'org.eclipse.jgit.revwalk.RevWalk'
+
+      def parents
+        @parents ||= java_commit.parents.map{|pr| repository.read(pr.getId()) }
+      end
+
+      def tree
+        @tree ||= repository.read(java_commit.tree.id)
+      end
+
+      def message
+        @message ||= java_commit.full_message.freeze
+      end
+
+      def time
+        @time ||= java_commit.author_ident.when
+      end
+
+      def commit_time
+        @time ||= java_commit.committer_ident.when
+      end
+
+      def author
+        @author ||= MultiGit::Handle.new(java_commit.author_ident.name,java_commit.author_ident.email_address)
+      end
+
+      def committer
+        @committer ||= MultiGit::Handle.new(java_commit.committer_ident.name,java_commit.committer_ident.email_address)
+      end
+    private
+
+      def java_commit
+        @java_commit ||= repository.use_reader{|rd| RevWalk.new(rd).parseCommit(java_oid) }
+      end
+
+    end
+  end
+end

data/lib/multi_git/jgit_backend/object.rb

@@ -0,0 +1,48 @@
+require 'multi_git/object'
+require 'forwardable'
+require 'multi_git/jgit_backend/rewindeable_io'
+class MultiGit::JGitBackend::Object
+
+  import "org.eclipse.jgit.lib.ObjectId"
+
+  extend Forwardable
+
+  include MultiGit::Object
+
+  def initialize(repository,oid, object = nil)
+    @repository = repository
+    @java_oid = oid
+    @git = repository.__backend__
+    @oid = ObjectId.toString(oid)
+    @java_object = object
+  end
+
+  def bytesize
+    java_object.getSize
+  end
+
+  def to_io
+    MultiGit::JGitBackend::RewindeableIO.new( java_stream )
+  end
+
+  def content
+    @content ||= to_io.read.freeze
+  end
+
+private
+
+  def java_stream
+    stream = java_object.openStream
+    stream.mark(bytesize)
+    stream
+  end
+
+protected
+
+  attr :java_oid
+
+  def java_object
+    @java_object ||= repository.use_reader{|rdr| rdr.open(@java_oid) }
+  end
+
+end

data/lib/multi_git/jgit_backend/ref.rb

@@ -0,0 +1,117 @@
+require 'multi_git/ref'
+module MultiGit
+  module JGitBackend
+    class Ref
+
+      include MultiGit::Ref
+
+      # HACK!
+      # @api private
+      # @visibility private
+      class Java::OrgEclipseJgitStorageFile::RefDirectoryUpdate
+        public :tryLock, :unlock, :doUpdate, :doDelete
+      end
+
+      # @api developer
+      class Updater < MultiGit::Ref::Updater
+
+        import "org.eclipse.jgit.lib.ObjectId"
+        import 'org.eclipse.jgit.lib.RefUpdate'
+
+      protected
+
+        def do_update(ru, nx)
+          case nx
+          when nil then
+            ru.doDelete(RefUpdate::Result::FORCED)
+          when MultiGit::Object then
+            ru.new_object_id = ObjectId.fromString(nx.oid)
+            ru.doUpdate(RefUpdate::Result::FORCED)
+          when MultiGit::Ref    then
+            ru.link( nx.name )
+          end
+        end
+
+      end
+
+      # @api developer
+      class OptimisticUpdater < Updater
+        def update(nx)
+          ru = repository.__backend__.updateRef(name)
+          begin
+            if !ru.try_lock(false)
+              raise
+            end
+            if ref.direct?
+              old_id = ObjectId.toString(ru.old_object_id)
+              if target.nil?
+                raise Error::ConcurrentRefUpdate if old_id != Utils::NULL_OID
+              elsif old_id != target.oid
+                raise Error::ConcurrentRefUpdate
+              end
+            end
+            nx = super
+            do_update(ru, nx)
+            return nx
+          ensure
+            ru.unlock
+          end
+        end
+
+      end
+
+      # @api developer
+      class PessimisticUpdater < Updater
+
+        def initialize(*_)
+          super
+          @ref_update = repository.__backend__.updateRef(name)
+          if !@ref_update.try_lock(false)
+            raise
+          end
+          self.ref = ref.reload
+        end
+
+        def update(nx)
+          nx = super
+          do_update(@ref_update, nx)
+          return nx
+        end
+
+        def destroy!
+          @ref_update.unlock
+        end
+      end
+
+      def initialize(repository, name)
+        super(repository, name)
+        @java_ref = repository.__backend__.getRef(name)
+      end
+
+      def target
+        return nil unless java_ref
+        @target ||= begin
+                    if java_ref.symbolic?
+                      repository.ref(java_ref.target.name)
+                    else
+                      repository.read(java_ref.getObjectId())
+                    end
+                  end
+      end
+
+      # @api private
+      # @visibility private
+      attr :java_ref
+
+    private
+
+      def optimistic_updater
+        OptimisticUpdater
+      end
+
+      def pessimistic_updater
+        PessimisticUpdater
+      end
+    end
+  end
+end