gollum-rjgit_adapter 0.1-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4a8a18819e637ec54da1fb7eff7701a710ce2a8b
+  data.tar.gz: 7711a47179c79831e2ebbf3b2188933b3a47ec35
+SHA512:
+  metadata.gz: 35e83bd21391eb164ffbf70c478d33c4ddf42e4632d9177a85897dc2f2f15f2be00b981ece54e4a10c36dd15e2156e8be98f024905d2b8c36e0fcc7a326c1fb8
+  data.tar.gz: 1073d9557fdb8706000fd46df10902a2f45a66e2c65d06b1955a969ea3c148cb2e7a1db0581a6d0971ef42ffa31a99b13236517e238d27adcd252acc10e10c0c

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gemspec
+gem 'rake', '~> 10.0.3'
+
+gem 'adapter_specs', :git => 'https://github.com/gollum/adapter_specs.git'
+
+group :test do
+  gem "simplecov"
+end

data/README.md

@@ -0,0 +1,4 @@
+gollum-lib_rjgit_adapter
+========================
+
+Adapter for Gollum to use RJGit at the backend

data/lib/rjgit_adapter.rb

@@ -0,0 +1 @@
+require 'rjgit_adapter/git_layer_rjgit.rb'

data/lib/rjgit_adapter/git_layer_rjgit.rb

