multi_git 0.0.1.alpha1

data/lib/multi_git/ref.rb

@@ -0,0 +1,381 @@
+require 'multi_git/utils'
+require 'fileutils'
+module MultiGit
+
+  # A reference is something that points eihter to another reference or to 
+  # an {MultiGit::Object}. So the most noteable method of this class is 
+  # {#target}.
+  #
+  # Instances of this classe are immuteable and reuseable. All writing methods 
+  # return new instances.
+  #
+  # @abstract
+  module Ref
+
+    # Updates a reference. Different subclasses use different mechanisms 
+    # for locking and storing the references. Locks may be acquired in the 
+    # constructor and must be released in #destroy! .
+    #
+    # Updaters are inherently neither threadsafe nor reuseable. This should 
+    # , however, not be a problem since they are not allocated by users.
+    #
+    # @api developer
+    # @abstract
+    class Updater
+
+      # @return [MultiGit::Object, MultiGit::Ref, nil]
+      attr :target
+
+      # @return [MultiGit::Ref]
+      attr :ref
+
+      # @return [MultiGit::Repository]
+      def repository
+        @ref.repository
+      end
+
+      # @return [String]
+      def name
+        @ref.name
+      end
+
+      # @param ref [Ref]
+      def initialize(ref)
+        self.ref = ref
+      end
+
+      # Finally carry out the update.
+      #
+      # @param new [MultiGit::Object, MultiGit::Ref, nil]
+      # @return [MultiGit::Object, MultiGit::Ref, nil]
+      # @abstract
+      def update(new)
+        nx = case new
+             when Ref, nil then new
+             when Object, Builder then repository.write(new)
+             else raise
+             end
+        @target = nx
+        return nx
+      end
+
+      # Release all resources used by this updater.
+      def destroy!
+      end
+
+      # @param ref [Ref]
+      def ref=(ref)
+        @ref = ref
+        @target = ref.target
+        return ref
+      end
+
+    end
+
+    # @api developer
+    class FileUpdater < Updater
+
+    protected
+
+      def open_file(exists)
+        mode = ::File::WRONLY | ::File::TRUNC
+        if !exists
+          begin
+            return ::File.open(file_path, mode | ::File::CREAT)
+          rescue Errno::EEXIST
+            raise Error::ConcurrentRefUpdate
+          end
+        else
+          begin
+            return ::File.open(file_path, mode)
+          rescue Errno::ENOENT
+            raise Error::ConcurrentRefUpdate
+          end
+        end
+      end
+
+      def object_to_ref_str(object)
+        case(object)
+        when nil              then ''
+        when MultiGit::Object then object.oid
+        when Ref              then "ref: #{object.name}"
+        end
+      end
+
+      def file_path
+        ::File.join(repository.git_dir, name)
+      end
+
+      def lock_file_path
+        ::File.join(repository.git_dir, name + '.lock')
+      end
+
+      def acquire_lock
+        ::File.open(lock_file_path, ::File::CREAT | ::File::RDWR | ::File::EXCL )
+      end
+
+      def release_lock(lock)
+        ::File.unlink(lock.path)
+        lock.flock(::File::LOCK_UN)
+      end
+
+    end
+
+    # @api developer
+    class PessimisticFileUpdater < FileUpdater
+
+      def initialize(*_)
+        super
+        @lock = acquire_lock
+        # safe now
+        @ref = @ref.reload
+      end
+
+      def update(new)
+        old = target
+        nx = super
+        if nx
+          str = object_to_ref_str(nx)
+          begin
+            file = open_file(!old.nil?)
+            file.puts(str)
+            file.flush
+          ensure
+            file.close if file
+          end
+        else
+          ::File.unlink(file_path)
+        end
+        return nx
+      end
+
+      def destroy!
+        release_lock(@lock)
+      end
+
+    end
+
+    # @api developer
+    class OptimisticFileUpdater < FileUpdater
+
+      def update(new)
+        begin
+          lock = acquire_lock
+          if ::File.exists?(file_path)
+            content = ::File.read(file_path).chomp
+            if content != object_to_ref_str(target)
+              raise Error::ConcurrentRefUpdate
+            end
+          elsif !target.nil?
+            raise Error::ConcurrentRefUpdate
+          end
+          old = target
+          nx = super
+          if nx.nil?
+            if !old
+              return nx
+            end
+            ::File.unlink(file_path)
+          else
+            begin
+              file = open_file( !old.nil? )
+              str = object_to_ref_str(nx)
+              file.puts( str )
+              file.flush
+            ensure
+              file.close if file
+            end
+          end
+          return nx
+        ensure
+          release_lock( lock )
+        end
+      end
+
+    private
+
+    end
+
+    extend MultiGit::Utils::AbstractMethods
+
+    # The full name of this ref e.g. refs/heads/master for the master branch.
+    # @return [String]
+    attr :name
+
+    # @!attribute [r] target
+    #   The target of this ref.
+    #   @return [MultiGit::Ref, MultiGit::Object, nil]
+    #   @abstract
+    abstract :target
+
+    # @return [MultiGit::Repository]
+    attr :repository
+
+    # @visibility private
+    def initialize(repository, name)
+      @repository = repository
+      @name = name
+    end
+
+    # Rereads this reference from the repository.
+    #
+    # @return [MultiGit::Ref]
+    def reload
+      repository.ref(name)
+    end
+
+    # Resolves symbolic references and returns the final reference.
+    #
+    # @return [MultGit::Ref]
+    def resolve
+      @leaf = begin
+        ref = self
+        loop do
+          break ref unless ref.symbolic?
+          ref = ref.target
+        end
+      end
+    end
+
+    # @!group Treeish methods
+
+    def [](name)
+      t = resolve.target
+      if t
+        return t[name]
+      end
+    end
+
+    alias / []
+
+    def []=(path, options = {}, value)
+      resolve.update(options.fetch(:lock, :pessimistic) ) do |commit|
+        
+      end
+    end
+
+    # @!endgroup
+
+    # @!group Utility methods
+
+    def direct?
+      name.include?('/')
+    end
+
+    def symbolic?
+      !direct?
+    end
+
+    def exists?
+      !target.nil?
+    end
+
+    # @!endgroup
+
+    # @!group Writing methods
+
+    # Updates the target of this reference.
+    #
+    # The new target of this reference is the result of the passed block. If
+    # you return nil, the ref will be deleted.
+    #
+    # By using the lock param you can control the isolation:
+    #
+    # [:optimistic] If the target is altered during the execution of the
+    #               block, a {MultiGit::Error::ConcurrentRefUpdate} is 
+    #               raised. This is the default as it holds hard locks 
+    #               only as long as necessary while providing pointfull 
+    #               isolation.
+    # [:pessimistic] A lock is acquired and held during the execution of the
+    #                block. Concurrent updates will wait or fail. This is 
+    #                good if the block is not retry-able or very small.
+    #
+    # @param lock [:optimistic, :pessimistic]
+    # @yield [current_target] Yields the current target and expects the block to return the new target
+    # @yieldparam current_target [MultiGit::Ref, MultiGit::Object, nil] current target
+    # @yieldreturn [MultiGit::Ref, MultiGit::Object, nil] new target
+    # @return [MultiGit::Ref] The altered ref
+    #
+    # @example
+    #  # setup:
+    #  dir = `mktemp -d`
+    #  repository = MultiGit.open(dir, init: true)
+    #  # insert a commit:
+    #  builder = MultiGit::Commit::Builder.new
+    #  builder.tree['a_file'] = 'some_content'
+    #  commit = repository.write(builder)
+    #  # update the ref:
+    #  ref = repository.ref('refs/heads/master') #=> be_a MultiGit::Ref
+    #  ref.update do |current_target|
+    #    current_target #=> be_nil
+    #    commit
+    #  end
+    #  # check result:
+    #  repository.ref('refs/heads/master').target #=> eql commit
+    #  # teardown:
+    #  `rm -rf #{dir}`
+    def update( lock = :optimistic )
+      updater_class = case lock
+                when :optimistic  then optimistic_updater
+                when :pessimistic then pessimistic_updater
+                end
+      begin
+        updater = updater_class.new(self)
+        updater.update( yield(updater.target) )
+        return reload
+      ensure
+        updater.destroy! if updater
+      end
+    end
+
+    def delete
+      update(:pessimistic){ nil }
+    end
+
+    def commit(&block)
+      resolve.update do |current|
+        Commit::Builder.new(current, &block)
+      end
+      return reload
+    end
+
+    #@!endgroup
+
+    # @api private
+    # @visibility private
+    def hash
+      name.hash ^ repository.hash
+    end
+
+    # @api private
+    # @visibility private
+    def eql?(other)
+      return false unless other.kind_of? Ref
+      name == other.name && repository.eql?(other.repository)
+    end
+
+    # @api private
+    # @visibility private
+    def ==(other)
+      eql?(other) && target == other.target
+    end
+
+    # @api private
+    # @visibility private
+    def inspect
+      ['<',self.class,' ',repository.inspect,':', name, ' -> ', target.inspect,' >'].join
+    end
+
+    private
+
+    def optimistic_updater
+      OptimisticFileUpdater
+    end
+
+    def pessimistic_updater
+      PessimisticFileUpdater
+    end
+
+  end
+
+end

