rjgit 0.1.0

data/Gemfile

@@ -0,0 +1,8 @@
+source :rubygems
+
+gem "mime-types", "~> 1.15"
+
+group :test do
+  gem "rspec", "~> 2.0"
+  gem "simplecov"
+end

data/LICENSE

@@ -0,0 +1,46 @@
+# RJGit
+
+Copyright (c) 2013, Team Repotag
+
+(Modified BSD License)
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+* Neither the name of Team Repotag nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# JGit
+ 
+Eclipse Distribution License - v 1.0
+
+Copyright (c) 2007, Eclipse Foundation, Inc. and its licensors.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+* Neither the name of the Eclipse Foundation, Inc. nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# JSch
+
+Copyright (c) 2002-2012 Atsuhiko Yamanaka, JCraft,Inc. 
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+* The names of the authors may not be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL JCRAFT, INC. OR ANY CONTRIBUTORS TO THIS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,156 @@
+JGit
+=====
+
+###A JRuby wrapper around the [JGit library](https://github.com/eclipse/jgit) for manipulating Git repositories, the Ruby way.
+
+Authors
+-------
+
+RJGit is being developed by Team Repotag:
+
+- [Maarten Engelen](https://github.com/maarten)
+- [Bart Kamphorst](https://github.com/bartkamphorst)
+- [Dawa Ometto](https://github.com/dometto)
+- [Arlette van Wissen](https://github.com/arlettevanwissen)
+- [Steven Woudenberg](https://github.com/stevenwoudenberg)
+
+With special thanks to:
+- Patrick Pepels
+
+Installation
+------------
+Install the rjgit gem with the command:
+
+$ gem install rjgit
+
+#### Dependencies for using RJGit:
+- JRuby >= 1.7.0
+- mime-types >= 1.15
+
+#### Further dependencies for developing RJGIT:
+- rake >= 0.9.2.2
+- rspec >= 2.0
+- simplecov
+
+Usage
+-----
+RJGit wraps most (if not all) of JGit's core functionality; see below for some examples of what you can do with it. Make sure you have [JRuby](http://jruby.org/) installed.
+
+### Require the gem and include the RJGit module
+
+```ruby
+require "rjgit"
+include RJGit
+```
+
+### Initializing an existing repository on the filesystem
+
+```ruby
+repo = Repo.new("repo.git")
+```
+
+### Creating a new repository
+
+```ruby
+repo = Repo.new("repo.git", :create => true)
+repo = Repo.new("repo.git", :create => true, :bare => true) # Create a 'bare' git repo, which stores all git-data under the '.git' directory.
+```
+
+### Getting a list of commits
+```ruby
+repo.commits('master')
+repo.commits('959329025f67539fb82e76b02782322fad032821')
+# Similarly for getting tags, branches, trees (directories), and blobs (files).
+```
+
+### Getting tags
+```ruby
+tag = repo.tags['example_tag']
+tag.id # tag's object id
+tag.author.name # Etcetera
+```
+
+### Getting a repository's contents
+```ruby
+repo.blob("example/file.txt") # Retrieve a file by filepath
+repo.blob("example/file.txt").data # Cat the file
+repo.tree("example") # Retrieve a tree by filepath
+repo.tree("example").data # List the tree's contents (blobs and trees)
+Porcelain::ls_tree(repo, repo.tree("example"), :print => true, :recursive => true, :branch => 'mybranch') # Outputs a file list to $stdout. Passing nil as the second argument lists the entire repository. Branch defaults to HEAD.
+```
+
+### Manipulating repositories
+```ruby
+repo.create_branch('new_branch') # Similarly for deleting, renaming
+repo.checkout('new_branch')
+repo.add('new_file.txt') # Similarly for removing
+repo.commit('My message')
+```
+
+### And more...
+```ruby
+pack = RJGitReceivePack.new(repo) # Implement the smart-http protocol with RJGitReceivePack and RJGitUploadPack
+pack.receive(client_msg) # Respond to a client's GET request
+repo.config['remote origin']['url'] # Retrieve config values
+Porcelain::diff(repo, options)
+Porcelain::blame(repo, options)
+```
+
+Issues
+---------------
+Please let us know by creating a [github issue](https://github.com/repotag/rjgit/issues).
+
+Contributing
+---------------
+
+
+1. Fork the project
+1. Create a new branch
+1. Modify the sources
+1. Add specs with full coverage for your new code
+1. Make sure the whole test suite passes by running rake
+1. Push the branch up to GitHub
+1. Send us a pull request
+
+Running RSpec tests (the recommended way)
+---------------
+
+1. Start the nailgun server
+```
+jruby --ng-server &
+```
+1. Run rake against the nailgun instance
+```
+jruby --ng -S rake
+```
+
+License
+-------
+Copyright (c) 2011 - 2013, Team Repotag
+
+(Modified BSD License)
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+* Neither the name of the organization nor the
+  names of its contributors may be used to endorse or promote products
+  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/lib/actor.rb

@@ -0,0 +1,55 @@
+module RJGit
+
+  # PersonIdent in JGit
+  import 'org.eclipse.jgit.lib.PersonIdent'
+  
+  class Actor
+
+    attr_reader :name, :email, :person_ident
+    
+    RJGit.delegate_to(PersonIdent, :@person_ident)
+    
+    def self.new_from_name_and_email(name, email)
+      return self.new(PersonIdent.new(name, email))
+    end
+    alias_method :to_s, :name
+
+    def initialize(person_ident)
+      @name = person_ident.get_name
+      @email = person_ident.get_email_address
+      @person_ident = person_ident
+    end
+    
+    # Create an Actor from a string.
+    #
+    # str - The String in this format: 'John Doe <jdoe@example.com>'
+    #
+    # Returns Git::Actor.
+    def self.from_string(str)
+      if str =~ /<.+>/
+        m, name, email = *str.match(/(.*) <(.+?)>/)
+        return self.new_from_name_and_email(name, email)
+      end
+    end
+
+    # Outputs an actor string for Git commits.
+    #
+    # actor = Actor.new('bob', 'bob@email.com')
+    # actor.output(time) # => "bob <bob@email.com> UNIX_TIME +0700"
+    #
+    # time - The Time the commit was authored or committed.
+    #
+    # Returns a String.
+    def output(time)
+      offset = time.utc_offset / 60
+      "%s <%s> %d %+.2d%.2d" % [
+        @name,
+        @email || "null",
+        time.to_i,
+        offset / 60,
+        offset.abs % 60]
+    end
+
+  end 
+
+end

data/lib/blob.rb

@@ -0,0 +1,76 @@
+module RJGit
+  
+  import 'org.eclipse.jgit.revwalk.RevBlob'
+  
+  class Blob 
+    
+    attr_reader :id, :mode, :name, :path, :jblob
+    RJGit.delegate_to(RevBlob, :@jblob)
+
+    def initialize(jrepo, path, mode, jblob)
+      @jrepo = jrepo
+      @jblob = jblob
+      @path = path
+      @name = File.basename(path)
+      @mode = mode
+      @id = ObjectId.toString(jblob.get_id)
+    end
+    
+    # The size of this blob in bytes
+    #
+    # Returns Integer
+    def bytesize
+      @bytesize ||= @jrepo.open(@jblob).get_size 
+    end
+
+    def size
+      @size ||= bytesize
+    end
+    
+    def blame(options={})
+      @blame ||= RJGit::Porcelain.blame(@jrepo, @path, options)
+    end
+
+    # The binary contents of this blob.
+    # Returns String
+    def data
+      @data ||= RJGit::Porcelain.cat_file(@jrepo, @jblob) 
+    end
+
+    # The mime type of this file (based on the filename)
+    # Returns String
+    def mime_type
+      Blob.mime_type(self.name)
+    end
+
+    def self.mime_type(filename)
+      guesses = MIME::Types.type_for(filename) rescue []
+      guesses.first ? guesses.first.simplified : DEFAULT_MIME_TYPE
+    end
+    
+    # Finds a particular Blob in repository matching file_path
+    def self.find_blob(repository, file_path, branch=Constants::HEAD)
+      jrepo = RJGit.repository_type(repository)
+      last_commit_hash = jrepo.resolve(branch)
+      return nil if last_commit_hash.nil?
+
+      walk = RevWalk.new(jrepo)
+      jcommit = walk.parse_commit(last_commit_hash)
+      treewalk = TreeWalk.new(jrepo)
+      jtree = jcommit.get_tree
+      treewalk.add_tree(jtree)
+      treewalk.set_recursive(true)
+      treewalk.set_filter(PathFilter.create(file_path))
+      if treewalk.next
+        jblob = walk.lookup_blob(treewalk.objectId(0))
+        if jblob
+          mode = RJGit.get_file_mode(jrepo, file_path, jtree) 
+          Blob.new(jrepo, file_path, mode, jblob)
+        end
+      else
+        nil
+      end
+    end
+
+  end
+end

data/lib/commit.rb

@@ -0,0 +1,56 @@
+module RJGit
+
+  import 'org.eclipse.jgit.revwalk.RevWalk'
+  import 'org.eclipse.jgit.revwalk.RevCommit'
+
+  class Commit
+
+    attr_reader :id
+    attr_reader :parents
+    attr_reader :actor
+    attr_reader :committer
+    attr_reader :authored_date
+    attr_reader :committed_date
+    attr_reader :message
+    attr_reader :short_message
+    attr_reader :jcommit
+    attr_reader :count
+  
+    RJGit.delegate_to(RevCommit, :@jcommit)
+    
+    def initialize(commit)
+      @jcommit = commit
+      @id = ObjectId.to_string(commit.get_id)
+      @actor = Actor.new(@jcommit.get_author_ident)
+      @committer = Actor.new(@jcommit.get_committer_ident)
+      @committed_date = Time.at(@jcommit.commit_time)
+      @message = @jcommit.get_full_message
+      @short_message = @jcommit.get_short_message
+      @count = @jcommit.get_parent_count
+    end
+  
+    def parents
+      @parents ||= @jcommit.get_parents.map{|parent| Commit.new(parent) }
+    end
+    
+    def self.find_all(repository, ref, options)
+      repository = RJGit.repository_type(repository)
+      return nil if repository.nil?
+      begin
+        walk = RevWalk.new(repository)
+        objhead = repository.resolve(ref)
+        root = walk.parse_commit(objhead)
+        walk.mark_start(root)
+        commits = walk.map { |commit| Commit.new(commit) }
+        return commits.first(options[:limit])
+      rescue NativeException => e
+        return Array.new
+      end
+    end
+  
+    def self.diff(repo, a, b = nil, paths = [], options = {})
+    end
+    
+    
+  end
+end

data/lib/config.rb

@@ -0,0 +1,94 @@
+module RJGit
+
+  import 'org.eclipse.jgit.lib.Config'
+  
+  class Configuration
+    
+    attr_reader :jconfig, :path
+    
+    def initialize(path)
+      @path = path
+      @jconfig = org.eclipse.jgit.lib.Config.new
+    end
+    
+    def load
+      return self if @loaded
+      begin
+        @jconfig.from_text(IO.read(@path))
+        @loaded = true
+      rescue => exception
+        @loaded = false
+        raise IOException.new(exception.message)
+      end
+      return self
+    end
+    
+    def [](key)
+      section, subsection = key.split
+      build_settings_hash(section, subsection)
+    end
+    
+    def build_settings_hash(section, subsection)
+      names = names(section, subsection)
+      settings = {}
+      names.each do |name|
+        value = @jconfig.get_string(section, subsection, name)
+        if is_num?(value)
+          value = value.to_i 
+        elsif is_bool?(value)
+          value = to_boolean(value)
+        end
+        settings[name] = value
+      end
+      settings
+    end
+    
+    def is_num?(str)
+      begin
+        !!Integer(str)
+      rescue ArgumentError, TypeError
+        false
+      end
+    end
+    
+    def is_bool?(str)
+      str = str.strip
+      str == 'true' || str == 'false'
+    end
+    
+    def to_boolean(str)
+      str == "true"
+    end
+    
+    def loaded?
+      @loaded
+    end
+    
+    def sections
+      @jconfig.get_sections.to_array
+    end
+    
+    def subsections(section)
+      @jconfig.get_subsections(section).to_array
+    end
+    
+    def to_s
+      @jconfig.to_text
+    end
+    
+    def add_setting(name, value, section, subsection = "")
+      case value
+        when Integer then @jconfig.set_int(section, subsection, name, value)
+        when TrueClass then @jconfig.set_boolean(section, subsection, name, value)
+        when FalseClass then @jconfig.set_boolean(section, subsection, name, value)
+        when String then @jconfig.set_string(section, subsection, name, value)
+        else nil
+      end
+    end
+    
+    def names(section, subsection)
+      @jconfig.get_names(section, subsection).to_array
+    end
+    
+  end # Config
+end

data/lib/constants.rb

@@ -0,0 +1,16 @@
+module RJGit
+  
+  import 'org.eclipse.jgit.lib.FileMode'
+  
+  TREE_TYPE = 0040000
+  SYMLINK_TYPE = 0120000
+  FILE_TYPE = 0100000
+  GITLINK_TYPE = 0160000
+  MISSING_TYPE = 0000000
+  REG_FILE_TYPE = 0100644
+  
+  DEFAULT_MIME_TYPE = "text/plain"
+  
+  OBJ_TAG = 4
+  
+end

data/lib/git.rb

@@ -0,0 +1,228 @@
+module RJGit
+
+  import 'java.io.ByteArrayInputStream'
+  import 'java.io.FileInputStream'
+
+  import 'org.eclipse.jgit.api.Git'
+  import 'org.eclipse.jgit.api.AddCommand'
+  import 'org.eclipse.jgit.api.RmCommand'
+  import 'org.eclipse.jgit.transport.UsernamePasswordCredentialsProvider'
+  import 'org.eclipse.jgit.transport.RefSpec'
+
+  class RubyGit
+
+    attr_accessor :jgit
+    attr_accessor :jrepo
+
+    RESET_MODES = ["HARD", "SOFT", "KEEP", "MERGE", "MIXED"]
+
+    RJGit.delegate_to(Git, :@jgit)
+
+    def initialize(repository)
+      @jrepo = RJGit.repository_type(repository)
+      @jgit = Git.new(@jrepo)
+    end
+
+    def log
+      logs = @jgit.log
+      commits = Array.new
+      logs.call.each do |jcommit|
+        commits << Commit.new(jcommit)
+      end
+      commits
+    end
+
+    def branch_list
+      branch = @jgit.branch_list
+      array = Array.new
+      branch.call.each do |b|
+        array << b.get_name
+      end
+      array
+    end
+
+    def commit(message)
+      Commit.new(@jgit.commit.set_message(message).call)
+    end
+
+    def clone(remote, local, options = {})
+      RubyGit.clone(remote, local, options)
+    end
+
+    def self.clone(remote, local, options = {})
+      clone_command = Git.clone_repository
+      clone_command.setURI(remote)
+      clone_command.set_directory(java.io.File.new(local))
+      clone_command.set_bare(true) if options[:bare]
+      if options[:branch]
+        if options[:branch] == :all
+          clone_command.set_clone_all_branches(true)
+        else
+          clone_command.set_branch(options[:branch])
+        end
+      end
+      if options[:username]
+        clone_command.set_credentials_provider(UsernamePasswordCredentialsProvider.new(options[:username], options[:password]))
+      end
+      clone_command.call
+      Repo.new(local)
+    end
+
+    def add(file_pattern)
+      @jgit.add.add_filepattern(file_pattern).call
+    end
+
+    def remove(file_pattern)
+      @jgit.rm.add_filepattern(file_pattern).call
+    end
+
+    def merge(commit)
+      merge_command = @jgit.merge
+      merge_command.include(commit.jcommit)
+      result = merge_command.call
+      if result.get_merge_status.to_string == 'Conflicting'
+        return result.get_conflicts.to_hash.keys
+      else
+        return result
+      end
+    end
+
+    def tag(name, message = "", commit_or_revision = nil, actor = nil, force = false)
+      tag_command = @jgit.tag
+      tag_command.set_name(name)
+      tag_command.set_force_update(force)
+      tag_command.set_message(message)
+      tag_command.set_object_id(commit_or_revision) if commit_or_revision
+      if actor
+        actor = RJGit.actor_type(actor)
+        tag_command.set_tagger(actor)
+      end
+      tag_command.call
+    end
+
+    def resolve_tag(tagref)
+      begin
+        walk = RevWalk.new(@jrepo)
+        walk.parse_tag(tagref.get_object_id)
+      rescue Java::OrgEclipseJgitErrors::IncorrectObjectTypeException
+        nil
+      end
+    end
+
+    def create_branch(name)
+      @jgit.branch_create.setName(name).call
+    end
+
+    def delete_branch(name)
+      @jgit.branch_delete.set_branch_names(name).call
+    end
+
+    def rename_branch(old_name, new_name)
+      @jgit.branch_rename.set_old_name(old_name).set_new_name(new_name).call
+    end
+
+    def checkout(branch_name, options = {})
+      checkout_command = @jgit.checkout.set_name(branch_name)
+      checkout_command.set_create_branch(true) if options[:create]
+      checkout_command.set_force(true) if options[:force]
+      result = {}
+      begin
+        checkout_command.call
+        result[:success] = true
+        result[:result] = @jgit.get_repository.get_full_branch
+      rescue Java::OrgEclipseJgitApiErrors::CheckoutConflictException => conflict
+        result[:success] = false
+        result[:result] = conflict.get_conflicting_paths
+      end
+      result
+    end
+
+    def apply(input_stream)
+      apply_result = @jgit.apply.set_patch(input_stream).call
+      updated_files = apply_result.get_updated_files
+      updated_files_parsed = []
+      updated_files.each do |file|
+        updated_files_parsed << file.get_absolute_path
+      end
+      updated_files_parsed
+    end
+
+    def apply_patch(patch_content)
+      input_stream = ByteArrayInputStream.new(patch_content.to_java_bytes)
+      apply(input_stream)
+    end
+
+    def apply_file(patch_file)
+      input_stream = FileInputStream.new(patch_file)
+      apply(input_stream)
+    end
+
+    def clean(options = {})
+      clean_command = @jgit.clean
+      clean_command.set_dry_run(true) if options[:dryrun]
+      clean_command.set_paths(java.util.Arrays.asList(options[:paths])) if options[:paths]
+      clean_command.call
+    end
+
+    def reset(ref, mode = "HARD", paths = nil)
+      return nil if mode != nil && !RESET_MODES.include?(mode)
+      reset_command = @jgit.reset
+      if paths then
+        paths.each do |path|
+          reset_command.addPath(path)
+        end
+      end
+      reset_command.setRef(ref.id)
+      reset_command.setMode(org.eclipse.jgit.api.ResetCommand::ResetType.valueOf(mode)) unless mode == nil
+      reset_command.call
+    end
+
+    def revert(commits)
+      revert_command = @jgit.revert
+      commits.each do |commit|
+        revert_command.include commit.jcommit
+      end
+      Commit.new(revert_command.call)
+    end
+
+    def status
+      @jgit.status.call
+    end
+
+    def push_all(remote, options = {})
+      push_command = @jgit.push
+      push_command.set_dry_run(true) if options[:dryrun]
+      push_command.set_remote(remote)
+      push_command.set_push_all
+      push_command.set_push_tags
+      if options[:username]
+        push_command.set_credentials_provider(UsernamePasswordCredentialsProvider.new(options[:username], options[:password]))
+      end
+      push_command.call
+    end
+
+    def push(remote, refs = [], options = {})
+      if(refs.size > 0)
+        refs.map!{|ref| RefSpec.new(ref)}
+        push_command = @jgit.push
+        push_command.set_dry_run(true) if options[:dryrun]
+        push_command.set_remote(remote)
+        push_command.set_ref_specs(refs)
+        if options[:username]
+          push_command.set_credentials_provider(UsernamePasswordCredentialsProvider.new(options[:username], options[:password]))
+        end
+        push_command.call
+      end
+    end
+
+    def pull(options = {})
+        pull_command = @jgit.pull
+        pull_command.set_dry_run(true) if options[:dryrun]
+        pull_command.set_rebase(options[:rebase]) if options[:rebase]
+        if options[:username]
+          pull_command.set_credentials_provider(UsernamePasswordCredentialsProvider.new(options[:username], options[:password]))
+        end
+        pull_command.call
+    end
+  end
+end

data/lib/repo.rb

@@ -0,0 +1,171 @@
+module RJGit
+
+  import 'org.eclipse.jgit.lib.Repository'
+  import 'org.eclipse.jgit.lib.RepositoryBuilder'
+  import 'org.eclipse.jgit.storage.file.FileRepository'
+  import 'org.eclipse.jgit.treewalk.TreeWalk'
+  import 'org.eclipse.jgit.treewalk.filter.PathFilter'
+  import 'org.eclipse.jgit.lib.Constants'
+  import 'org.eclipse.jgit.lib.RefWriter'
+  import 'java.io.IOException'
+  
+  # Implementation of RefWriter for local files. This class is able to generate and write the $GIT_DIR/info/refs. For use in Repo::update_server_info.
+  class LocalRefWriter < RefWriter
+    attr_accessor :path
+    
+    def initialize(refs, path)
+      super(refs)
+      @path = path
+    end
+    
+    def writeFile(file, content)
+        file = File.join(@path, file)
+      begin
+        f = File.open(file, "w")
+        f.write String.from_java_bytes(content)
+        f.close
+      rescue
+        raise IOException.new # JGit API requires RefWriter.writeFile to throw IOException
+      end
+    end
+    
+  end
+  
+  class Repo
+    
+    attr_accessor :git
+    attr_accessor :jrepo
+    attr_accessor :path
+    
+    PACK_LIST = 'objects/info/packs'
+
+    RJGit.delegate_to(Repository, :@jrepo)
+    
+    def initialize(path, options = {})
+      epath = File.expand_path(path)
+
+      bare = false
+      if File.exist?(File.join(epath, '/.git'))
+        bare = false
+      elsif File.exist?(epath) || options[:bare]
+        bare = true
+      end
+
+      @path = bare ? epath : File.join(epath, '/.git')
+      @config = RJGit::Configuration.new(File.join(@path, 'config'))
+      repo_path = java.io.File.new(@path)
+      @jrepo = bare ? RepositoryBuilder.new().set_bare.set_git_dir(repo_path).build() : RepositoryBuilder.new().set_git_dir(repo_path).build()
+      @jrepo.create(bare) if options[:create]
+      @git = RubyGit.new(@jrepo)
+    end
+    
+    def bare?
+      @jrepo.is_bare
+    end
+
+    def self.create(path, options = {:bare => false})
+      options[:create] = true
+      Repo.new(path, options)
+    end
+
+    def commits(ref="master", limit=100)
+      options = { :limit => limit }
+      Commit.find_all(@jrepo, ref, options)
+    end
+
+    def config
+      @config.load
+    end
+    
+    def branch
+      @jrepo.get_full_branch
+    end
+
+    def branches
+      return @git.branch_list
+    end
+    
+    def create_branch(name)
+      @git.create_branch(name)
+    end
+    
+    def delete_branch(name)
+      @git.delete_branch(name)
+    end
+    
+    def rename_branch(old_name, new_name)
+      @git.rename_branch(old_name, new_name)
+    end
+    
+    def checkout(branch_name, options = {})
+      @git.checkout(branch_name, options)
+    end
+    alias_method :switch, :checkout
+    
+    
+    def tags(lightweight = false)
+      jtags = @jrepo.get_tags.to_hash
+      if lightweight
+        jtags.each_with_object( Hash.new ) do |(key, value), hash| 
+          hash[key] = ObjectId.to_string(value.get_object_id)
+        end
+      else
+        tags = Hash.new
+        jtags.each do |key, value|
+          jtag = @git.resolve_tag(value)
+          if jtag
+            tag = Tag.new(jtag)
+            tags[key] = tag 
+          end
+        end
+        tags
+      end
+    end
+
+    def add(file_pattern)
+      @git.add(file_pattern)
+    end
+    
+    def remove(file_pattern)
+      @git.remove(file_pattern)
+    end
+    
+    def commit(message)
+      @git.commit(message)
+    end
+    
+    def clean(options = {})
+      @git.clean(options)
+    end
+
+    # Convenience method to retrieve a Blob by name
+    def blob(file_path)
+      Blob.find_blob(@jrepo, file_path)
+    end
+
+    # Convenience method to retrieve a Tree by name
+    def tree(file_path)
+      Tree.find_tree(@jrepo, file_path)
+    end
+    
+    # Update the info files required for fetching files over the dump-HTTP protocol
+    def update_server_info
+      # First update the $GIT_DIR/refs/info file
+      refs = @jrepo.get_all_refs # Note: JGit will include directories under $GIT_DIR/refs/heads that start with a '.' in its search for refs. Filter these out in LocalRefWriter?
+      writer = LocalRefWriter.new(refs, @path)
+      writer.write_info_refs
+      
+      # Now update the $GIT_OBJECT_DIRECTORY/info/packs file
+      f = File.new(File.join(@path, PACK_LIST), "w")
+      @jrepo.get_object_database.get_packs.each do |pack|
+        f.write "P " + pack.get_pack_file.get_name + "\n"
+      end
+      f.write "\n"
+      f.close
+      
+      return true
+    end 
+
+  end
+
+end

data/lib/rjgit.rb

@@ -0,0 +1,122 @@
+module RJGit
+
+  begin
+    require 'java'
+    Dir["#{File.dirname(__FILE__)}/java/jars/*.jar"].each { |jar| require jar }
+  rescue LoadError
+    raise "You need to be running JRuby to use this gem."
+  end
+
+  def self.version
+    VERSION
+  end
+  
+  require 'stringio'
+  # gem requires
+  require 'mime/types'
+  # require helpers first because RJGit#delegate_to is needed
+  require "#{File.dirname(__FILE__)}/rjgit_helpers.rb"
+  # require everything else
+  begin
+    Dir["#{File.dirname(__FILE__)}/*.rb"].each do |file| 
+      require file
+    end
+  end
+  
+  import 'org.eclipse.jgit.lib.ObjectId'
+   
+  class Porcelain
+   
+    import 'org.eclipse.jgit.api.AddCommand'
+    import 'org.eclipse.jgit.api.CommitCommand'
+    import 'org.eclipse.jgit.api.BlameCommand'
+    import 'org.eclipse.jgit.blame.BlameGenerator'
+    import 'org.eclipse.jgit.blame.BlameResult'
+    
+    # http://wiki.eclipse.org/JGit/User_Guide#Porcelain_API
+    def self.add(repository, file_pattern)
+      repository.add(file_pattern)
+    end
+    
+    def self.commit(repository, message="")
+      repository.commit(message)
+    end
+    
+    # http://dev.eclipse.org/mhonarc/lists/jgit-dev/msg00558.html
+    def self.cat_file(repository, object)
+      bytes = repository.open(object.id).get_bytes
+      return bytes.to_a.pack('c*').force_encoding('UTF-8')
+    end
+    
+    def self.ls_tree(repository, tree=nil, options={})
+      options = {:recursive => false, :print => false, :io => $stdout, :branch => Constants::HEAD}.merge(options)
+      jrepo = RJGit.repository_type(repository)
+      return nil unless jrepo
+      if tree 
+        jtree = RJGit.tree_type(tree)
+      else
+        last_commit_hash = jrepo.resolve(options[:branch])
+        return nil unless last_commit_hash
+        walk = RevWalk.new(jrepo)
+        jcommit = walk.parse_commit(last_commit_hash)
+        jtree = jcommit.get_tree
+      end
+      treewalk = TreeWalk.new(jrepo)
+      treewalk.set_recursive(options[:recursive])
+      treewalk.add_tree(jtree)
+      entries = []
+      while treewalk.next
+        entry = {}
+        mode = treewalk.get_file_mode(0)
+        entry[:mode] = mode.get_bits
+        entry[:type] = Constants.type_string(mode.get_object_type)
+        entry[:id]   = treewalk.get_object_id(0).name
+        entry[:path] = treewalk.get_path_string
+        entries << entry
+      end
+      options[:io].puts RJGit.stringify(entries) if options[:print]
+      entries
+    end
+      
+    def self.blame(repository, file_path, options={})
+      options = {:print => false, :io => $stdout}.merge(options)
+      jrepo = RJGit.repository_type(repository)
+      return nil unless jrepo
+
+      blame_command = BlameCommand.new(jrepo)
+      blame_command.set_file_path(file_path)
+      result = blame_command.call
+      content = result.get_result_contents
+      blame = []
+      for index in (0..content.size - 1) do
+        blameline = {}
+        blameline[:actor] = Actor.new(result.get_source_author(index))
+        blameline[:line] = result.get_source_line(index)
+        blameline[:commit] = Commit.new(result.get_source_commit(index))
+        blameline[:line] = content.get_string(index)
+        blame << blameline
+      end
+      options[:io].puts RJGit.stringify(blame) if options[:print]
+      return blame
+    end
+    
+    def self.diff(repository, options = {})
+      options = {:namestatus => false}.merge(options)
+      git = repository.git.jgit
+      diff_command = git.diff
+      diff_command.set_old_tree(old_tree) if options[:old_tree]
+      diff_command.set_new_tree(new_tree) if options[:new_tree]
+      diff_command.set_path_filter(PathFilter.create(file_path)) if options[:file_path]
+      diff_command.set_show_name_and_status_only(true) if options[:namestatus] 
+      diff_command.set_cached(true) if options[:cached]
+      diff_entries = diff_command.call
+      diff_entries = diff_entries.to_array.to_ary
+      diff_entries = RJGit.convert_diff_entries(diff_entries)
+      diff_entries
+    end
+    
+  end
+  
+end
+
+

data/lib/rjgit_helpers.rb

@@ -0,0 +1,77 @@
+module RJGit
+  
+  require 'forwardable'
+  extend Forwardable
+  
+  def self.underscore(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+  
+  def self.delegate_to(klass, delegate_name)
+    java_methods = klass.java_class.declared_instance_methods.map{ |method| method.name.to_sym }
+    def_delegators delegate_name, *java_methods
+  end
+
+  def self.get_file_mode(repository, path, jtree)
+    treewalk = TreeWalk.forPath(repository, path, jtree)
+    return treewalk.get_file_mode(0).get_bits
+  end
+  
+  def self.stringify(entries)
+    str = ""
+    entries.each do |entry|
+      line = entry.values.join("\t")
+      str = "#{str}#{line}\n"
+    end
+    str
+  end
+  
+  def self.convert_diff_entries(entries)
+    entries.map do |diff_entry|
+      RJGit. diff_entry_to_hash(diff_entry)
+    end
+  end
+  
+  def self.diff_entry_to_hash(diff_entry)
+    entry = {}
+    entry[:changetype] = diff_entry.get_change_type.to_string
+    entry[:oldpath] = diff_entry.get_old_path
+    entry[:newpath] = diff_entry.get_new_path
+     entry[:oldmode] = diff_entry.get_old_mode.get_bits
+     entry[:newmode] = diff_entry.get_new_mode.get_bits
+     entry[:score] = diff_entry.get_score
+     entry[:oldid] = diff_entry.get_old_id.name
+     entry[:newid] = diff_entry.get_new_id.name
+     entry
+  end
+  
+  
+  def self.repository_type(repository)
+    repo = case repository
+      when Repo then repository.jrepo
+      when org.eclipse.jgit.lib.Repository then repository
+      else nil
+    end
+  end
+  
+  def self.actor_type(actor)
+    person_ident = case actor
+      when Actor then actor.person_ident
+      when org.eclipse.jgit.lib.PersonIdent then actor
+      else nil
+    end
+  end
+  
+  def self.tree_type(tree)
+    treeobj = case tree
+      when Tree then tree.jtree
+      when org.eclipse.jgit.revwalk.RevTree then tree
+      else nil
+    end
+  end
+    
+end

data/lib/tag.rb

@@ -0,0 +1,38 @@
+module RJGit
+  
+  import 'org.eclipse.jgit.revwalk' 
+  import 'org.eclipse.jgit.revwalk.RevTag'
+  
+  class Tag
+
+    attr_reader :id, :jtag
+    RJGit.delegate_to(RevTag, :@jtag)
+    
+    def initialize(jtag)
+      @jtag = jtag
+      @id = ObjectId.to_string(jtag.get_id)
+    end
+    
+    def full_message
+      @full_message ||= @jtag.get_full_message
+    end
+    
+    def short_message
+      @short_message ||= @jtag.get_short_message
+    end 
+    
+    def actor
+      @actor ||= Actor.new(@jtag.get_tagger_ident)
+    end
+    
+    def name
+      @name ||= @jtag.get_tag_name
+    end
+
+    def type
+      @type ||= @jtag.get_type
+    end
+    
+    
+  end
+end

data/lib/transport.rb

@@ -0,0 +1,79 @@
+module RJGit
+
+  import "org.eclipse.jgit.transport.ReceivePack"
+  import "org.eclipse.jgit.transport.UploadPack"
+  import "org.eclipse.jgit.transport.PacketLineOut"
+  import "org.eclipse.jgit.transport.RefAdvertiser$PacketLineOutRefAdvertiser"
+  import "java.io.ByteArrayInputStream"
+  import "java.io.ByteArrayOutputStream"
+
+  class RJGitPack
+    attr_accessor :jpack, :jrepo, :bidirectional
+    
+    def initialize(repository, bidirectional = false)
+      @jrepo = RJGit.repository_type(repository)
+      @bidirectional = bidirectional
+    end
+
+    def init_buffers(client_msg)
+      return ByteArrayInputStream.new(client_msg.to_java_bytes), ByteArrayOutputStream.new
+    end    
+  
+    def advertise_refs
+      out_stream = ByteArrayOutputStream.new
+      pck_out = PacketLineOut.new(out_stream)
+      advertiser = PacketLineOutRefAdvertiser.new(pck_out)
+      @jpack.sendAdvertisedRefs(advertiser)
+      return out_stream.to_string
+    end
+  end
+
+  class RJGitReceivePack < RJGitPack
+   
+    def initialize(repository, bidirectional = false)
+      super
+      @jpack = ReceivePack.new(@jrepo)
+    end
+  
+    def process(client_msg)
+      self.receive(client_msg)
+    end
+  
+    def receive(client_msg)
+      in_stream, out_stream = init_buffers(client_msg)
+      @jpack.set_bi_directional_pipe(@bidirectional)
+      begin
+        @jpack.receive(in_stream, out_stream, nil)
+      rescue Java::OrgEclipseJgitErrors::InvalidObjectIdException, Java::JavaIo::IOException => e
+        return nil, e
+      end
+      return ByteArrayInputStream.new(out_stream.to_byte_array).to_io, nil
+  end
+  
+end
+
+  class RJGitUploadPack < RJGitPack
+  
+    def initialize(repository, bidirectional = false)
+      super
+      @jpack = UploadPack.new(@jrepo)
+    end
+  
+    def process(client_msg)
+      self.upload(client_msg)
+    end
+  
+    def upload(client_msg)
+      in_stream, out_stream = init_buffers(client_msg)
+      @jpack.set_bi_directional_pipe(@bidirectional)
+      begin
+        @jpack.upload(in_stream, out_stream, nil)
+      rescue Java::OrgEclipseJgitErrors::InvalidObjectIdException, Java::OrgEclipseJgitTransport::UploadPackInternalServerErrorException, Java::JavaIo::IOException => e
+        return nil, e
+      end
+      return ByteArrayInputStream.new(out_stream.to_byte_array).to_io, nil
+    end
+  
+  end
+
+end

data/lib/tree.rb

@@ -0,0 +1,51 @@
+module RJGit
+  
+  import 'org.eclipse.jgit.revwalk' 
+  import 'org.eclipse.jgit.revwalk.RevTree'
+  
+  class Tree 
+
+    attr_reader :contents, :id, :mode, :name, :repo, :jtree
+    RJGit.delegate_to(RevTree, :@jtree)
+    
+    def initialize(repository, mode, path, jtree)
+      @repo = repository
+      @mode = mode
+      @path = path
+      @name = File.basename(path)
+      @jtree = jtree
+      @id = ObjectId.to_string(jtree.get_id)
+    end
+    
+    def data
+      strio = StringIO.new
+      RJGit::Porcelain.ls_tree(@repo, @jtree, options={:print => true, :io => strio})
+      strio.string
+    end
+    
+    def self.find_tree(repository, file_path, branch=Constants::HEAD)
+      jrepo = RJGit.repository_type(repository)
+      return nil if jrepo.nil?
+      last_commit_hash = jrepo.resolve(branch)
+      return nil if last_commit_hash.nil?
+
+      walk = RevWalk.new(jrepo)
+      commit = walk.parse_commit(last_commit_hash)
+      treewalk = TreeWalk.new(jrepo)
+      jtree = commit.get_tree
+      treewalk.add_tree(jtree)
+      treewalk.set_filter(PathFilter.create(file_path))
+      if treewalk.next
+        jsubtree = walk.lookup_tree(treewalk.object_id(0))
+        if jsubtree
+          mode = RJGit.get_file_mode(jrepo, file_path, jtree) 
+          Tree.new(jrepo, mode, file_path, jsubtree)
+        end
+      else
+        nil
+      end
+    end
+    
+  end
+  
+end

data/lib/version.rb

@@ -0,0 +1,3 @@
+module RJGit
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: rjgit
+version: !ruby/object:Gem::Version
+  prerelease:
+  version: 0.1.0
+platform: ruby
+authors:
+- Maarten Engelen
+- Bart Kamphorst
+- Dawa Ometto
+- Arlette van Wissen
+- Steven Woudenberg
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2013-04-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mime-types
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+    none: false
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+    none: false
+  prerelease: false
+  type: :runtime
+description: JRuby wrapper around the JGit library for manipulating git repositories in code.
+email: repotag-dev@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- lib/actor.rb
+- lib/blob.rb
+- lib/commit.rb
+- lib/config.rb
+- lib/constants.rb
+- lib/git.rb
+- lib/repo.rb
+- lib/rjgit.rb
+- lib/rjgit_helpers.rb
+- lib/tag.rb
+- lib/transport.rb
+- lib/tree.rb
+- lib/version.rb
+- README.md
+- LICENSE
+- Gemfile
+- lib/java/jars/jsch-0.1.49.jar
+- lib/java/jars/org.eclipse.jgit-2.3.1.201302201838-r.jar
+homepage: https://github.com/repotag/rjgit
+licenses: []
+post_install_message:
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: !binary |-
+        MA==
+  none: false
+requirements: []
+rubyforge_project:
+rubygems_version: 1.8.24
+signing_key:
+specification_version: 3
+summary: JRuby wrapper around the JGit library.
+test_files: []