v 0.0.4

data/lib/v/adapters/git/index.rb

@@ -0,0 +1,63 @@
+module V
+  module Adapters
+    module Git
+      # http://book.git-scm.com/7_the_git_index.html
+      class Index
+        include V::Adapters::Git
+
+        def initialize(environment)
+          @environment = environment
+        end
+
+        def add(*files)
+          @environment.add *files
+        end
+        alias_method :<<, :add
+
+        def include?(filename)
+          @environment.ls_files(filename) !~ /^\s*$/
+        end
+
+        def +(other)
+          raise NotImplementedError, 'TODO: implement Index#+(other)'
+        end
+
+        def -(other)
+          other.is_a? Git::Object or
+          raise ArgumentError, 'expected Git::Object'
+
+          name = case other
+          when Commit
+            other.name
+          when Tree
+            other.name
+          when Tag
+            other.name
+          when Blob
+            raise NotImplementedError, 'TODO: implement Index#-(other)'
+          else raise p(other)
+          end
+
+          @environment.diff_index name,
+              :name_status => true, :cached => true do |out, err|
+            Status.new out
+          end
+        end
+
+        def commit(*args)
+          @environment.commit *args
+        end
+        def reset(*args)
+          @environment.reset *args
+        end
+
+        protected
+
+          def assign(attrs)
+            attrs.each { |k, v| instance_variable_set :"@#{ k }", v }
+          end
+
+      end
+    end
+  end
+end

data/lib/v/adapters/git/object.rb

@@ -0,0 +1,104 @@
+module V
+  module Adapters
+    module Git
+      class ObjectType
+        include Singleton
+
+        # Returns true if other is a Git::Object and has the same type, false
+        # otherwise.
+        def ===(object)
+          object.is_a? Git::Object and object.type == self
+        end
+
+        # See ObjectType#===.
+        def self.===(object)
+          instance === object
+        end
+
+        def content(object)
+          raise NotImplementedError
+        end
+        def to_s(object = nil)
+          object ? object.name : self.class.name
+        end
+      end
+
+      # http://book.git-scm.com/1_the_git_object_model.html
+      class Object
+
+        DEFN = 'def %s(*args, &block) type.%s self, *args, &block end'
+        def self.register_methods(*methods)
+          methods.each { |method| class_eval DEFN.gsub('%s', method.to_s) }
+        end
+        @@types = {}
+        def self.register_type(type)
+          @@types.update type
+        end
+
+        attr_reader :name, :environment
+
+        def initialize(environment, attrs)
+          @environment = environment
+          assign attrs
+        end
+
+        # Keep this lazy! Most objects only need a name.
+        def type
+          @@types.fetch @type
+        end
+
+        # Content depends on type. Since this object is typecasted on demand
+        # content can be assigned during initialize (e.g. after commit).
+        def content(reload = false)
+          @content = type.content self if reload or not defined? @content
+          @content
+        end
+        def size
+          content.size
+        end
+        alias_method :length, :size
+
+        def to_s
+          type.to_s self
+        end
+
+        INSPECT_EXCLUDES = [:'@content', :'@name', :'@type']
+        def inspect
+          attrs = instance_variables.inject([]) { |m, i|
+            if INSPECT_EXCLUDES.include? :"#{ i }" then m
+            else
+              m << "#{ i }=#{ instance_variable_get(:"#{ i }").inspect }"
+            end
+          } * ' '
+          type = "#{ @type }".capitalize
+
+          "#<Git::#{ type }:#{ @name } #{ attrs } @content=[...]>"
+        end
+
+        # Returns the path to the object in the current root.
+        def path(*basenames)
+          type.path @parent, @basenames, *basenames
+        end
+
+        # Returns true if the other object has the same type and name, false
+        # otherwise.
+        def ==(other)
+          type === other and name == other.name
+        end
+
+        protected
+
+          def assign(attrs)
+            attrs.each { |k, v| instance_variable_set :"@#{ k }", v }
+          end
+
+      end
+    end
+  end
+end
+
+begin
+  __dir__ = File.dirname __FILE__
+  %w[ commit tree blob tag ].
+  each { |basename| require "#{ __dir__ }/object_types/#{ basename }" }
+end

data/lib/v/adapters/git/object_types/blob.rb

@@ -0,0 +1,24 @@
+module V
+  module Adapters
+    module Git
+      class Blob < ObjectType
+
+        def content(object)
+          object.environment.show object.name, :pretty => :raw
+        end
+
+        def path(parent, basename)
+          parent.path basename
+        end
+
+        def [](object, *args)
+          object.content[*args]
+        end
+
+        Object.register_type :blob => instance
+        Object.register_methods :[]
+
+      end
+    end
+  end
+end