data/lib/multi_git/repository.rb

@@ -0,0 +1,190 @@
+require 'fileutils'
+require 'set'
+require 'multi_git/utils'
+require 'multi_git/error'
+require 'multi_git/tree_entry'
+require 'multi_git/symlink'
+require 'multi_git/directory'
+require 'multi_git/file'
+require 'multi_git/executeable'
+require 'multi_git/submodule'
+
+# Abstract base class for all repository implementations.
+# @abstract
+class MultiGit::Repository
+
+protected
+  Utils = MultiGit::Utils
+  Error = MultiGit::Error
+
+  VALID_TYPES = Set[:blob, :tree, :commit, :tag]
+public
+  extend Utils::AbstractMethods
+
+  # @!method git_dir
+  #   @abstract
+  #   Return the repository base directory
+  #   @return [String]
+  abstract :git_dir
+
+  # @!method bare?
+  #   @abstract
+  #   Is this repository bare?
+  abstract :bare?
+
+  # @!method initialize(directory, options = {})
+  #   @param directory [String] a directory
+  #   @option options [Boolean] :init init the repository if it doesn't exist
+  #   @option options [Boolean] :bare open/init the repository bare
+
+  # @!method read(ref)
+  #   Reads a reference.
+  #
+  #   @abstract
+  #
+  #   @raise [MultiGit::Error::InvalidReference] if ref is not a valid reference
+  #   @raise [MultiGit::Error::AmbiguousReference] if ref refers to multiple objects
+  #   @raise [MultiGit::Error::BadRevisionSyntax] if ref does not contain a valid ref-syntax
+  #   @param [String] ref
+  #   @return [MultiGit::Object] object
+  abstract :read
+
+  # @!method include?(oid)
+  #   Checks whether this repository contains a given oid.
+  #   @abstract
+  #   @param [String] oid
+  #   @return [Boolean]
+  abstract :include?
+
+  # @!method parse(ref)
+  #   Resolves a reference into an oid.
+  #   @abstract
+  #   @param [String] rev
+  #   @raise [MultiGit::Error::InvalidReference] if ref is not a valid reference
+  #   @raise [MultiGit::Error::AmbiguousReference] if ref refers to multiple objects
+  #   @raise [MultiGit::Error::BadRevisionSyntax] if ref does not contain a valid ref-syntax
+  #   @return [String] oid
+  abstract :parse
+
+  # @!method write(content)
+  #   Writes something to the repository.
+  #
+  #   If called with a String or an IO, this method creates a {MultiGit::Blob} with the
+  #   given content. This is the easiest way to create blobs.
+  #
+  #   If called with a {MultiGit::Object}, this method determines if the object does already exist 
+  #   and writes it otherwise.
+  #
+  #   If called with a {MultiGit::Builder}, this method inserts the content of the builder to the 
+  #   repository. This is the easiest way to create trees/commits.
+  #
+  #   @abstract
+  #   @param [String, IO, MultiGit::Object, MultiGit::Builder] content
+  #   @return [MultiGit::Object] the resulting object
+  abstract :write
+
+  # @!method ref(name)
+  #   Opens a reference.
+  #   @abstract
+  #   @param [String] name
+  #   @return [MultiGit::Ref] ref
+  abstract :ref
+
+  def branch(name)
+    if name.include? '/'
+      ref('refs/remotes/'+name)
+    else
+      ref('refs/heads/'+name)
+    end
+  end
+
+  def tag(name)
+    ref('refs/tags/'+name)
+  end
+
+  # @!parse alias_method :[], :ref
+  def [](name)
+    ref(name)
+  end
+
+  # @!parse alias_method :<<, :write
+  def <<(*args,&block)
+    write(*args,&block)
+  end
+
+  # @visibility private
+  def inspect
+    if bare?
+      ["#<",self.class.name," ",git_dir,">"].join
+    else
+      ["#<",self.class.name," ",git_dir," checked out at:",git_work_tree,">"].join
+    end
+  end
+
+  # @visibility private
+  EC = {
+    Utils::MODE_EXECUTEABLE => MultiGit::Executeable,
+    Utils::MODE_FILE        => MultiGit::File,
+    Utils::MODE_SYMLINK     => MultiGit::Symlink,
+    Utils::MODE_DIRECTORY   => MultiGit::Directory
+  }
+
+  # @visibility private
+  def read_entry(parent = nil, name, mode, oidish)
+    obj = read(oidish)
+    EC[mode].new(parent, name, obj)
+  end
+protected
+
+  def initialize_options(path, options)
+    options = options.dup
+    options[:expected_bare] = options[:bare]
+    looks_bare = Utils.looks_bare?(path)
+    case(options[:bare])
+    when nil then
+      options[:bare] = looks_bare
+    when false then
+      raise Error::RepositoryBare, path if looks_bare
+    end
+    if !::File.exists?(path)
+      if options[:init]
+        FileUtils.mkdir_p(path)
+      else
+        raise Error::NotARepository, path
+      end
+    end
+    if options[:bare]
+      if looks_bare || options[:init]
+        options[:repository] ||= path
+      else
+        options[:repository] ||= ::File.join(path, '.git')
+      end
+      options.delete(:working_directory)
+    else
+      options[:working_directory] = path
+      options[:repository] ||= ::File.join(path, '.git')
+    end
+    options[:index] ||= ::File.join(options[:repository],'index')
+    return options
+  end
+
+  def verify_bareness(path, options)
+    bareness = options[:expected_bare]
+    return if bareness.nil?
+    if !bareness && bare?
+      raise Error::RepositoryBare, path
+    end
+  end
+
+  def verify_type_for_mode(type, mode)
+    expected = Utils.type_from_mode(mode)
+    unless type == expected
+      raise Error::WrongTypeForMode.new(expected, type)
+    end
+  end
+
+  def validate_type(type)
+    raise Error::InvalidObjectType, type.inspect unless VALID_TYPES.include?(type)
+  end
+
+end

