v 0.0.4

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

@@ -0,0 +1,23 @@
+module V::Adapters::Git
+  module Operations
+    ShowLog = operation(:log) do
+      # 1.6.3.2
+      arguments do |args|
+        args.pretty(:medium)
+        args.abbrev_commit
+        args.oneline
+        args.encoding('UTF-8')
+        args << '--'
+        # TODO: complete arguments ...
+      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/show_object.rb

@@ -0,0 +1,21 @@
+module V::Adapters::Git
+  module Operations
+    ShowObject = operation(:show) do
+      # 1.6.3.2
+      arguments do |args|
+        args.pretty(:medium)
+        args.abbrev_commit
+        args.oneline
+        args.encoding('UTF-8')
+      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/tag.rb

@@ -0,0 +1,29 @@
+module V::Adapters::Git
+  module Operations
+    Tag = operation(:tag) do
+      # 1.6.3.2
+      arguments do |args|
+        args.annotated(:alias => true).a
+        args.signed(:alias => true).s
+        args.signed_as(nil, :alias => true).u
+        args.force(:alias => true).f
+        args.delete(:alias => true).d
+        args.verify(:alias => true).v
+        args.lines(1, :alias => true).n
+        args.list('*', :alias => true).l
+        args.contains.c
+        args.message(nil, :alias => true).m
+        args.file(nil, :alias => true).F
+      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/participation.rb

@@ -0,0 +1,18 @@
+module V
+  module Adapters
+    module Git
+      Participation = Struct.new(:role, :name, :email, :unix_timestamp) do
+
+        def to_s
+          "#{ role } #{ name } <#{ email }> #{ unix_timestamp }"
+        end
+
+        # TODO: take TZ into account
+        def time
+          Time.at unix_timestamp.to_i
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module V
+  module Adapters
+    module Git
+      class Remote
+        attr_reader :name
+        def fetch
+        end
+        def push
+        end
+        def pull
+        end
+        def commits
+        end
+        def head
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module V
+  module Adapters
+    module Git
+      Status = Struct.new :diff do
+
+        ADDED         = :A
+        COPIED        = :C
+        DELETED       = :D
+        MODIFIED      = :M
+        RENAMED       = :R
+        TYPE_CHANGED  = :T
+        UNMERGED      = :U
+        UNKNOWN       = :X
+
+        def added?(filename)
+          index[filename] == ADDED
+        end
+        def copied?(filename)
+          index[filename] == COPIED
+        end
+        def deleted?(filename)
+          index[filename] == DELETED
+        end
+        def modified?(filename)
+          index[filename] == MODIFIED
+        end
+        def renamed?(filename)
+          index[filename] == RENAMED
+        end
+        def type_changed?(filename)
+          index[filename] == TYPE_CHANGED
+        end
+        def unmerged?(filename)
+          index[filename] == UNMERGED
+        end
+        def unknown?(filename)
+          index[filename] == UNKNOWN
+        end
+
+        def [](filename)
+          index[filename]
+        end
+
+        protected
+
+          def index
+            build_index unless defined? @index
+            @index
+          end
+          def build_index
+            @index = diff.split($/).inject({}) do |mem, line|
+              state, path = line.split("\t").map { |v| v.strip }
+              mem.update path => state.to_sym
+            end
+          end
+
+      end
+    end
+  end
+end

data/lib/v/adapters/git.rb

@@ -0,0 +1,27 @@
+module V
+  module Adapters
+    module Git
+      VERSION = [0,0,4]
+
+      # Builds Operations module.
+      Operations = Operations.new __FILE__.gsub(/\.rb$/, '')
+
+      module WorkTreeRequirement
+        # Ensures all calls require a git dir and a work tree.
+        def call(environment)
+          raise V::ENOTREPO unless File.directory? environment.git_dir
+          raise V::ENOTWTREE if environment.bare
+
+          super environment
+        end
+      end
+
+    end
+  end
+end
+
+begin
+  __dir__ = File.dirname __FILE__
+  %w[ environment branches commits index object participation status ].
+  each { |basename| require "#{ __dir__ }/git/#{ basename }" }
+end

data/lib/v/adapters.rb

@@ -0,0 +1,25 @@
+module V
+  module Adapters
+    autoload :Git, "#{ File.dirname __FILE__ }/adapters/git"
+  end
+
+  # Initialize a git environment.
+  #
+  #   Attributes => Default
+  #   :bare      => false
+  #   :work_tree => ENV || Dir.getwd
+  #   :git_dir   => ENV || bare? ? work_tree : File.join(work_tree, '.git')
+  #   :which_git => `which git`
+  def self.git(attrs = {}, &block)
+    env = Adapters::Git::Environment.new attrs
+
+    if not block_given?
+      env
+    elsif not block.arity.between?(-1, 0)
+      yield env
+    else
+      env.instance_eval(&block)
+    end
+  end
+
+end

data/lib/v/arguments.rb