data/lib/v/adapters/git/object_types/commit.rb

@@ -0,0 +1,124 @@
+module V
+  module Adapters
+    module Git
+      class Commit < ObjectType
+
+        # Completes :name in <tt>attrs</tt> and returns a Git::Object with
+        # type :commit.
+        def self.with(environment, attrs = {})
+          if attrs[:name].length < 40
+            glob = File.join environment.git_dir, 'objects',
+                attrs[:name][0, 2], "#{ attrs[:name][2, 38] }*"
+
+            attrs[:name] = attrs[:name][0, 2] + File.basename(Dir[ glob ].first)
+          end
+
+          Object.new environment, attrs.update(:type => :commit)
+        end
+
+        # see `git help show` for details
+        F = {
+          :commit_hash          => '%H',
+          :commit_hash_abbrev   => '%h',
+          :tree_hash            => '%T', #
+          :tree_hash_abbrev     => '%t',
+          :parent_hashes        => '%P', #
+          :parent_hashes_abbrev => '%p',
+          :a_name               => '%an', #
+          :a_name_mailmap       => '%aN',
+          :a_email              => '%ae', #
+          :a_email_mailmap      => '%aE',
+          :a_date               => '%ad',
+          :a_date_rfc2822       => '%aD',
+          :a_date_relative      => '%ar',
+          :a_date_unix          => '%at', #
+          :a_date_iso8601       => '%ai',
+          :c_name               => '%cn', #
+          :c_name_mailmap       => '%cN',
+          :c_email              => '%ce', #
+          :c_email_mailmap      => '%cE',
+          :c_date               => '%cd',
+          :c_date_rfc2822       => '%cD',
+          :c_date_relative      => '%cr',
+          :c_date_unix          => '%ct', #
+          :c_date_iso8601       => '%ci',
+          :ref_names            => '%d',
+          :encoding             => '%e',
+          :subject              => '%s', #
+          :subject_sanitized    => '%f',
+          :body                 => '%b', # extra
+          :red                  => '%Cred',
+          :green                => '%Cgreen',
+          :blue                 => '%Cblue',
+          :reset_color          => '%Creset',
+          :newline              => '%n',
+          :hex                  => '%%x%02x'
+#                     o    %m: left, right or boundary mark
+#                     o    %C(...): color specification, as described in color.branch.* config option
+        }
+        format = []
+        format<< F[:tree_hash]
+        format<< F[:parent_hashes]
+        format<< F.values_at(:a_name, :a_email, :a_date_unix) * (F[:hex] % 0)
+        format<< F.values_at(:c_name, :c_email, :c_date_unix) * (F[:hex] % 0)
+        format<< F.values_at(:subject, :body) * (F[:hex] % 0)
+        FORMAT = format * F[:newline]
+
+        def content(object)
+          object.environment.show object.name, :pretty => FORMAT
+        end
+
+        def tree(object)
+          fetch object, :tree
+        end
+        def parents(object)
+          fetch object, :parents
+        end
+        def author(object)
+          fetch object, :author
+        end
+        def committer(object)
+          fetch object, :commiter
+        end
+        def subject(object)
+          fetch object, :subject
+        end
+        def body(object)
+          fetch object, :body
+        end
+
+        def path(parent, *basenames)
+          basenames.compact * '/'
+        end
+
+        protected
+
+          def fetch(object, attribute)
+            content = object.content.split "\n", 5
+            env     = object.environment
+
+            case attribute
+            when :tree
+              Tree.with env, :name => content[0], :parent => object
+            when :parents
+              content[1].split(' ').
+              inject({}) { |mem, name| mem.update name => Commit.with(env, :name => name) }
+            when :author
+              Participation.new :author, *content[2].split("\0")
+            when :commiter
+              Participation.new :committer, *content[3].split("\0")
+            when :subject
+              content[4].split("\0").first
+            when :body
+              content[4].split("\0").last
+            end
+          end
+
+        Object.register_type :commit => instance
+        Object.register_methods :tree, :parents, :author, :committer,
+            :subject, :body
+
+      end
+    end
+  end
+end

data/lib/v/adapters/git/object_types/tag.rb

@@ -0,0 +1,23 @@
+module V
+  module Adapters
+    module Git
+      class Tag < ObjectType
+
+        # Returns the name of the commit the object points to.
+        def content(obj)
+          path = File.join obj.environment.git_dir, %w[ refs tags ], obj.name
+          File.read(path).chomp
+        end
+
+        # Returns the commit the object points to.
+        def commit(object)
+          Commit.with object.environment, :name => object.content
+        end
+
+        Object.register_type :tag => instance
+        Object.register_methods :commit
+
+      end
+    end
+  end
+end