data/lib/multi_git/rugged_backend/blob.rb

@@ -0,0 +1,8 @@
+require 'stringio'
+require 'multi_git/blob'
+require 'multi_git/rugged_backend/object'
+module MultiGit::RuggedBackend
+  class Blob < Object
+    include MultiGit::Blob
+  end
+end

data/lib/multi_git/rugged_backend/commit.rb

@@ -0,0 +1,38 @@
+require 'multi_git/commit'
+require 'multi_git/rugged_backend/object'
+module MultiGit
+  module RuggedBackend
+    class Commit < Object
+      include MultiGit::Commit
+
+      def tree
+        @tree ||= repository.read(rugged_object.tree_oid)
+      end
+
+      def parents
+        @parents ||= rugged_object.parent_oids.map{|oid| repository.read(oid) }
+      end
+
+      def author
+        MultiGit::Handle.new(rugged_object.author[:name],rugged_object.author[:email])
+      end
+
+      def time
+        rugged_object.author[:time]
+      end
+
+      def committer
+        MultiGit::Handle.new(rugged_object.committer[:name],rugged_object.committer[:email])
+      end
+
+      def commit_time
+        rugged_object.committer[:time]
+      end
+
+      def message
+        rugged_object.message
+      end
+
+    end
+  end
+end