@@ -0,0 +1,102 @@
+module V
+  class Arguments
+    instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A__/ }
+    
+    def initialize(op, &args)
+      @op, @first_argument = op.to_sym, nil
+
+      @slots = []
+      yield self if block_given?
+      @slots.freeze
+    end
+    
+    def method_missing(argument, *defaults)
+      options = Hash === defaults.last ? defaults.pop : {}
+      @first_argument = argument if options[:first]
+
+      slot = Slot.new argument, defaults, options
+      @slots << slot
+
+      slot
+    end
+
+    def <<(string)
+      @slots << string
+    end
+
+    def %(args)
+      opts = Hash === args.last ? args.pop : {}
+      opts[@first_argument] = args.shift if @first_argument
+
+      op_args = @slots.inject([@op]) { |ca, slot|
+        if String === slot
+          ca << slot
+        elsif key = slot.key(opts)
+          if slot.standalone? and opts[key]
+            ca << slot
+          else
+            value = opts[key]
+
+            if slot.defaults_to? value then ca
+            else
+              ca << slot.to_s % quote(value)
+            end
+          end
+        else
+          ca
+        end
+      }.concat args.map { |arg| quote arg }
+
+      op_args * ' '
+    end
+
+    def inspect
+      @slots.inspect
+    end
+
+    protected
+
+      def quote(str)
+        str = "#{ str }"
+
+        str.gsub! "\'", "'\\\\''"
+        str.gsub! ";", '\\;'
+
+        "'#{ str }'"
+      end
+
+    class Slot
+      attr_reader :to_sym
+      def initialize(argument, defaults, options)
+        @to_s, @to_sym = "#{ argument }".gsub('_', '-'), argument
+        @captures = [argument]
+        @options = options
+        @standalone, @defaults = defaults.empty?, defaults.map { |d| d.to_s }
+
+        @fstring = if @options[:rude] then '%s'
+            elsif @options[:alias] and @standalone then '-$op'
+            elsif @options[:alias] and not @standalone then '-$op %s'
+            elsif not @options[:alias] and @standalone then '--$op'
+            else '--$op=%s'
+            end
+      end
+      def method_missing(sym)
+        @captures << sym
+        @to_s = sym.to_s if @options[:alias]
+      end
+      def standalone?
+        @standalone
+      end
+      def key(opts)
+        @captures.find { |cap| opts.member? cap }
+      end
+      def defaults_to?(value)
+        @defaults.include? value.to_s
+      end
+      def to_s
+        @fstring.sub '$op', @to_s
+      end
+    end
+
+  end
+end

data/lib/v/errors.rb

@@ -0,0 +1,39 @@
+module V
+  class ERROR < RuntimeError
+    # otherwise I get these stupid parenthesis warnings...
+    def self.raise(*args)
+      target = Thread === args.last ? args.pop : Kernel
+      target.raise new(*args)
+    end
+  end
+  class ENOTREPO < ERROR
+    def initialize
+      super 'repository do not exist'
+    end
+  end
+  class ENOTWTREE < ERROR
+    def initialize
+      super 'operation must be run in a work tree'
+    end
+  end
+  class ENOOP < ERROR
+    def initialize(op_sym)
+      super "undefined operation `#{ op_sym }'"
+    end
+  end
+  class ECMDNOFO
+    def initialize(command)
+      super "#{ command }: command not found"
+    end
+  end
+  class EUNREV < ERROR
+    def initialize
+      super 'unknown revision or path not in the working tree'
+    end
+  end
+  class ECLOSED < ERROR
+    def initialize
+      super 'worker queue was closed already'
+    end
+  end
+end

data/lib/v/future.rb

@@ -0,0 +1,46 @@
+module V
+  class Future
+    instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A__/ }
+
+    def initialize(worker)
+      @worker, @waiting = worker, []
+    end
+
+    def value
+      while (Thread.critical = true; not defined? @value)
+        Thread.current != @worker or
+        raise ThreadError, 'waiting for a value in worker causes deadlock'
+        @waiting << Thread.current
+        Thread.stop
+      end
+
+      @value
+    ensure
+      Thread.critical = false
+    end
+
+    def value=(value)
+      Thread.critical = true
+      @value = value
+
+      class << self
+        def value; @value end
+      end
+
+      begin
+        while thread = @waiting.shift
+          thread.wakeup
+        end
+      rescue ThreadError
+        retry
+      ensure
+        Thread.critical = false
+      end
+    end
+
+    def method_missing(*params, &block)
+      value.send(*params, &block)
+    end
+
+  end
+end

data/lib/v/operation.rb

