multi_git 0.0.1.alpha2 → 0.0.1.beta1

data/lib/multi_git/jgit_backend/repository.rb

@@ -4,6 +4,8 @@ require 'multi_git/jgit_backend/blob'
 require 'multi_git/jgit_backend/tree'
 require 'multi_git/jgit_backend/commit'
 require 'multi_git/jgit_backend/ref'
+require 'multi_git/jgit_backend/config'
+require 'multi_git/jgit_backend/remote'
 module MultiGit::JGitBackend
   class Repository < MultiGit::Repository
 
@@ -114,6 +116,10 @@ module MultiGit::JGitBackend
       Ref.new(self, name)
     end
 
+    def config
+      @config ||= Config.new(@git.config)
+    end
+
   private
     ALL_FILTER = %r{\Arefs/(?:heads|remotes)}
     LOCAL_FILTER = %r{\Arefs/heads}
@@ -212,6 +218,15 @@ module MultiGit::JGitBackend
       return Java::OrgEclipseJgitLib::ObjectId.toString(parse_java(ref))
     end
 
+    def remote( name_or_url )
+      if looks_like_remote_url? name_or_url
+        remote = Remote.new(self, name_or_url)
+      else
+        remote = Remote::Persistent.new(self, name_or_url)
+      end
+      return remote
+    end
+
     # @visibility private
     # @api private
     def parse_java(oidish)

data/lib/multi_git/ref.rb

@@ -157,7 +157,6 @@ module MultiGit
       def destroy!
         release_lock(@lock)
       end
-
     end
 
     # @api developer
@@ -197,9 +196,17 @@ module MultiGit
           release_lock( lock ) if lock
         end
       end
+    end
 
-    private
-
+    class RecklessUpdater < Updater
+      def update( new )
+        pu = PessimisticFileUpdater.new( ref )
+        begin
+          pu.update( new )
+        ensure
+          pu.destroy!
+        end
+      end
     end
 
     extend MultiGit::Utils::AbstractMethods
@@ -254,12 +261,6 @@ module MultiGit
 
     alias / []
 
-    def []=(path, options = {}, value)
-      resolve.update(options.fetch(:lock, :pessimistic) ) do |commit|
-        
-      end
-    end
-
     # @!endgroup
 
     # @!group Utility methods
@@ -272,6 +273,10 @@ module MultiGit
       !direct?
     end
 
+    def detached?
+      symbolic? && !target.kind_of?(Ref)
+    end
+
     def exists?
       !target.nil?
     end
@@ -285,22 +290,31 @@ module MultiGit
     # 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:
+    # @overload update( lock = :optimistic )
+    #   By using the lock param you can control the isolation:
+    #  
+    #   [:reckless] Updates the reference the hard way. Only locks enough 
+    #               to ensure the integrity of the repository and simply 
+    #               overwrites concurrent changes.
+    #   [: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.
     #
-    # [: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 [:reckless, :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
     #
-    # @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
+    # @overload update( value )
+    #
+    #   @param value [Commit, Ref, nil] new target for this ref
+    #   @return [MultiGit::Ref] The altered ref
     #
     # @example
     #  # setup:
@@ -320,26 +334,40 @@ module MultiGit
     #  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
+    def update( value_or_lock = :optimistic )
+      updater = updater_class(block_given?, value_or_lock).new(self)
+      updater.update( block_given? ? yield(updater.target) : value_or_lock )
+      return reload
+    ensure
+      updater.destroy! if updater
     end
 
+    # Shorthand for deleting this ref.
+    # @return [Ref]
     def delete
-      update(:pessimistic){ nil }
+      update( nil )
     end
 
-    def commit(&block)
-      resolve.update do |current|
+    # Shorthand method to directly create a commit and update the given ref.
+    #
+    # @example
+    #  # setup:
+    #  dir = `mktemp -d`
+    #  repository = MultiGit.open(dir, init: true)
+    #  # insert a commit:
+    #  repository.head.commit do
+    #    tree['a_file'] = 'some_content'
+    #  end
+    #  # check result:
+    #  repository.head['a_file'].content #=> eql 'some_content'
+    #  # teardown:
+    #  `rm -rf #{dir}`
+    #
+    # @option options :lock [:optimistic, :pessimistic] How to lock during the commit.
+    # @yield
+    # @return [Ref]
+    def commit(options = {}, &block)
+      resolve.update(options.fetch(:lock, :optimistic)) do |current|
         Commit::Builder.new(current, &block)
       end
       return reload