data/lib/v/adapters/git/object_types/tree.rb

@@ -0,0 +1,51 @@
+module V
+  module Adapters
+    module Git
+      class Tree < ObjectType
+        include Enumerable
+
+        def self.with(environment, attrs = {})
+          Object.new environment, attrs.update(:type => :tree)
+        end
+
+        LINE_RE = /^(\d{6}) (blob|tree) ([[:alnum:]]{40})\t(.+)$/
+        def content(object)
+          environment, name, parent = object.environment, object.name, object
+
+          environment.ls_tree(name).split($/).
+          inject({}) do |mem, line|
+            mode, type, name, basename = LINE_RE.match(line).captures
+
+#            see git help ls-tree
+#            path.gsub! /(\\n|\\t|\\)/, ...
+
+            child = Object.new environment,
+                :type => type.to_sym, :name => name,
+                :parent => parent, :basename => basename
+
+            mem.update basename => child
+          end
+        end
+        def each(object)
+          object.content.values.each { |v| yield v }
+        end
+
+        def [](object, glob)
+          raise NotImplementedError
+        end
+        def /(object, path)
+          parts = path.to_s.split '/'
+          parts.inject(object) { |obj, name| obj.content.fetch name }
+        end
+
+        def path(parent, *basenames)
+          parent.path *basenames
+        end
+
+        Object.register_type :tree => instance
+        Object.register_methods :each, :/, :[]
+
+      end
+    end
+  end
+end

data/lib/v/adapters/git/operations/add_to_index.rb

@@ -0,0 +1,30 @@
+module V::Adapters::Git
+  module Operations
+    AddToIndex = operation(:add) do
+      # 1.6.3.2
+      arguments do |args|
+        args.dry_run.n
+        args.verbose.v
+        args.force.f
+        args.interactive.i
+        args.patch.p
+        args.edit.e
+        args.all.A
+        args.update.u
+        args.intent_to_add.N
+        args.refresh
+        args.ignore_errors
+        args << '--'
+      end
+
+      include WorkTreeRequirement
+      def run(environment)
+        out, err = exec environment
+        err.empty? or raise V::ERROR, err
+
+        Index.new environment
+      end
+
+    end
+  end
+end

data/lib/v/adapters/git/operations/branch.rb

@@ -0,0 +1,42 @@
+module V::Adapters::Git
+  module Operations
+    Branch = operation(:branch) do
+      # 1.6.3.2
+      arguments do |args|
+        args.color
+        args.no_color
+        args.remote(:alias => true).r
+        args.all(:alias => true).a
+        args.verbose.v
+        args.abbrev(7)
+        args.no_abbrev
+        args.merged
+        args.no_merged
+        args.contains
+        # <commit>
+        args.track
+        args.no_track
+        args.reflog(:alias => true).l
+        args.force(:alias => true).f
+        # <branchname>
+        # <startpoint>
+        args.move(:alias => true).m
+        args.move!(:alias => true).M
+        # <oldbranch>
+        # <newbranch>
+        args.delete(:alias => true).d
+        args.delete!(:alias => true).D
+        # <branchname>
+      end
+
+      include WorkTreeRequirement
+      def run(environment)
+        out, err = exec environment
+        err.empty? or raise V::ERROR, err
+
+        out
+      end
+
+    end
+  end
+end

data/lib/v/adapters/git/operations/commit_index.rb

@@ -0,0 +1,39 @@
+module V::Adapters::Git
+  module Operations
+    CommitIndex = operation(:commit) do
+      # 1.6.3.2
+      arguments do |args|
+        args.all.a
+        args.interactive
+        args.signoff.s
+        args.verbose.v
+        args.untracked_files(:all).u
+        args.amend
+        args.reedit_message(nil).c
+        args.reuse_message(nil).C
+        args.file(nil).F
+        args.message(nil, :first => true).m
+        args.allow_empty
+        args.no_verify.n
+        args.edit.e
+        args.author nil
+        args.cleanup :default
+        args << '--'
+        args.include.i
+        args.only.o
+      end
+
+      include WorkTreeRequirement
+      def run(environment)
+        out, err = exec environment
+        err.empty? or raise V::ERROR, err
+
+        name = /^\[(?:.*) (\S+)\]/.match(out).captures.first
+        Commit.with environment, :name => name
+      rescue
+        return out
+      end
+
+    end
+  end
+end

data/lib/v/adapters/git/operations/diff_index.rb

