multi_git 0.0.1.alpha1

data/lib/multi_git/backend.rb

@@ -0,0 +1,100 @@
+require 'multi_git/utils'
+require 'multi_git/error'
+module MultiGit
+
+  module Backend
+
+    attr :failed, :exception
+
+    def check(description, &check)
+      @checks ||= []
+      @checks << [description, check]
+    end
+
+    def check!
+      @checks.each do |description, check|
+        begin 
+          result = check.call
+          if result == false
+            @failed = description
+            return
+          end
+        rescue Exception => e
+          @failed = description
+          @exception = e
+        end
+      end
+    end
+
+    private :check, :check!
+
+    # @abstract
+    #
+    # This method implements loading the backend files.
+    def load!
+      raise NotImplementedError, "Please implement #load! for #{self}"
+    end
+
+    # Opens a git repository.
+    #
+    # @return [Repository]
+    def open(directory, options = {})
+      load!
+      open(directory, options)
+    end
+
+    # Tests whether this backend is available.
+    def available?
+      check!
+      @failed.nil?
+    end
+
+  end
+
+  module RuggedBackend
+
+    extend Backend
+
+    check "Rugged available" do
+      defined?(::Rugged) || 
+        Utils.file_loadeable?('rugged.rb')
+    end
+
+    def self.load!
+      require 'multi_git/rugged_backend'
+    end
+
+  end
+
+  module JGitBackend
+
+    extend Backend
+
+    check "Using Jruby" do
+      RUBY_ENGINE == "jruby"
+    end
+
+    check "Jgit available" do
+      defined?(Java::OrgEclipseJgitLib::Repository)
+    end
+
+    def self.load!
+      require 'multi_git/jgit_backend'
+    end
+
+  end
+
+  module GitBackend
+
+    extend Backend
+
+    check "Git Executeable available" do
+      `git --version`
+    end
+
+    def self.load!
+      require 'multi_git/git_backend'
+    end
+
+  end
+end

data/lib/multi_git/backend_set.rb

@@ -0,0 +1,42 @@
+require 'multi_git/backend'
+module MultiGit
+
+  # @visibility private
+  # @api private
+  class BackendSet
+
+    def initialize
+      @backends = {}
+      @priorities = {}
+    end
+
+    def []=(name, options={}, value)
+      raise ArgumentError, "Expected a MultiGit::Backend, got #{value.inspect}" unless value.respond_to? :available?
+      @priorities[name] = options.fetch(:priority, 0)
+      @backends[name] = value
+    end
+
+    def [](name)
+      if name.kind_of? Backend
+        return name
+      elsif name == :best
+        return best
+      else
+        return @backends[name]
+      end
+    end
+
+    def priority(name)
+      @priorities[name]
+    end
+
+    def best
+      @priorities.sort_by{|_,value| -value}.find do |name, _|
+        be = self[name]
+        return be if be.available?
+      end
+    end
+
+  end
+
+end

data/lib/multi_git/blob.rb

@@ -0,0 +1,52 @@
+require 'stringio'
+require 'multi_git/object'
+require 'multi_git/builder'
+module MultiGit
+  module Blob
+
+    module Base
+      def type
+        :blob
+      end
+    end
+
+    class Builder < StringIO
+      include Base
+      include MultiGit::Builder
+
+      def initialize(content = nil)
+        super()
+        if content.kind_of? Blob
+          self << content.content
+        elsif content.kind_of? String
+          self << content
+        elsif content.kind_of? IO
+          IO.copy_stream(content, self)
+        elsif content
+          raise ArgumentError
+        end
+      end
+
+      def content
+        string
+      end
+
+      def content=(value)
+        self.string = value.dup
+      end
+
+      def >>(repo)
+        rewind
+        return repo.write(read)
+      end
+    end
+
+    include Object
+    include Base
+
+    def to_builder
+      Builder.new(self)
+    end
+
+  end
+end

data/lib/multi_git/builder.rb