@@ -382,6 +410,22 @@ module MultiGit
       PessimisticFileUpdater
     end
 
+    def reckless_updater
+      RecklessUpdater
+    end
+
+    def updater_class( block_given, lock )
+      if block_given
+        case lock
+        when :optimistic  then optimistic_updater
+        when :pessimistic then pessimistic_updater
+        when :reckless    then reckless_updater
+        end
+      else
+        pessimistic_updater
+      end
+    end
+
   end
 
 end

data/lib/multi_git/refspec.rb

@@ -0,0 +1,118 @@
+module MultiGit
+
+  # A RefSpec describes which and how references are updated during 
+  # push and pull.
+  #
+  # It basically says: set the "to" ref to the target of "from"
+  #
+  # @example
+  #   refspecs = MultiGit::RefSpec.parse('master')
+  #
+  class RefSpec < Struct.new(:from,:to,:forced)
+
+    extend Utils::AbstractMethods
+
+    # @!attribute from
+    #   @return [String]
+
+    # @!attribute to
+    #   @return [String]
+
+    # @!attribute forced
+    #   @return [Boolean]
+
+    alias forced? forced
+
+    # @param from [String]
+    # @param to [String]
+    # @param forced [Boolean]
+    def initialize(from,to,forced = false)
+      super
+    end
+
+    def inspect
+      ['#<',self.class,' ',forced ? '+':'',from,':',to,'>'].join
+    end
+
+    def to_s
+      [forced ? '+':'',from,':',to].join
+    end
+
+    class Parser
+
+      REF = %r{\A(\+?)([a-zA-Z/0-9_*]+)?(?:(:)([a-zA-Z/0-9_*]+)?)?\z}
+
+      attr :from_base, :to_base
+
+      def initialize(from_base = 'refs/heads/', to_base )
+        @from_base = from_base
+        @to_base = to_base
+      end
+
+      # 
+      # @param args [RefSpec, String, Hash, Range, ...]
+      # @return [Array<RefSpec>]
+      def [](*args)
+        args.collect_concat do |arg|
+          if arg.kind_of? RefSpec
+            [arg]
+          elsif arg.kind_of? String
+            [parse_string(arg)]
+          elsif arg.kind_of? Hash
+            arg.map{|k,v| parse_pair(k,v) }
+          elsif arg.kind_of? Range
+            [parse_pair(arg.begin, arg.end)]
+          else
+            raise ArgumentError, "Expected a String, Hash or Range. Got #{arg.inspect}"
+          end
+        end
+      end
+
+    private
+      def parse_string(string)
+        if ma = REF.match(string)
+          if ma[2]
+            from = normalize(from_base, ma[2])
+          end
+          if ma[3]
+            to  = normalize(to_base, ma[4])
+          else
+            to  = normalize(to_base, ma[2])
+          end
+          RefSpec.new( from, to, ma[1] == '+' )
+        end
+      end
+
+      def parse_pair(a,b)
+        RefSpec.new( normalize(from_base,a.to_s), normalize(to_base,b.to_s) )
+      end
+
+      def normalize(base, name)
+        ns = name.split(SLASH, -1)
+        bs = base.split(SLASH, -1)
+        fill_reverse(bs, ns)
+        return bs.join(SLASH)
+      end
+
+      def fill_reverse(a,b)
+        s = a.size - b.size
+        b.each_with_index do |e, i|
+          a[s+i] = e
+        end
+      end
+
+    end
+
+    DEFAULT_PARSER = Parser.new('refs/remotes/origin/')
+
+    class << self
+
+      def parse(arg)
+        DEFAULT_PARSER[arg].first
+      end
+
+    end
+
+  end
+
+end

data/lib/multi_git/remote.rb