@@ -0,0 +1,20 @@
+module V::Adapters::Git
+  module Operations
+    DiffIndex = operation(:diff_index) do
+      # 1.6.3.2
+      arguments do |args|
+        # TODO: complete arguments ...
+        args.cached
+        args.name_status
+      end
+
+      def run(environment)
+        out, err = exec environment
+        err.empty? or raise V::ERROR, err
+
+        out
+      end
+
+    end
+  end
+end

data/lib/v/adapters/git/operations/initialize_repository.rb

@@ -0,0 +1,21 @@
+module V::Adapters::Git
+  module Operations
+    InitializeRepository = operation(:init) do
+      # 1.6.3.2
+      arguments do |args|
+        args.quiet.q
+        args.bare
+        args.template(nil)
+        args.shared(:umask, false)
+      end
+
+      def run(environment)
+        out, err = exec environment
+        err.empty? or raise V::ERROR, err
+
+        environment
+      end
+
+    end
+  end
+end

data/lib/v/adapters/git/operations/list_files.rb

@@ -0,0 +1,38 @@
+module V::Adapters::Git
+  module Operations
+    ListFiles = operation(:ls_files) do
+      # 1.6.3.2
+      arguments do |args|
+        args.zero(:alias => true).z
+        args.tags(:alias => true).t
+        # TODO: understand v option
+        args.vulgar(:alias => true).v
+        args.cached.c
+        args.deleted.d
+        args.others.o
+        args.ignored.i
+        args.stage.s
+        args.unmerge.u
+        args.killed.k
+        args.modified.m
+        args.exclude(nil).x
+        args.exclude_from(nil).X
+        args.exclude_per_directory(nil)
+        args.exclude_standard
+        args.error_unmatch
+        args.with_tree(nil)
+        args.full_name
+        args.abbrev(40)
+        args << '--'
+      end
+
+      def run(environment)
+        out, err = exec environment
+        err.empty? or raise V::ERROR, err
+
+        out
+      end
+
+    end
+  end
+end

data/lib/v/adapters/git/operations/list_tree.rb

@@ -0,0 +1,30 @@
+module V::Adapters::Git
+  module Operations
+    ListTree = operation(:ls_tree) do
+      # 1.6.3.2
+      arguments do |args|
+        # TODO: check naming
+        args.directories(:alias => true).d
+        args.recursive(:alias => true).r
+        # TODO: check naming
+        args.trace(:alias => true).t
+        args.long.l
+        args.zero(:alias => true).z
+        args.name_only
+        # TODO: implement support for non abbrev aliases
+        args.name_status
+        args.abbrev(40)
+        args.full_name
+        args.full_tree
+      end
+
+      def run(environment)
+        out, err = exec environment
+        err.empty? or raise V::ERROR, err
+
+        out
+      end
+
+    end
+  end
+end

data/lib/v/adapters/git/operations/push_references_to_remote.rb

@@ -0,0 +1,25 @@
+module V::Adapters::Git
+  module Operations
+    PushReferencesToRemote = operation(:push) do
+      # 1.6.3.2
+      arguments do |args|
+        args.all
+        args.mirror
+        args.tags
+        args.dry_run
+        args.porcelain
+        args.receive_pack nil
+        args.repository nil
+        args.thin
+        args.no_thin
+        args.force.f
+        args.verbose.v
+      end
+
+      def run(environment)
+        exec environment
+      end
+
+    end
+  end
+end

data/lib/v/adapters/git/operations/remove_from_index.rb

@@ -0,0 +1,25 @@
+module V::Adapters::Git
+  module Operations
+    RemoveFromIndex = operation(:rm) do
+      # 1.6.3.2
+      arguments do |args|
+        args.force.f
+        args.dry_run.n
+        args.recursive(:alias => true).r
+        args.cached
+        args.ignore_unmatch
+        args.quiet.q
+        args << '--'
+      end
+
+      include WorkTreeRequirement
+      def run(environment)
+        out, err = exec environment
+        err.empty? or raise V::ERROR, err
+
+        Index.new environment
+      end
+
+    end
+  end
+end

data/lib/v/adapters/git/operations/reset_index.rb

@@ -0,0 +1,25 @@
+module V::Adapters::Git
+  module Operations
+    ResetIndex = operation(:reset) do
+      # 1.6.3.2
+      arguments do |args|
+        args.mixed
+        args.soft
+        args.hard
+        args.merged
+        args.quiet(:alias => true).q
+        args.commit(:HEAD, :rude => true).c
+        args << '--'
+      end
+
+      include WorkTreeRequirement
+      def run(environment)
+        out, err = exec environment
+        err.empty? or raise V::ERROR, err
+
+        Index.new environment
+      end
+
+    end
+  end
+end