@@ -0,0 +1,19 @@
+require 'multi_git/utils'
+# Builders provides simple interfaces to create complex structures like trees and commits.
+module MultiGit::Builder
+
+  extend MultiGit::Utils::AbstractMethods
+
+  # @!method >>(repository)
+  #   @abstract
+  #   Writes the content of this builder to the given repository.
+  #   @param [Repository] repository
+  #   @return [MultiGit::Object] the persisted object
+  abstract :>>
+
+  # @return [self] self
+  def to_builder
+    self
+  end
+
+end

data/lib/multi_git/commit.rb

@@ -0,0 +1,185 @@
+require 'forwardable'
+require 'multi_git/utils'
+require 'multi_git/handle'
+require 'multi_git/builder'
+module MultiGit
+
+  module Commit
+
+    module Base
+      extend Utils::AbstractMethods
+      extend Forwardable
+
+      # @return String
+      abstract :message
+
+      # @return Tree
+      abstract :tree
+
+      # @return [Array<Commit>]
+      abstract :parents
+
+      # @return [Time]
+      abstract :time
+      # @return [Handle]
+      abstract :author
+
+      # @return [Time]
+      abstract :commit_time
+      # @return [Handle]
+      abstract :committer
+
+      delegate [:[], :/] => :tree
+
+      def type
+        :commit
+      end
+    end
+
+    # A commit builder helps creating new commits by 
+    # providing a simple interface, sane defaults and some
+    # validations.
+    #
+    # You can create a new commit using the commit builder like this:
+    # 
+    # @example Commit an small tree
+    #   #setup:
+    #   dir = `mktemp -d`
+    #   # example:
+    #   builder = MultiGit::Commit::Builder.new
+    #   builder.message = "My first commit"
+    #   builder.by "me@example.com"
+    #   builder.tree["a_file"] = "some content"
+    #   # builder is now ready to be inserted
+    #   repository = MultiGit.open(dir, init: true)
+    #   commit = repository << builder #=> be_a MultiGit::Commit
+    #   commit.tree['a_file'].content  #=> eql "some content"
+    #   # teardown:
+    #   `rm -rf #{dir}`
+    class Builder
+      include MultiGit::Builder
+      include Base
+
+      # @return (see MultiGit::Commit::Base#message)
+      def message(*args)
+        if args.any?
+          self.message = args.first
+          return self
+        else
+          return @message
+        end
+      end
+
+      #
+      # @yield allows 
+      # @return [Tree::Builder]
+      def tree(&block)
+        @tree.instance_eval(&block) if block
+        @tree
+      end
+      # @return [Array<Commit::Base>]
+      attr :parents
+
+      # @return (see MultiGit::Commit::Base#time)
+      attr :time
+      # @return (see MultiGit::Commit::Base#commit_time)
+      attr :commit_time
+
+      # @return (see MultiGit::Commit::Base#author)
+      attr :author
+      # @return (see MultiGit::Commit::Base#committer)
+      attr :committer
+
+      attr_writer :author, :committer
+      attr_writer :message
+
+      # @param time [Time]
+      def time=(time)
+        raise ArgumentError, "Expected a Time, got #{time.inspect}" unless time.kind_of? Time
+        @time = time
+      end
+
+      # @param time [Time]
+      def commit_time=(time)
+        raise ArgumentError, "Expected a Time, got #{time.inspect}" unless time.kind_of? Time
+        @commit_time = time
+      end
+
+      # @param handle [Handle, String]
+      def committer=(handle)
+        @committer = parse_handle(handle)
+      end
+
+      # @param handle [Handle, String]
+      def author=(handle)
+        @author = parse_handle(handle)
+      end
+
+      # DSL method to set author and committer in one step
+      # @param handle [Handle, String]
+      # @return self
+      def by(handle)
+        self.author = self.committer = handle
+        return self
+      end
+
+      def at(time)
+        self.time = self.commit_time = time
+        return self
+      end
+
+      def initialize(from = nil, &block)
+        @parents = []
+        if from.kind_of? Tree
+          @tree = from.to_builder
+        elsif from.kind_of? Tree::Builder
+          @tree = from
+        elsif from.kind_of? Commit
+          @tree = from.tree.to_builder
+          @parents << from
+        elsif from.nil?
+          @tree = Tree::Builder.new
+        end
+        @author = nil
+        @committer = nil
+        @time = @commit_time = Time.now
+        instance_eval(&block) if block
+      end
+
+      def >>(repo)
+        new_tree = repo << tree
+        new_parents = parents.map{|p| repo.write(p).oid }
+        c = committer || author    || Handle::DEFAULT
+        a = author    || committer || Handle::DEFAULT
+        return repo.make_commit(
+          :time => time,
+          :author => a,
+          :commit_time => commit_time,
+          :committer => c,
+          :parents => new_parents,
+          :tree => new_tree.oid,
+          :message => message || "Thank you for using multi_git",
+          :update_ref => []
+        )
+      end
+
+    protected
+
+      def parse_handle(handle)
+        case(handle)
+        when Handle then
+          return handle
+        when String then
+          return Handle.parse(handle)
+        else
+          raise ArgumentError, "Expected a String or a Handle, got #{handle.inspect}"
+        end
+      end
+
+    end
+
+    include Base
+
+  end
+end
+