@@ -0,0 +1,409 @@
+# ~*~ encoding: utf-8 ~*~
+
+require 'rjgit'
+require 'ostruct'
+
+module Gollum
+
+  def self.set_git_timeout(time)
+  end
+
+  def self.set_git_max_filesize(size)
+  end
+
+  module Git
+
+    import 'org.eclipse.jgit.revwalk.RevWalk'
+    import 'org.eclipse.jgit.lib.ObjectId'
+
+    # Convert HEAD refspec to jgit canonical form
+    def self.canonicalize(ref)
+      return ref if sha?(ref)
+      return "refs/heads/master" if ref.nil? || ref.to_s.upcase == "HEAD"
+      result = ref.is_a?(Gollum::Git::Ref) ? ref.name : ref
+      result = "refs/heads/#{result}" unless result =~ /^refs\/heads\//
+      result
+    end
+
+    def self.sha?(str)
+      !!(str =~ /^[0-9a-f]{40}$/)
+    end
+    
+    class Actor
+      
+      attr_accessor :name, :email
+      attr_reader :actor
+      
+      def initialize(name, email)
+        @name = name
+        @email = email
+        @actor = RJGit::Actor.new(name, email)
+      end
+      
+      def output(time)
+        @actor.output(time)
+      end
+      
+    end
+    
+    class Blob
+      
+      attr_reader :size
+      
+      # Gollum::Git::Blob.create(repo, :id => @sha, :name => name, :size => @size, :mode => @mode)
+      def self.create(repo, options)
+        blob = repo.find(options[:id], :blob)
+        jblob = blob.jblob unless blob.nil?
+        return nil if jblob.nil?
+        blob = self.new(RJGit::Blob.new(repo.repo, options[:mode], options[:name], jblob))
+        blob.set_size(options[:size]) if options[:size]
+        return blob
+      end
+      
+      def initialize(blob)
+        @blob = blob
+      end
+      
+      # Not required by gollum-lib. Should be private/protected?
+      def set_size(size)
+        @size = size
+      end
+      
+      def id
+        @blob.id
+      end
+      
+      def mode
+        @blob.mode
+      end
+      
+      def data
+        @blob.data
+      end
+      
+      def name
+        @blob.name
+      end
+      
+      def mime_type
+        @blob.mime_type
+      end
+      
+      def is_symlink
+        @blob.is_symlink?
+      end
+
+      def symlink_target(base_path = nil)
+        target = @blob.data
+        new_path = ::File.expand_path(::File.join('..', target), base_path)
+        return new_path if ::File.file? new_path
+        nil
+      end
+      
+    end
+    
+    class Commit
+      attr_reader :commit
+      
+      def initialize(commit)
+        @commit = commit
+      end
+      
+      def id
+        @commit.id
+      end
+      alias_method :sha, :id
+      alias_method :to_s, :id
+
+      def author
+        author = @commit.actor
+        Gollum::Git::Actor.new(author.name, author.email)
+      end
+      
+      def authored_date
+        @commit.authored_date
+      end
+      
+      def message
+        @commit.message
+      end
+      
+      def tree
+        Gollum::Git::Tree.new(@commit.tree)
+      end
+
+      def stats
+        return @stats unless @stats.nil?
+        rjgit_stats = @commit.stats
+        additions = rjgit_stats[0]
+        deletions = rjgit_stats[1]
+        @stats = OpenStruct.new(:additions => additions, :deletions => deletions, :files => rjgit_stats[2].to_a.map {|a| a.flatten}, :id => id, :total => additions + deletions)
+      end
+      
+    end
+    
+    class Git
+    
+      def initialize(git)
+        @git = git
+      end
+      
+      def exist?
+        ::File.exists?(@git.jrepo.getDirectory.to_s)
+      end
+      
+      def grep(query, options={})
+        ref = Gollum::Git.canonicalize(options[:ref])
+        blobs = []
+        RJGit::Porcelain.ls_tree(@git.jrepo, nil, {:ref => ref, :recursive => true, :file_path => options[:path]}).each do |item|
+          walk = RevWalk.new(@git.jrepo)
+          blobs << RJGit::Blob.new(@git.jrepo, item[:mode], item[:path], walk.lookup_blob(ObjectId.from_string(item[:id]))) if item[:type] == 'blob'
+        end
+        result = []
+        blobs.each do |blob|
+          count = blob.data.downcase.scan(/#{query}/i).length
+          result << {:name => blob.path, :count => count} if count > 0
+        end
+        result
+      end
+      
+      def rm(path, options={})
+        @git.remove(path)
+      end
+      
+      def checkout(path, ref, options = {})
+        ref = Gollum::Git.canonicalize(ref)
+        options[:paths] = [path]
+        options[:force] = true
+        options[:commit] = "#{ref}^{commit}"
+        @git.checkout(ref, options)
+      end
+      
+      # rev_list({:max_count=>1}, ref)
+      def rev_list(options, *refs)
+        raise "Not implemented"
+      end
+      
+      def ls_files(query, options = {})
+        ref = Gollum::Git.canonicalize(options[:ref])
+        result = RJGit::Porcelain.ls_tree(@git.jrepo, nil, {:ref => ref, :recursive => true, :file_path => options[:path]}).select {|object| object[:type] == "blob" && object[:path].split("/").last.scan(/#{query}/i) }
+        result.map do |r|
+          r[:path]
+        end
+      end
+      
+      def apply_patch(sha, patch = nil, options = {})
+        return false if patch.nil?
+        @git.apply_patch(patch)
+        Tree.new(RJGit::Tree.new(@git.jrepo, nil, nil, RevWalk.new(@git.jrepo).lookup_tree(@git.jrepo.resolve("HEAD^{tree}"))))
+      end
+      
+      # @repo.git.cat_file({:p => true}, sha)
+      def cat_file(options, sha)
+        @git.cat_file(options, sha)
+      end
+      
+      def log(path = nil, ref = nil, options = nil)
+        ref = Gollum::Git.canonicalize(ref)
+        @git.log(path, ref, options).map {|commit| Gollum::Git::Commit.new(commit)}
+      end
+      alias_method :versions_for_path, :log
+      
+      def refs(options, prefix)
+        @git.refs(options, prefix)
+      end
+
+      def push(remote, branch, options = {})
+        @git.push(remote, [branch].flatten, options)
+      end
+
+      def pull(remote, branch = nil, options = {})
+        @git.pull(remote, branch, options)
+      end
+      
+    end
+    
+    class Index
+      
+      def initialize(index)
+        @index = index
+        @current_tree = nil
+      end
+      
+      def delete(path)
+        @index.delete(path)
+      end
+      
+      def add(path, data)
+        @index.add(path, data)
+      end
+      
+      def commit(message, parents = nil, actor = nil, last_tree = nil, ref = "refs/heads/master")
+        ref = Gollum::Git.canonicalize(ref)
+        actor = actor ? actor.actor : RJGit::Actor.new("Gollum", "gollum@wiki")
+        parents.map!{|parent| parent.commit} if parents
+        commit_data = @index.commit(message, actor, parents, ref)
+        return false if !commit_data
+        commit_data[2]
+      end
+      
+      def tree
+        @index.treemap
+      end
+      
+      def read_tree(tree)
+        tree = tree.id if tree.is_a?(Tree)
+        begin
+          @index.current_tree = RJGit::Tree.new(@index.jrepo, nil, nil, RevWalk.new(@index.jrepo).lookup_tree(@index.jrepo.resolve("#{tree}^{tree}")))
+        rescue
+          raise Gollum::Git::NoSuchShaFound
+        end
+        @current_tree = Gollum::Git::Tree.new(@index.current_tree)
+      end
+      
+      def current_tree
+        @current_tree
+      end
+      
+    end
+    
+    class Ref
+      def initialize(name, commit)
+        @name, @commit = name, commit
+      end
+      
+      def name
+        @name
+      end
+      
+      def commit
+        Gollum::Git::Commit.new(@commit)
+      end
+            
+    end
+
+    class Diff
+      def initialize(diff)
+        @diff = diff
+      end
+      def diff
+        @diff[:patch]
+      end
+    end
+    
+    class Repo
+      
+      attr_reader :repo
+      
+      def initialize(path, options = {})
+        @repo = RJGit::Repo.new(path, options)
+      end
+      
+      def self.init(path, git_options = {}, repo_options = {})
+        RJGit::Repo.create(path, {:is_bare => false})
+        self.new(path, {:is_bare => false})
+      end
+      
+      def self.init_bare(path, git_options = {}, repo_options = {})
+        RJGit::Repo.create(path, {:is_bare => true})
+        self.new(path, {:is_bare => true})
+      end
+      
+      def bare
+        @repo.bare
+      end
+      
+      def config
+        @repo.config
+      end
+      
+      def git
+        @git ||= Gollum::Git::Git.new(@repo.git)
+      end
+      
+      def commit(ref)
+        ref = Gollum::Git.canonicalize(ref)
+        objectid = @repo.jrepo.resolve(ref)
+        return nil if objectid.nil?
+        id = objectid.name
+        commit = @repo.find(id, :commit)
+        return nil if commit.nil?
+        Gollum::Git::Commit.new(commit)
+        rescue Java::OrgEclipseJgitErrors::RevisionSyntaxException
+          raise Gollum::Git::NoSuchShaFound
+      end
+      
+      def commits(ref = nil, max_count = 10, skip = 0)
+        ref = Gollum::Git.canonicalize(ref)
+        @repo.commits(ref, max_count).map{|commit| Gollum::Git::Commit.new(commit)}
+      end
+      
+      # Not required by gollum-lib
+      def find(sha, type)
+        @repo.find(sha, type)
+      end
+      
+      # @wiki.repo.head.commit.sha
+      def head
+        Gollum::Git::Ref.new("refs/heads/master", @repo.head)
+      end
+      
+      def index
+        @index ||= Gollum::Git::Index.new(RJGit::Plumbing::Index.new(@repo))
+      end
+      
+      def log(commit = 'refs/heads/master', path = nil, options = {})
+        commit = Gollum::Git.canonicalize(commit)
+        git.log(path, commit, options)
+      end
+      
+      def lstree(sha, options={})
+        entries = RJGit::Porcelain.ls_tree(@repo.jrepo, @repo.find(sha, :tree), {:recursive => options[:recursive]})
+        entries.map! do |entry| 
+          entry[:mode] = entry[:mode].to_s(8)
+          entry[:sha]  = entry[:id]
+          entry
+        end
+      end
+      
+      def path
+        @repo.path
+      end
+      
+      def update_ref(ref = "refs/heads/master", commit_sha)
+        ref = Gollum::Git.canonicalize(head)
+        cm = self.commit(commit_sha)
+        @repo.update_ref(cm.commit, true, ref)
+      end
+
+      def diff(sha1, sha2, path = nil)
+        RJGit::Porcelain.diff(@repo, {:old_rev => sha2, :new_rev => sha1, :file_path => path, :patch => true}).map {|d| Diff.new(d)}
+      end
+     
+    end
+    
+    class Tree
+      
+      def initialize(tree)
+        @tree = tree
+      end
+      
+      def id
+        @tree.id
+      end
+      
+      def /(file)
+        @tree.send(:/, file) 
+      end
+      
+      def blobs
+        return Array.new if @tree == {}
+        @tree.blobs.map{|blob| Gollum::Git::Blob.new(blob) }
+      end
+    end
+    
+    class NoSuchShaFound < StandardError
+    end
+    
+  end
+end

data/lib/rjgit_adapter/version.rb

@@ -0,0 +1,7 @@
+module Gollum
+  module Lib
+    module Git
+      VERSION = '0.1'
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: gollum-rjgit_adapter
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: java
+authors:
+- Bart Kamphorst, Dawa Ometto
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-04-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rjgit
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  prerelease: false
+  type: :runtime
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  prerelease: false
+  type: :development
+description: Adapter for Gollum to use RJGit at the backend.
+email:
+- repotag-dev@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- lib/rjgit_adapter.rb
+- lib/rjgit_adapter/git_layer_rjgit.rb
+- lib/rjgit_adapter/version.rb
+homepage: https://github.com/repotag/gollum-lib_rjgit_adapter
+licenses: []
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.5
+signing_key:
+specification_version: 4
+summary: Adapter for Gollum to use RJGit at the backend.
+test_files: []