@@ -0,0 +1,66 @@
+require 'multi_git/refspec'
+module MultiGit
+
+  module Remote
+
+    extend Utils::AbstractMethods
+
+    # @!attribute repository
+    #   @return [Repository]
+    abstract :repository
+
+    # @!attribute fetch_urls
+    #   @return [Enumerable<URI>]
+    abstract :fetch_urls
+
+    # @!attribute push_urls
+    #   @return [Enumerable<URI>]
+    abstract :push_urls
+
+    # @!method fetch( *refspecs )
+    #   @param refspecs [RefSpec, String, Range, Hash, ...]
+    abstract :fetch
+
+    # @!method push( *refspecs )
+    #   @param refspecs [RefSpec, String, Range, Hash, ...]
+    abstract :push
+
+    # @!method save( name )
+    #   @param name [String]
+    #   @return [Persistent]
+    abstract :save
+
+    module Persistent
+      include Remote
+      extend Utils::AbstractMethods
+
+      # @!attribute name
+      #   @return [String, nil]
+      abstract :name
+
+      # @!method save( name = name )
+      #   @param name [String]
+      #   @return [Persistent]
+      abstract :save
+
+    protected
+
+      def refspec_parser
+        RefSpec::Parser.new("refs/remotes/#{name}/")
+      end
+
+    end
+
+  protected
+
+    def parse_fetch_refspec(*refspecs)
+      refspec_parser[*refspecs]
+    end
+
+    def refspec_parser
+      RefSpec::Parser.new("refs/remotes//")
+    end
+
+  end
+
+end

data/lib/multi_git/repository.rb

@@ -21,6 +21,12 @@ protected
 public
   extend Utils::AbstractMethods
 
+  # @!method config
+  #   @abstract
+  #   Returns the config
+  #   @return [Config]
+  abstract :config
+
   # @!method git_dir
   #   @abstract
   #   Return the repository base directory
@@ -101,6 +107,12 @@ public
   #   @return [MultiGit::Ref] ref
   abstract :ref
 
+  # Gets the ref
+  # @return [Ref] head
+  def head
+    return ref('HEAD')
+  end
+
   # Opens a branch
   #
   # @param name [String] branch name
@@ -236,4 +248,9 @@ protected
     raise Error::InvalidObjectType, type.inspect unless VALID_TYPES.include?(type)
   end
 
+  def looks_like_remote_url?(string)
+    # poor but efficient
+    string.include? '/'
+  end
+
 end

data/lib/multi_git/rugged_backend/config.rb

@@ -0,0 +1,43 @@
+require 'forwardable'
+require 'multi_git/config'
+module MultiGit
+  module RuggedBackend
+    class Config
+
+      include MultiGit::Config
+
+      def initialize(rugged_config)
+        @rugged_config = rugged_config
+        @config = Hash.new([])
+        rugged_config.each_pair do |qk, value|
+          key = split_key(qk)
+          @config.fetch(key){ @config[key] = [] } << value
+        end
+      end
+
+      def get(section, subsection, key)
+        s = schema_for(section, subsection, key)
+        v = @config[ [section, subsection,key] ]
+        if v.size == 0
+          s.default
+        elsif s.list?
+          s.convert(v)
+        else
+          s.convert(v.last)
+        end
+      end
+
+      def each_explicit_key
+        return to_enum(:each_explicit_key) unless block_given?
+        @config.each_key do |k|
+          yield *k
+        end
+      end
+
+    private
+
+      attr :rugged_config
+
+    end
+  end
+end

data/lib/multi_git/rugged_backend/remote.rb

@@ -0,0 +1,66 @@
+require 'multi_git/remote'
+require 'forwardable'
+module MultiGit
+  module RuggedBackend
+    class Remote
+
+      include MultiGit::Remote
+      extend Forwardable
+
+      attr :repository
+
+      attr :rugged_remote
+      protected :rugged_remote
+
+      def fetch_urls
+        [rugged_remote.url]
+      end
+
+      # :nocov:
+      if Rugged::Remote.instance_methods.include? :push_url
+        def push_urls
+          [rugged_remote.push_url || rugged_remote.url]
+        end
+      else
+        def push_urls
+          raise Error::NotYetImplemented, 'Rugged::Remote#push_urls is only available in bleeding edge rugged'
+        end
+      end
+      # :nocov:
+
+      def initialize( repository, remote )
+        @repository = repository
+        @rugged_remote = remote
+      end
+
+      class Persistent < self
+
+        include MultiGit::Remote::Persistent
+        extend Forwardable
+
+        def_instance_delegator :rugged_remote, :name
+
+      end
+
+    if Rugged::Remote.instance_methods.include? :clear_refspecs
+      def fetch(*refspecs)
+        rs = parse_fetch_refspec(*refspecs)
+        cl = Rugged::Remote.new(repository.__backend__, fetch_urls.first)
+        cl.clear_refspecs
+        rs.each do |spec|
+          cl.add_fetch(spec.to_s)
+        end
+        cl.connect(:fetch) do |r|
+          r.download
+        end
+        cl.update_tips!
+      end
+    else
+      def fetch(*_)
+        raise Error::NotYetImplemented, 'This rugged version doesn\'t seem to support fetching. You may want to install from HEAD.'
+      end
+    end
+
+    end
+  end
+end