data/lib/multi_git/directory.rb

@@ -0,0 +1,67 @@
+require 'multi_git/tree'
+require 'multi_git/tree_entry'
+module MultiGit
+
+  class Directory < TreeEntry
+
+    module Base
+      include Tree::Base
+      def mode
+        Utils::MODE_DIRECTORY
+      end
+
+      def parent?
+        !@parent.nil?
+      end
+
+      def size
+        object.size
+      end
+
+      def entry(key)
+        e = object.entry(key)
+        e.with_parent(self) if e
+      end
+
+    end
+
+    class Builder < TreeEntry::Builder
+      include Tree::Builder::DSL
+      include Base
+
+      def make_inner(*args)
+        if args.any?
+          if args[0].kind_of?(Tree::Builder)
+            return args[0]
+          elsif args[0].kind_of?(Directory)
+            return args[0].object.to_builder
+          elsif args[0].kind_of?(Tree)
+            return args[0].to_builder
+          end
+        end
+        Tree::Builder.new(*args)
+      end
+
+      def entry_set(key, value)
+        object.entry_set(key, make_entry(key, value))
+      end
+
+      def entries
+        Hash[
+          object.map{|entry| [entry.name, entry.with_parent(self) ] }
+        ]
+      end
+
+    end
+
+    include Base
+
+    def entries
+      @entries ||= Hash[
+        object.map{|entry| [entry.name, entry.with_parent(self) ] }
+      ]
+    end
+
+  end
+
+end

data/lib/multi_git/error.rb

@@ -0,0 +1,67 @@
+module MultiGit
+
+  module Error
+
+    class NotARepository < ArgumentError
+      include Error
+    end
+
+    class RepositoryNotBare < NotARepository
+      include Error
+    end
+
+    class RepositoryBare < NotARepository
+      include Error
+    end
+
+    class InvalidObjectType < ArgumentError
+      include Error
+    end
+
+    class InvalidReference < ArgumentError
+      include Error
+    end
+
+    class InvalidTraversal < ArgumentError
+      include Error
+    end
+
+    class CyclicSymlink < Exception
+      include Error
+    end
+
+    class AmbiguousReference < InvalidReference
+    end
+
+    class BadRevisionSyntax < InvalidReference
+    end
+
+    class WrongTypeForMode < Exception
+      include Error
+
+      def initialize(expected, actual)
+        super("It looks like you expected a #{expected.inspect} but referenced entry is a #{actual.inspect}")
+      end
+    end
+
+    class NotYetImplemented < NotImplementedError
+      include Error
+    end
+
+    class Internal < Exception
+      include Error
+    end
+
+    class ConcurrentRefUpdate < Exception
+      include Error
+
+      def initialize
+        super 'Another process has updated the ref you are currently updating.
+This is unlikely to be a problem, no data got lost. You may simply retry the update.
+If this happens frequently, you may have want to run "git gc" to remove clobber.'
+      end
+    end
+
+  end
+
+end

data/lib/multi_git/executeable.rb

@@ -0,0 +1,12 @@
+require 'multi_git/tree_entry'
+require 'multi_git/file'
+module MultiGit
+
+  class Executeable < File
+
+    def mode
+      Utils::MODE_EXECUTEABLE
+    end
+  end
+
+end