@@ -0,0 +1,94 @@
+module V
+
+  class Operations < Module
+
+    def initialize(load_path)
+      @load_path, @operations = load_path, {}
+    end
+
+    def included(base)
+      base.const_set :Operations, self
+
+      class_path = File.join @load_path, 'operations', '**', '*'
+      Dir[ class_path ].each { |p| require p }
+    end
+
+    TO_SYM_DEFN = %q"def self.to_sym; :'%s' end"
+    DEF_SHORTCUT = <<-RUBY
+      def %s(*args, &callback)
+        schedule (self.class)::Operations.new(:%s, *args, &callback)
+      end
+    RUBY
+    def operation(op_sym, &defn)
+      this_module = self
+      op = Class.new(Operation) { const_set :Operations, this_module }
+      op.class_eval TO_SYM_DEFN % "#{ op_sym }".gsub('_', '-')
+      op.class_eval(&defn)
+
+      module_eval DEF_SHORTCUT % [ op_sym, op_sym ]
+
+      @operations[ op_sym ] = op
+    end
+    def new(op_sym, *args, &callback)
+      op_class = @operations[op_sym] or
+      V::ENOOP.raise(op_sym)
+
+      op_class.new(*args, &callback)
+    end
+
+  end
+
+  class Operation
+    attr_reader :arguments
+
+    def self.arguments(&defn)
+      const_set :Arguments, Arguments.new(self, &defn)
+    end
+
+    def initialize(*arguments, &callback)
+      @arguments, @callback = arguments, callback
+      @hooks = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def call(environment)
+      @hooks[:pre].all? { |hook| hook[environment] != false } or throw :pre
+      value = run environment
+      @hooks[:post].all? { |hook| hook[environment] != false } or throw :post
+
+      @callback ? @callback[value] : value
+    end
+
+    def run(value)
+      raise NotImplementedError
+    end
+
+    def exec(environment)
+      sh = "#{ environment } #{ self }"
+      logger.info sh
+
+      stdout, stderr = Open3.popen3(sh) { |_, *oe| oe.map { |io| io.read } }
+      logger.debug stdout unless stdout.empty?
+      logger.error stderr unless stderr.empty?
+
+      return stdout, stderr
+    end
+
+    def to_s
+      (self.class)::Arguments % @arguments
+    end
+
+    # TODO: replace this stub
+    require 'logger'
+    @@logger = Logger.new STDERR
+    @@logger.level = Logger::INFO
+
+    def self.logger
+      @@logger
+    end
+    def logger
+      self.class.logger
+    end
+
+  end
+
+end

data/lib/v/worker.rb

@@ -0,0 +1,73 @@
+module V
+  class Worker < Thread
+    class Group < ThreadGroup
+      include Singleton
+
+      def enclose
+        super
+
+        list.
+          each { |worker| worker.stop! }.
+          each { |worker| worker.join }
+      end
+
+      at_exit {
+        if defined? Test::Unit
+          unless $! or Test::Unit.respond_to?(:run?) && Test::Unit.run?
+            test_result = Test::Unit::AutoRunner.run
+            instance.enclose
+            exit test_result
+          end
+        else
+          instance.enclose
+        end
+      }
+    end
+
+    @instances = {}
+    def self.new(git_dir)
+      @instances[git_dir] ||= super()
+    end
+
+    def initialize
+      @queue = Queue.new
+
+      super do
+        while continue?
+          operation, environment, thread, future = @queue.pop
+
+          begin
+            future.value = operation.call environment
+
+          rescue Exception => e
+            thread.raise e
+
+          end if future
+        end
+      end
+
+      if continue?
+        Group.instance.add self
+      else
+        raise V::ECLOSED
+      end
+    end
+
+    def enq(operation, environment)
+      raise V::ECLOSED unless continue?
+
+      thread, future = Thread.current, Future.new(self)
+      @queue.enq [operation, environment, thread, future]
+
+      future
+    end
+
+    def stop!
+      @queue.push nil
+    end
+    def continue?
+      not Group.instance.enclosed?
+    end
+
+  end
+end

data/lib/v.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# 
+#  v.rb
+#  v
+#  
+#  Created by Florian Aßmann on 2009-10-01.
+#  Copyright 2009 Oniversus Media, Fork Unstable Media. All rights reserved.
+# 
+
+module V
+  VERSION = [0,0,4]
+end
+
+require 'enumerator'
+require 'open3'
+require 'singleton'
+
+begin
+  require 'fastthread'
+rescue
+  RUBY_PLATFORM =~ /java/ or warn 'Please install fastthread.'
+  require 'thread'
+end
+
+begin
+  __dir__ = File.dirname __FILE__
+  %w[ errors arguments operation worker future adapters ].
+  each { |basename| require "#{ __dir__ }/v/#{ basename }" }
+end

data/test/teststrap.rb

@@ -0,0 +1,4 @@
+require 'pathname'
+require 'rubygems'
+require 'riot'
+require 'v'

data/test/v_test.rb

@@ -0,0 +1,32 @@
+require 'teststrap'
+
+context 'V' do
+  context 'git' do
+
+    setup do
+      @work_tree = Pathname.new "#{ File.dirname __FILE__ }/work_tree"
+      @work_tree.rmtree if @work_tree.directory?
+      @work_tree.mkpath
+
+      V.git :work_tree => @work_tree
+    end
+
+    should 'initialize repository' do
+      topic.init
+
+      File.directory? topic.git_dir
+    end
+    should 'add files to index' do
+      @work_tree.join('file').open('w') { |f| f << 0 }
+
+      topic.add('file').include? 'file'
+    end
+    asserts 'content of committed file' do
+      topic.index.commit 'commit file'
+      blob = topic.head.tree / 'file'
+
+      Integer blob.content
+    end.equals 0
+
+  end
+end

data/test/work_tree/file

@@ -0,0 +1 @@
+0