v 0.0.4

data/.document

@@ -0,0 +1,5 @@
+README.markdown
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,23 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+
+commit_message

data/.watchr

@@ -0,0 +1,24 @@
+require 'open3'
+
+Dir.chdir File.dirname(__FILE__)
+File.open('commit_message', 'a').close
+
+watch(/(?:commit_message)/)  { |*|
+
+  puts 'Running syntax checks...'
+  Dir['lib/**/*.rb'].inject(true) do |check, path|
+    Open3.popen3('ruby', '-c', path) { |_, o, stderr|
+      errors = stderr.read
+
+      if errors.empty? then check
+      else
+        puts errors
+        false
+      end
+    }
+  end and begin
+    puts 'Running integration tests and release...'
+    system('ruby', 'auto_commit.rb')
+  end
+
+}

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Florian Aßmann, Fork Unstable Medie, Oniversus Media
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,146 @@
+v
+=
+
+v is for versioned. It's is currently only a threaded wrapper for the git
+commands or procedures. In the future it should provide a generic interface
+for diverse VCSs.
+
+This Project does not have a separate test suite. This projects version-tracks
+itself when everything works as expected.
+
+All operations are designed to be reimplemented as pure ruby version and their
+interface is almost 1:1 mapped to their ruby derivate.
+
+Install
+-------
+
+    gem install v
+
+or unless you installed gemcutter
+
+    gem install gemcutter
+    gem tumble
+    gem install v
+
+Interface
+---------
+
+    require 'v'
+
+    V.git do
+      add '.'
+      commit 'Initial commit!'
+    end
+
+Git::Environment uses git returned by `which git` by default (\*n\*ix).
+
+### Change the git executable globally
+
+    V::Adapters::Git::Environment.which_git = '/usr/local/bin/git'
+
+### Change the git executable locally
+
+    env = V.git :which_git => '/usr/local/bin/git'
+
+    # or
+
+    V.git do
+      @which_git = '/usr/local/bin/git'
+      # ...
+    end
+
+### Working with futures...
+
+    V.git do
+      # initialize repository and return environment (as future)
+      init == self
+
+      # add root to index return a index future
+      proxy = add '.'
+      # wait for result and return index
+      proxy.value == index
+      # shortcut for add '.'
+      index == index << '.'
+
+      # commit index and return commit future
+      proxy = commit 'initial commit' 
+      # wait for result and return commit
+      commit = proxy.value
+
+      # Queries:
+      init.add('.').commit 'First argument is always the message!'
+    end
+
+_See auto\_commit.rb for more examples._
+
+Supported Operations
+--------------------
+
+ * add
+ * branch
+ * commit
+ * diff-index => diff\_index (partially)
+ * init
+ * ls-files => ls\_files (what does -v mean?)
+ * ls-tree => ls\_tree (alias for args)
+ * push
+ * rm
+ * reset
+ * log (partially)
+ * show
+ * tag
+
+Git Objects
+-----------
+
+ * normal git objects
+    * Blob
+    * Commit
+    * Tag
+    * Tree
+ * convenience objects
+    * Head
+    * Index
+    * Branch
+    * Branches
+    * Commits
+
+TODO
+----
+
+ * implement global cache / branch && git\_dir flag expired by branch mtime
+ * implement non-blocking queries
+ * implement all git operations
+ * ALL operations should return raw results which can be used by the convenience objects
+ * implement Convenience objects (git objects call commands with arguments set, ...)
+ * add Documentation and Examples
+ * Long-Term: reimplement all ops in ruby, starting with plumbing
+
+Note on Patches/Pull Requests
+-----------------------------
+
+ * Fork the project.
+ * Make your feature addition or bug fix.
+ * Add tests for it. This is important so I don't break it in a
+   future version unintentionally.
+ * Commit, do not mess with rakefile, version, or history.
+   (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+ * Send me a pull request. Bonus points for topic branches.
+
+Required
+--------
+
+ * git 1.6+
+ * fastthread
+
+Thanks
+------
+
+Linus, matz and mojombo.
+
+Copyright
+---------
+
+Copyright (c) 2009 Florian Aßmann, Fork Unstable Medie, Oniversus Media.
+See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+# coding: utf-8
+
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "v"
+    gem.summary = %Q{'florian' says: v is talking git.}
+    gem.description = %Q{v is for versioned. It's is currently only a threaded wrapper for the git commands or procedures. In the future it should provide a generic interface for diverse VCSs.}
+    gem.email = "florian.assmann@email.de"
+    gem.requirements << "fastthread"
+    gem.homepage = "http://github.com/boof/v"
+    gem.authors = ["Florian Aßmann"]
+    gem.add_development_dependency "riot", ">= 0"
+    gem.add_development_dependency "yard", ">= 0"
+    gem.add_dependency 'fastthread', '>= 1.0.7'
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

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

data/auto_commit.rb

@@ -0,0 +1,131 @@
+require 'rubygems'
+require 'lib/v.rb'
+require 'benchmark'
+Thread.abort_on_exception = true
+
+Benchmark.bm do |results|
+  results.report "Auto-Commit\n" do
+    # TODO: check bare repository
+    # V.git 'test.git' do ...
+
+    V.git do
+      # write version
+      File.open('VERSION', 'w') { |f| f << "#{ V::VERSION * '.' }" }
+
+      # add all files and reset those that should not appear in tree
+      add 'lib'
+      index.add 'VERSION', 'LICENSE', 'auto_commit.rb'
+      index << '.' # << is like: add '.'
+      index.reset 'commit_message', 'test.git', '*.gem*'
+
+      not index.include? 'v.gemspec' or
+      raise 'expected index not to include gem specific files'
+
+      not index.include? 'commit_message' or
+      raise 'expected index not to include commit_message'
+
+      # check for new version
+      new_version = (index - head).modified? 'VERSION'
+
+      # build subject
+      subject = "'#{ ENV['USER'] }' says: "
+      subject += ARGV.first || File.read('commit_message')
+
+      # tip of current branch for later use (this is a future)
+      parent = head.commit
+
+      parent == parent or raise 'expected == to work'
+
+      # raises IndexError if path does not exist
+      head.tree / 'lib/v/adapters/git.rb'
+
+      # initialize a test branch
+      test_branch = branches['test']
+      test_branch.destroy
+
+      test_branch.create
+      test_branch.exists? or
+      raise 'expected branch to exist after being created'
+
+      first_two_commits = commits.first 2
+      first_two_commits.last.parents.member? first_two_commits.first.name or
+      raise 'expected first to be correctly ordered'
+
+      last_two_commits = commits.last 2
+      last_two_commits.last.parents.member? last_two_commits.first.name or
+      raise 'expected last to be correctly ordered'
+
+      # commit changes, returns commit future but schedules after head.commit
+      head_commit = commit subject
+
+      commits.include? parent or
+      raise 'expected commits to include parent'
+      commits.last == head_commit or
+      raise 'expected last commit to be head_commit'
+
+      commits.all? { |commit| commit.is_a? V::Adapters::Git::Object } or
+      raise ' expected all commits to be kind of Git::Object'
+
+      # raises an exception if commits.last.to_s is not a String.
+      String(commits.last)
+
+      head_commit.parents[parent.name] or begin
+        p parent, head_commit, head_commit.parents
+        raise 'expected parents to include previous'
+      end
+
+      head_commit == head.commit or
+      raise 'expected head to represent current state'
+
+      head_commit.tree.content.keys.
+      all? { |basename| basename != 'commit_message' } or
+      raise 'expected content not to include commit_message'
+
+      test_branch.update head.commit
+      test_branch.head == head or
+      raise 'expected branch start at head after update'
+
+      head_commit.subject == subject.split("\n").first or begin
+        p subject.split("\n").first, head_commit, head_commit.subject
+        raise 'expected subject to be correctly quoted'
+      end
+
+      head_commit.committer.role == :committer or
+      raise 'expected role to be :committer'
+
+      test_branch.destroy
+      not test_branch.exists? and
+      raise 'expected branch not to exist after being destroyed'
+
+      if new_version
+        tag "v#{ V::VERSION * '.' }"
+        push :tags => true
+#        remotes[:origin].push :all
+        # build gem and push it to gemcutter
+      else
+#        remotes[:origin].branches["#{ head.branch }"].commits
+#        remotes[:origin].branches[ head.branch.name ].commits
+#        remotes[:origin].commits
+#        origin.commits
+
+#        push if commits.size - origin.commits.size > 6
+      end
+    end
+  end
+end
+
+__END__
+if __FILE__ == $0
+  begin
+    test_path = "#{ __DIR__ }/../test.git"
+    V.git :work_tree => test_path do
+      bare == true or raise TypeError, 'test.git should be bare'
+      init and add('config').value
+    end
+  rescue V::ENOTWTREE
+    # and here we bam'ed :D
+  ensure
+    FileUtils.rm_r test_path if File.directory? test_path
+    raise if $!
+  end
+end; end

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

@@ -0,0 +1,115 @@
+module V
+  module Adapters
+    module Git
+
+      # The head behaves like a commit.
+      class Head
+        instance_methods.each { |m| m =~ /^__/ or undef_method m }
+        attr_reader :branch, :path
+
+        def initialize(env, branch)
+          @environment, @branch = env, branch
+          @path = File.join env.git_dir, %W[ refs heads #{ branch } ]
+        end
+
+        # Returns the tip of the branch.
+        def commit
+          @environment.schedule do
+            raise V::EUNREV unless File.readable? @path
+            Commit.with @environment, :name => File.read(@path).chomp
+          end
+        end
+
+        # Delegates to commit.
+        def method_missing(meth, *args, &block)
+          commit.send meth, *args, &block
+        end
+
+      end
+
+      class Branch
+        attr_reader :name
+        alias_method :to_s, :name
+
+        def initialize(environment, name)
+          @environment, @name = environment, name
+        end
+
+        def create(*args)
+          @environment.branch @name, *args
+          return self
+        end
+
+        # Returns commits for this branch.
+        def commits(path = '.')
+          @commits ||= Commits.new @environment, self, path
+        end
+        # Returns head for this branch.
+        def head
+          @head ||= Head.new @environment, self
+        end
+
+        # Returns true if this branch has a startpoint, false otherwise.
+        def exists?
+          head.commit
+        rescue V::EUNREV
+          return false
+        end
+
+        # Returns the tip of this branch.
+        def tip
+          head.commit
+        end
+
+        def update(*args)
+          @environment.branch @name, *args.dup << { :force => true }
+          return self
+        end
+        def destroy(opts = {})
+          arguments = {}
+          arguments[ opts[:force] ? :D : :d ] = true
+          arguments[:r] = true if opts[:remote]
+
+          @environment.branch @name, arguments
+
+          return self
+        end
+
+      end
+
+      class Branches
+        include Enumerable
+        def initialize(environment)
+          @environment = environment
+          root = File.join environment.git_dir, %w[ refs heads ]
+          @glob, @offset = File.join(root, %w[ ** * ]), root.length + 1
+        end
+
+        # Returns current branch.
+        def current
+          @environment.schedule do
+            head = File.read File.join(@environment.git_dir, 'HEAD')
+            name = head.split(':', 2).last.split('/', 3).last.strip
+
+            Branch.new @environment, name
+          end
+        end
+
+
+        # Returns the branch with the given <tt>name</tt>.
+        def [](name)
+          Branch.new @environment, name
+        end
+
+        # Yields instance of Branch for each branch found in refs/heads.
+        def each
+          @environment.schedule do
+            Dir[ @glob ].each do |path|
+              yield Branch.new(@environment, path[ @offset.. -1 ])
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module V
+  module Adapters
+    module Git
+      class Commits
+        include Enumerable
+
+        def initialize(environment, branch, path)
+          @environment, @branch, @path = environment, branch, path
+        end
+
+        def first(*n)
+          to_commit names_reversed.last(*n)
+        end
+        def last(*n)
+          to_commit names_reversed.first(*n)
+        end
+
+        # TODO: work with chunks (see --max-count and --skip).
+        def each
+          commits = to_commit names_reversed
+          commits.each { |commit| yield commit } if block_given?
+
+          commits
+        end
+
+        # Returns true if name of commit is included in names of commits.
+        def include?(commit)
+          names_reversed.include? commit.name
+        end
+
+        # Returns the number of commits.
+        def size
+          names_reversed.size
+        end
+        alias_method :length, :size
+
+        protected
+
+          # Returns object names in reverse order.
+          def names_reversed
+            @environment.log(@path, :pretty => '%H').split "\n"
+          end
+
+          def to_commit(result)
+            Array === result or
+            return Commit.with(@environment, :name => result)
+
+            result.reverse!
+            result.map! { |name| Commit.with @environment, :name => name }
+          end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,99 @@
+module V
+  module Adapters
+    module Git
+      class Environment
+        include Operations
+
+        attr_reader :to_s, :bare, :work_tree, :git_dir, :branches, :index
+
+        def self.which_git=(path) @@which_git = path end
+        self.which_git = `which git`
+
+        def initialize(attrs = {})
+          assign attrs
+
+          assign_directories
+          assign_git
+          assign_string
+          assign_worker
+        end
+
+        def new?
+          schedule {
+            path = File.join @git_dir, 'refs', 'heads'
+            entries = Dir.entries(path) - %w[ . .. ]
+
+            entries.size == 0
+          }
+        end
+
+        # Tries to schedule an operation.
+        def method_missing(op_sym, *args, &callback)
+          schedule Operations.new(op_sym, *args, &callback)
+        end
+
+        # Schedules operation or proc for execution.
+        def schedule(op = nil, &block)
+          @worker.enq block || op, self
+        end
+
+        def inspect
+          @git_dir
+        end
+
+        ### Convenience
+
+        def remotes
+          @remotes
+        end
+        def origin
+          @remotes['origin']
+        end
+        # Returns collection of commits for current branch.
+        def commits(path = '.')
+          @branches.current.commits path
+        end
+        # Returns head for current branch. This is a moving target.
+        def head
+          @branches.current.head
+        end
+
+        protected
+
+          def assign(attrs)
+            attrs.each { |k, v| instance_variable_set :"@#{ k }", v }
+          end
+          def assign_directories
+            @work_tree ||= ENV['GIT_WORK_TREE'] || Dir.getwd
+            @work_tree = File.expand_path @work_tree
+
+            @bare = @work_tree[-4..-1] == '.git' unless defined? @bare
+
+            @git_dir ||= ENV['GIT_DIR']
+            @git_dir ||= @bare ? @work_tree : File.join(@work_tree, '.git')
+            @git_dir = File.expand_path @git_dir
+          end
+          def assign_git
+            @which_git ||= @@which_git
+            @which_git.strip!
+
+            raise V::ECMDNOFO, 'git' if @which_git.empty?
+
+            @branches = Branches.new self
+            @index = Index.new self
+          end
+          def assign_string
+            args = ["--no-pager"]
+            args.push @bare ? "--bare" : "--work-tree='#{ @work_tree }'"
+            args << "--git-dir='#{ @git_dir }'"
+
+            @to_s = "#{ @which_git } #{ args * ' ' }"
+          end
+          def assign_worker
+            @worker = Worker.new(@git_dir)
+          end
+
+      end
+    end
+  end
+end