data/lib/multi_git/rugged_backend/object.rb

@@ -0,0 +1,38 @@
+require 'forwardable'
+require 'multi_git/object'
+class MultiGit::RuggedBackend::Object
+
+  include MultiGit::Object
+
+  extend Forwardable
+
+  def initialize( repository, oid, object = nil )
+    @repository = repository
+    @git = repository.__backend__
+    @oid = oid
+    @rugged_object = object
+  end
+
+  def to_io
+    StringIO.new(content)
+  end
+
+  def bytesize
+    rugged_odb.len
+  end
+
+  def content
+    @content ||= rugged_odb.data.freeze
+  end
+
+protected
+
+  def rugged_object
+    @rugged_object ||= @git.lookup(@oid)
+  end
+
+  def rugged_odb
+    @rugged_odb ||= @git.read(@oid)
+  end
+
+end

data/lib/multi_git/rugged_backend/ref.rb

@@ -0,0 +1,32 @@
+require 'multi_git/ref'
+module MultiGit
+
+  module RuggedBackend
+
+    class Ref
+
+      include MultiGit::Ref
+
+      def initialize(repository, name)
+        super(repository, name)
+        @rugged_ref = Rugged::Reference.lookup(repository.__backend__, name)
+      end
+
+      def target
+        return nil unless rugged_ref
+        @target ||= begin
+                      if rugged_ref.type == :symbolic
+                        repository.ref(rugged_ref.target)
+                      else
+                        repository.read(rugged_ref.target)
+                      end
+                    end
+      end
+
+    private
+      attr :rugged_ref
+    end
+
+  end
+
+end