data/lib/multi_git/file.rb

@@ -0,0 +1,35 @@
+require 'multi_git/tree_entry'
+require 'multi_git/blob'
+require 'forwardable'
+module MultiGit
+
+  class File < TreeEntry
+
+    module Base
+      def mode
+        Utils::MODE_FILE
+      end
+    end
+
+    class Builder < TreeEntry::Builder
+      include Base
+
+      def make_inner(*args)
+        if args.any?
+          if args[0].kind_of? Blob::Builder
+            return args[0]
+          elsif args[0].kind_of? Blob
+            return args[0].to_builder
+          end
+        end
+        Blob::Builder.new(*args)
+      end
+    end
+
+    include Base
+    extend Forwardable
+
+    delegate (Blob.instance_methods - Object.instance_methods) => :object
+  end
+
+end

data/lib/multi_git/git_backend/blob.rb

@@ -0,0 +1,11 @@
+require 'multi_git/blob'
+require 'multi_git/git_backend/object'
+module MultiGit::GitBackend
+
+  class Blob < Object
+
+    include MultiGit::Blob
+
+  end
+
+end

data/lib/multi_git/git_backend/cmd.rb

@@ -0,0 +1,117 @@
+require 'shellwords'
+require 'open3'
+require 'multi_git/error'
+module MultiGit::GitBackend
+
+  class Cmd
+
+    class Error < MultiGit::Error::Internal
+
+      def self.const_missing(name)
+        if name =~ /\AExitCode\d+\z/
+          self.const_set(name, Class.new(self))
+        else
+          super
+        end
+      end
+
+      def self.[](exit_code)
+        return const_get("ExitCode#{exit_code}")
+      end
+    end
+
+    def initialize(command, options = {})
+      @cmd = command
+      @opts = options
+    end
+
+    READ_BLOCK = lambda{|io|
+      io.read
+    }
+
+    def call_env(env, *args, &block)
+      s = cmd(*args)
+      block ||= READ_BLOCK
+      result = nil
+      message = nil
+      status = popen_foo(env, s.join(' ')) do | stdin, stdout, stderr |
+        if block.arity == 1
+          stdin.close
+          result = block.call(stdout)
+        else
+          result = block.call(stdin, stdout)
+        end
+        message = stderr.read
+      end
+      if status.exitstatus == 0
+        return result
+      else
+        raise Error[status.exitstatus], message.chomp
+      end
+    end
+
+    def call(*args, &block)
+      call_env({}, *args, &block)
+    end
+
+    alias [] call
+
+  private
+
+    # @api private
+    # 
+    # popen3 is broken in jruby, popen4 is not available in mri :(
+    def popen_foo(env={}, cmd)
+      if IO.respond_to? :popen4
+        # setting the env is broken in jruby
+        args = ['env -i', escape_opts(env), cmd]
+        IO.popen4(args.join(' ')) do |_pid, *yield_args|
+          yield *yield_args
+        end
+        return $?
+      else
+        Open3.popen3(env, cmd,:unsetenv_others => true ) do |*yield_args,_thr|
+          yield *yield_args
+          return _thr.value
+        end
+      end
+    end
+
+    def cmd(*args)
+      [ @cmd, escape_opts(@opts), escape_args(args) ].flatten
+    end
+
+    def escape_args(args)
+      args.map{|arg|
+        if arg.kind_of? Hash
+          escape_opts(arg)
+        elsif arg.kind_of? Array
+          escape_args(arg)
+        else
+          Shellwords.escape(opt_to_string(arg))
+        end
+      }
+    end
+
+    def escape_opts(opts)
+      opts.map{|k,v|
+        opt_to_string(k)+'='+Shellwords.escape(v)
+      }
+    end
+
+    def opt_to_string(opt)
+      if opt.kind_of? Symbol
+        s = opt.to_s
+        if s.size == 1
+          return '-'+s
+        else
+          return '--'+s.gsub('_','-')
+        end
+      else
+        return opt
+      end
+    end
+
+  end
+
+end