data/lib/multi_git/rugged_backend/repository.rb

@@ -4,6 +4,8 @@ require 'multi_git/rugged_backend/blob'
 require 'multi_git/rugged_backend/tree'
 require 'multi_git/rugged_backend/commit'
 require 'multi_git/rugged_backend/ref'
+require 'multi_git/rugged_backend/config'
+require 'multi_git/rugged_backend/remote'
 module MultiGit::RuggedBackend
 
   class Repository < MultiGit::Repository
@@ -45,6 +47,7 @@ module MultiGit::RuggedBackend
           raise MultiGit::Error::NotARepository, path
         end
       end
+      @git.config = Rugged::Config.new(::File.join(@git.path, 'config'))
       verify_bareness(path, options)
     end
 
@@ -115,6 +118,10 @@ module MultiGit::RuggedBackend
       @git.include?(oid)
     end
 
+    def config
+      @config ||= Config.new(@git.config)
+    end
+
     TRUE_LAMBDA = proc{ true }
 
     def each_branch(filter = :all)
@@ -181,6 +188,24 @@ module MultiGit::RuggedBackend
       return read(oid)
     end
 
+    # 
+    def remote( name_or_url )
+      if looks_like_remote_url? name_or_url
+        remote = Rugged::Remote.new(__backend__, name_or_url)
+      else
+        remote = Rugged::Remote.lookup(__backend__, name_or_url)
+      end
+      if remote
+        if remote.name
+          return Remote::Persistent.new(self, remote)
+        else
+          return Remote.new(self, remote)
+        end
+      else
+        return nil
+      end
+    end
+
   private
 
     def strip_slash(path)

data/lib/multi_git/tree.rb

@@ -94,14 +94,37 @@ module MultiGit
       alias / traverse
       alias [] traverse
 
+      # Works like the builtin Dir.glob
+      #
+      # @param pattern [String] A glob pattern
+      # @param flags [Integer] glob flags
+      # @yield [MultiGit::TreeEntry]
+      # @return [Enumerator] if called without a block
+      # @return self if called with a block
+      #
+      # @example
+      #   bld = MultiGit::Tree::Builder.new do
+      #     file "file"
+      #     directory "folder" do
+      #       file "file"
+      #     end
+      #   end
+      #   bld.glob( '**/file' ).map(&:path) #=> eq ['file','folder/file']
+      #
+      # @see http://ruby-doc.org/core/Dir.html#method-c-glob
       def glob( pattern, flags = 0 )
         return to_enum(:glob, pattern, flags) unless block_given?
-        l = path.size
+        l = respond_to?(:path) ? path.size : 0
         flags |= ::File::FNM_PATHNAME
-        walk_pre do |object|
-          if ::File.fnmatch(pattern, object.path[l..-1], flags)
-            yield object
-            false
+        if ::File.fnmatch(pattern, '.', flags)
+          yield self
+        end
+        each do |entry|
+          entry.walk_pre do |sub_entry|
+            if ::File.fnmatch(pattern, sub_entry.path[l..-1], flags)
+              yield sub_entry
+              false
+            end
           end
         end
         return self
@@ -161,10 +184,6 @@ module MultiGit
       ['#<',self.class.name,' ',oid,' repository:', repository.inspect,'>'].join
     end
 
-    def path
-      ''
-    end
-
   protected
     # @return [Hash<String, MultiGit::TreeEntry>]
     def entries

data/lib/multi_git/tree_entry.rb

@@ -48,7 +48,7 @@ module MultiGit
 
       def path
         @path ||= begin
-                    if parent && parent.path != ''
+                    if parent.respond_to? :path
                       [parent.path,SLASH, name].join
                     else
                       name

data/lib/multi_git/version.rb

@@ -1,3 +1,3 @@
 module MultiGit
-  VERSION = '0.0.1.alpha2'
+  VERSION = '0.0.1.beta1'
 end

data/lib/multi_git.rb

@@ -4,6 +4,7 @@ require 'multi_git/backend'
 require 'multi_git/backend_set'
 require 'multi_git/error'
 require 'multi_git/utils'
+require 'multi_git/config'
 module MultiGit
 
 private