multi_git 0.0.1.alpha1

data/lib/multi_git/rugged_backend/repository.rb

@@ -0,0 +1,160 @@
+require 'multi_git/tree_entry'
+require 'multi_git/repository'
+require 'multi_git/rugged_backend/blob'
+require 'multi_git/rugged_backend/tree'
+require 'multi_git/rugged_backend/commit'
+require 'multi_git/rugged_backend/ref'
+module MultiGit::RuggedBackend
+
+  class Repository < MultiGit::Repository
+
+    extend Forwardable
+
+  private
+    OBJECT_CLASSES = {
+      :blob => Blob,
+      :tree => Tree,
+      :commit => Commit
+    }
+
+  public
+
+    # {include:MultiGit::Repository#bare?}
+    delegate "bare?" => "@git"
+
+    # {include:MultiGit::Repository#git_dir}
+    def git_dir
+      strip_slash @git.path
+    end
+
+    def git_work_tree
+      strip_slash @git.workdir
+    end
+
+    def initialize(path, options = {})
+      options = initialize_options(path,options)
+      begin
+        @git = Rugged::Repository.new(options[:repository])
+        if options[:working_directory]
+          @git.workdir = options[:working_directory]
+        end
+      rescue Rugged::RepositoryError, Rugged::OSError
+        if options[:init]
+          @git = Rugged::Repository.init_at(path, !!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
+      #if content.respond_to? :path
+        # file duck-type
+      #  oid = @git.hash_file(content.path, type)
+      #  return OBJECT_CLASSES[type].new(@git, oid)
+      #els
+      if content.respond_to? :read
+        # IO duck-type
+        content = content.read
+      end
+      oid = @git.write(content.to_s, type)
+      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(ref)
+      oid = parse(ref)
+      object = @git.lookup(oid)
+      return OBJECT_CLASSES[object.type].new(self, oid, object)
+    end
+
+    def ref(ref)
+      Ref.new(self, ref)
+    end
+
+    # {include:MultiGit::Repository#parse}
+    # @param (see MultiGit::Repository#parse)
+    # @raise (see MultiGit::Repository#parse)
+    # @return (see MultiGit::Repository#parse)
+    def parse(oidish)
+      begin
+        return Rugged::Object.rev_parse_oid(@git, oidish)
+      rescue Rugged::ReferenceError => e
+        raise MultiGit::Error::InvalidReference, e
+      end
+    end
+
+    # {include:MultiGit::Repository#include?}
+    # @param (see MultiGit::Repository#include?)
+    # @raise (see MultiGit::Repository#include?)
+    # @return (see MultiGit::Repository#include?)
+    def include?(oid)
+      @git.include?(oid)
+    end
+
+    # @api private
+    # @visibility private
+    def __backend__
+      @git
+    end
+
+    # @api private
+    # @visibility private
+    def make_tree(entries)
+      builder = Rugged::Tree::Builder.new
+      entries.each do |name, mode, oid|
+        builder << { name: name, oid: oid, filemode: mode}
+      end
+      oid = builder.write(@git)
+      return read(oid)
+    end
+
+    # @api private
+    # @visibility private
+    def make_commit(options)
+      rugged_options = {
+        tree: options[:tree],
+        message: options[:message],
+        parents: options[:parents],
+        author: {
+          name:  options[:author].name,
+          email: options[:author].email,
+          time:  options[:time]
+        },
+        committer: {
+          name:  options[:committer].name,
+          email: options[:committer].email,
+          time:  options[:commit_time]
+        }
+      }
+      oid = Rugged::Commit.create(@git, rugged_options)
+      return read(oid)
+    end
+
+  private
+
+    def strip_slash(path)
+      return nil if path.nil?
+      return path[0..-2]
+    end
+
+  end
+end

data/lib/multi_git/rugged_backend/tree.rb

@@ -0,0 +1,18 @@
+require 'multi_git/tree'
+require 'multi_git/rugged_backend/object'
+module MultiGit::RuggedBackend
+  class Tree < Object
+    include MultiGit::Tree
+
+    def size
+      rugged_object.count
+    end
+
+    def raw_entries
+      @raw_entries ||= rugged_object.map do |entry|
+        [entry[:name], entry[:filemode], entry[:oid]]
+      end
+    end
+
+  end
+end

data/lib/multi_git/rugged_backend.rb

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

data/lib/multi_git/submodule.rb

@@ -0,0 +1,7 @@
+require 'multi_git/tree_entry'
+module MultiGit
+
+  class Submodule < TreeEntry
+  end
+
+end

data/lib/multi_git/symlink.rb

@@ -0,0 +1,42 @@
+require 'multi_git/tree_entry'
+module MultiGit
+
+  class Symlink < TreeEntry
+
+    module Base
+
+      def target
+        object.content
+      end
+
+      def resolve
+        parent.traverse(target, :follow => :path)
+      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
+
+      def target=(t)
+        object.content = t
+      end
+
+    end
+
+    include Base
+
+  end
+
+end

data/lib/multi_git/tree/builder.rb

@@ -0,0 +1,184 @@
+require 'set'
+require 'multi_git/tree'
+require 'multi_git/builder'
+module MultiGit
+  class Tree::Builder
+
+    include MultiGit::Builder
+    include Tree::Base
+
+    attr :entries
+
+    def initialize(from = nil, &block)
+      @entries = {}
+      @from = from
+      instance_eval(&block) if block
+    end
+
+    def entry(key)
+      if @from
+        @entries.fetch(key) do
+          e = @from.entry(key)
+          if e
+            @entries[key] = e.to_builder.with_parent(self)
+          end
+        end
+      else
+        @entries[key]
+      end
+    end
+
+    def each
+      return to_enum unless block_given?
+      names.each do |name|
+        yield entry(name)
+      end
+    end
+
+    # TODO: cache
+    def names
+      names = @from ? @from.names.dup : []
+      @entries.each do |k,v|
+        if v
+          unless names.include? k
+            names << k
+          end
+        else
+          names.delete(k)
+        end
+      end
+      return names
+    end
+
+    def size
+      names.size
+    end
+
+    def >>(repository)
+      ent = []
+      @entries.each do |name, entry|
+        if entry
+          object = repository.write(entry)
+          ent << [name, object.mode, object.oid]
+        end
+      end
+      if @from
+        @from.each do |entry|
+          unless @entries.key? entry.name
+            ent << [entry.name, entry.mode, entry.oid]
+          end
+        end
+      end
+      return repository.make_tree(ent)
+    end
+
+    module DSL
+
+      def set(key, *args, &block)
+        case(args.size)
+        when 0
+          raise ArgumentError, "Expected a value or a block" unless block
+          value = block
+        when 1
+          if block
+            options = args[0]
+            value = block
+          else
+            value = args[0]
+          end
+        when 2
+          raise ArgumentError, "Expected either a value or a block, got both" if block
+          options = args[0]
+          value = args[1]
+        else
+          raise ArgumentError, "Expected 1-3 arguments, got #{args.size}"
+        end
+        # okay, a bit simple here for now
+        parts = key.split('/').reject{|k| k == '' || k == '.' }
+        if parts.any?{|p| p == ".." }
+          raise MultiGit::Error::InvalidTraversal, "Traversal to parent directories is currently not supported while setting."
+        end
+        return traverse_set( self, parts, value, true)
+      end
+
+      alias []= set
+
+      def entry_set(key, value)
+        entries[key] = make_entry(key, value)
+      end
+
+      def make_entry(key, value)
+        if value.kind_of? Proc
+          value = value.call(self, key)
+        end
+        if value.nil?
+          return value
+        elsif value.kind_of? String
+          return MultiGit::File::Builder.new(self, key, value)
+        elsif value.kind_of? MultiGit::Builder
+          return value.with_parent(self)
+        else
+          raise ArgumentError, "No idea what to do with #{value.inspect}"
+        end
+      end
+
+      def traverse_set(current, parts, value, create)
+        if parts.none?
+          raise
+        end
+        if parts.size == 1
+          current.entry_set(parts[0], value)
+          return current
+        end
+        part, *rest = parts
+        if !current.respond_to? :entry
+          raise MultiGit::Error::InvalidTraversal, "Can't traverse to #{path} from #{self.inspect}: #{current.inspect} doesn't contain an entry named #{part.inspect}"
+        end
+        entry = current.entry(part)
+        if !entry.kind_of? MultiGit::Directory::Builder
+          # fine
+          if entry.kind_of? MultiGit::Tree
+            entry = entry.to_builder
+          elsif create == :overwrite || ( entry.nil? && create )
+            entry = MultiGit::Directory::Builder.new(current, part)
+          else
+            raise MultiGit::Error::InvalidTraversal, "Can't traverse to #{path} from #{self.inspect}: #{current.inspect} doesn't contain an entry named #{part.inspect}" unless entry
+          end
+        end
+        current.entry_set(part, traverse_set(entry, rest, value, create))
+        return current
+      end
+
+      def file(name, content = nil, &block)
+        set(name){|parent, name|
+          File::Builder.new(parent, name, content, &block)
+        }
+      end
+
+      def directory(name, &block)
+        set(name){|parent, name|
+          Directory::Builder.new(parent, name, &block)
+        }
+      end
+
+      def link(name, target)
+        set(name){|parent, name|
+          Symlink::Builder.new(parent, name, target)
+        }
+      end
+
+      def delete(name)
+        set(name){ nil }
+      end
+
+      def to_builder
+        self
+      end
+
+    end
+
+    include DSL
+
+  end
+end
+require 'multi_git/directory'

data/lib/multi_git/tree.rb

@@ -0,0 +1,144 @@
+require 'multi_git/object'
+require 'forwardable'
+module MultiGit
+  module Tree
+
+    # @visibility protected
+    SLASH = '/'.freeze
+
+    module Base
+
+      include Enumerable
+
+      def type
+        :tree
+      end
+
+      def parent?
+        false
+      end
+
+      def key?(key)
+        if key.kind_of? String
+          return entries.key?(key)
+        else
+          raise ArgumentError, "Expected a String, got #{key.inspect}"
+        end
+      end
+
+      # @param [String] key
+      # @return [MultiGit::TreeEntry, nil]
+      def entry(key)
+        entries[key]
+      end
+
+      # Traverses to path
+      # @param [String] path
+      # @param [Hash] options
+      # @option options [Boolean] :follow follow sylinks ( default: true )
+      # @raise [MultiGit::Error::InvalidTraversal] if the path is not reacheable
+      # @raise [MultiGit::Error::CyclicSymlink] if a cyclic symlink is found
+      # @return [MultiGit::TreeEntry]
+      def traverse(path, options = {})
+        unless path.kind_of? String
+          raise ArgumentError, "Expected a String, got #{path.inspect}"
+        end
+        parts = path.split('/').reverse!
+        current = self
+        follow = options.fetch(:follow){true}
+        symlinks = Set.new
+        while parts.any?
+          part = parts.pop
+          if part == '..'
+            unless current.parent?
+              raise MultiGit::Error::InvalidTraversal, "Can't traverse to parent of #{current.inspect} since I don't know where it is."
+            end
+            current = current.parent
+          elsif part == '.' || part == ''
+            # do nothing
+          else
+            if !current.respond_to? :entry
+              raise MultiGit::Error::InvalidTraversal, "Can't traverse to #{path} from #{self.inspect}: #{current.inspect} doesn't contain an entry named #{part.inspect}"
+            end
+            entry = current.entry(part)
+            raise MultiGit::Error::InvalidTraversal, "Can't traverse to #{path} from #{self.inspect}: #{current.inspect} doesn't contain an entry named #{part.inspect}" unless entry
+            # may be a symlink
+            if entry.respond_to? :target
+              # this is a symlink
+              if symlinks.include? entry
+                # We have already seen this symlink
+                #TODO: it's okay to see a symlink twice if requested
+                raise MultiGit::Error::CyclicSymlink, "Cyclic symlink detected while traversing #{path} from #{self.inspect}."
+              else
+                symlinks << entry
+              end
+              if follow
+                parts.push(*entry.target.split(SLASH))
+              else
+                if parts.none?
+                  return entry
+                else
+                  raise ArgumentError, "Can't follow symlink #{entry.inspect} since you didn't allow me to"
+                end
+              end
+            else
+              current = entry
+            end
+          end
+        end
+        return current
+      end
+
+      alias / traverse
+      alias [] traverse
+
+      # @yield [MultiGit::TreeEntry]
+      def each
+        return to_enum unless block_given?
+        entries.each do |name, entry|
+          yield entry
+        end
+        return self
+      end
+
+      # @return [Integer] number of entries
+      def size
+        entries.size
+      end
+
+      # @return [Array<String>] names of all entries
+      def names
+        entries.keys
+      end
+
+    end
+
+    include Base
+    include Object
+
+    def to_builder
+      Builder.new(self)
+    end
+
+    # @visibility private
+    def inspect
+      ['#<',self.class.name,' ',oid,' repository:', repository.inspect,'>'].join
+    end
+
+  protected
+    # @return [Hash<String, MultiGit::TreeEntry>]
+    def entries
+      @entries ||= Hash[ raw_entries.map{|name, mode, oid| [name, make_entry(name, mode, oid) ] } ]
+    end
+
+    def raw_entries
+      raise Error::NotYetImplemented, "#{self.class}#each_entry"
+    end
+
+    def make_entry(name, mode, oid)
+      repository.read_entry(self, name,mode,oid)
+    end
+
+  end
+end
+require 'multi_git/tree/builder'

data/lib/multi_git/tree_entry.rb

@@ -0,0 +1,86 @@
+require 'multi_git/utils'
+require 'multi_git/object'
+require 'multi_git/builder'
+module MultiGit
+
+  base = Class.new
+
+  # @!parse
+  #    class TreeEntry < TreeEntry::Base
+  #    end
+  class TreeEntry < base
+    Base = superclass
+  end
+
+  # A tree entry is like a {MultiGit::Object} or a {MultiGit::Builder} but it 
+  # also has knows it's parent tree.
+  class TreeEntry
+
+    class Base
+
+      # @return [String]
+      attr :name
+      # @return [MultiGit::Tree::Base]
+      attr :parent
+
+      extend MultiGit::Utils::AbstractMethods
+
+      # @!method mode
+      #   @abstract
+      #   @return [Integer] the git-internal entry mode
+      abstract :mode
+
+      # @visibility private
+      def initialize(parent, name, inner)
+        @parent = parent
+        @name = name
+        @object = inner
+      end
+
+      # @param [MultiGit::Object] parent
+      # @return [MultiGit::TreeEntry]
+      def with_parent(parent, name = self.name)
+        self.class.new(parent, name, @object)
+      end
+
+    end
+
+    class Builder < Base
+
+      include MultiGit::Builder
+
+      # @return [MultiGit::Builder]
+      attr :object
+
+      # {include:MultiGit::Builder#>>}
+      # @param (see MultiGit::Builder#>>)
+      # @return [MultiGit::TreeEntry]
+      def >>(repository)
+        result = object >> repository
+        return repository.read_entry(parent, name, mode, result.oid)
+      end
+
+      # @visibility private
+      def initialize(parent, name, *args, &block)
+        super( parent, name , make_inner(*args) )
+        instance_eval(&block) if block
+      end
+
+    end
+
+    # @return [MultiGit::Object]
+    attr :object
+
+    include MultiGit::Object
+
+    extend Forwardable
+
+    delegate (MultiGit::Object.instance_methods - ::Object.instance_methods) => :object
+
+    def to_builder
+      self.class::Builder.new(parent, name, object)
+    end
+
+  end
+
+end

data/lib/multi_git/utils.rb

@@ -0,0 +1,57 @@
+module MultiGit
+  module Utils
+
+    module AbstractMethods
+
+      def abstract(name)
+        class_eval <<RUBY
+def #{name}(*args, &block)
+  raise NotImplementedError, "Please implement #{name} for \#{self}"
+end
+RUBY
+      end
+
+    end
+
+    NULL_OID = '0'*40
+
+    MODE_SYMLINK =     0120000
+    MODE_SUBMODULE =   0160000
+    MODE_DIRECTORY =   0040000
+    MODE_FILE =        0100644
+    MODE_EXECUTEABLE = 0100755
+
+    MODE_TYPES = {
+      MODE_SYMLINK     => :blob,
+      MODE_SUBMODULE   => :commit,
+      MODE_DIRECTORY   => :tree,
+      MODE_FILE        => :blob,
+      MODE_EXECUTEABLE => :blob
+    }
+
+    # @api private
+    DOTS = { '.' => true, '..' => true }
+
+    def empty_dir?(path)
+      Dir.new(path).reject{|path| DOTS[path] }.none?
+    end
+
+    # A
+    def looks_bare?(path)
+      return nil unless ::File.exists?(path)
+      return !::File.exists?(::File.join(path,'.git')) &&
+        ::File.exists?(::File.join(path,'refs'))
+    end
+
+    # @api private
+    def file_loadeable?(file)
+      $LOAD_PATH.any?{|path| File.exists?( File.join(path, file) ) }
+    end
+
+    def type_from_mode(mode)
+      MODE_TYPES.fetch(mode.to_i){ raise "Unknown file mode #{mode}" }
+    end
+
+    extend self
+  end
+end