jbox-gitolite 1.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f37bb126327d01abd1e3fb270b1da512d823c68f
+  data.tar.gz: 0d8485bf1ac13abebfeba9329cb2a31829941d69
+SHA512:
+  metadata.gz: 6beb1f436fabad483f7e88c0a9633a7d24c1cf2393fa61046b32c2fd678da7c2f0abde8200624aa48f52aac9235e962df0dc037afde248df562493da437dba41
+  data.tar.gz: dee2cb5e1f9c97988cb9ccea6ad0b63e1eecb45a08a19c16365450228ce3f310016a277027dacc1edcfecddaddc71c79baa1226539f472390b7ab17fdc22174c

data/.gitignore

@@ -0,0 +1,7 @@
+pkg/*
+*.gem
+.bundle
+rdoc/*
+*.conf
+coverage
+*.lock

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+ - 1.9.3
+ - rbx-19mode

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gitolite.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2010-2011 Stafford Brunk
+
+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,190 @@
+# gitolite [![Build Status](https://secure.travis-ci.org/wingrunr21/gitolite.png)](http://travis-ci.org/wingrunr21/gitolite)
+
+This gem is designed to provide a Ruby interface to the [gitolite](https://github.com/sitaramc/gitolite) git backend system.  I am aiming to provide all management functionality that is available via the gitolite-admin repository (like SSH keys, repository permissions, etc)
+
+This gem can still have problems.  Please file an issue if you encounter a bug.  If you have a feature request, file one please.
+
+## Features ##
+* Allows for the creation and management of repos within gitolite
+* Allows for the creation and deletion of SSH keys within gitolite
+* Allows for the bootstrapping of a gitolite-admin repository
+
+## Requirements ##
+* Ruby 1.8.x or 1.9.x
+* a working [gitolite](https://github.com/sitaramc/gitolite) installation
+* the <tt>gitolite-admin</tt> repository checked out locally
+
+## Installation ##
+
+    gem install gitolite
+
+## Usage ##
+
+### Load a gitolite-admin repo ###
+
+    require 'gitolite'
+    ga_repo = Gitolite::GitoliteAdmin.new("/path/to/gitolite/admin/repo")
+
+This method can only be called on an existing gitolite-admin repo.  If you need to create a new gitolite-admin repo, see "Bootstrapping".
+
+### Configuration Files ###
+
+    conf = ga_repo.config
+
+    #Empty configs can also be initialized
+    conf2 = Config.init # => defaults to a filename of gitolite.conf
+    conf2 = Config.init("new_config.conf")
+
+    #Filename is set to whatever the filename was when the config was created
+    conf.filename # => "gitolite.conf"
+    conf2.filename # => "new_config.conf")
+
+    #filename can be changed via the setter
+    conf2.filename = "new_config.conf"
+
+    #to_file will write the config out to the file system
+    #using the value of the filename attribute.  An alternative
+    #filename can also be specified
+    conf.to_file("/new/config/path") # => writes /new/config/path/gitolite.conf
+    conf.to_file("/new/config/path", "test.conf") # => writes /new/config/path/test.conf
+
+### Repo management ###
+
+    repo = Gitolite::Config::Repo.new("AwesomeRepo")
+
+    #For a list of permissions, see http://sitaramc.github.com/gitolite/conf.html#gitolite
+    repo.add_permission("RW+", "", "bob", "joe", "susan")
+
+    #Set a git config option to the repo
+    repo.set_git_config("hooks.mailinglist", "gitolite-commits@example.tld") # => "gitolite-commits@example.tld"
+
+    #Unset a git config option from the repo
+    repo.unset_git_config("hooks.mailinglist") # => "gitolite-commits@example.tld"
+
+    #Set a gitolite option to the repo
+    repo.set_gitolite_option("mirroring.master", "kenobi") # => "kenobi"
+
+    #Remove a gitolite option from the repo
+    repo.unset_gitolite_option("mirroring.master") # => "kenobi"
+
+    #Add repo to config
+    conf.add_repo(repo)
+
+    #Delete repo by object
+    conf.rm_repo(repo)
+
+    #Delete a repo by name
+    conf.rm_repo("AwesomeRepo")
+    conf.rm_repo(:AwesomeRepo)
+
+    #Test if repo exists by name
+    conf.has_repo?('cool_repo') # => false
+    conf.has_repo?(:cool_repo) # => false
+
+    #Can also pass a Gitolite::Config::Repo object
+    repo = Gitolite::Config::Repo.new('cool_repo')
+    conf.has_repo?(repo) # => true
+
+    #Get a repo object from the config
+    repo = conf.get_repo('cool_repo')
+    repo = conf.get_repo(:cool_repo)
+
+### SSH Key Management ###
+
+    #Three ways to create keys: manually, from an existing key, or from a string representing a key
+    key = Gitolite::SSHKey.new("ssh-rsa", "big-public-key-blob", "email")
+    key2 = Gitolite::SSHKey.from_file("/path/to/ssh/key.pub")
+
+    key_string = File.read("/path/to/ssh/key.pub")
+    key3 = Gitolite::SSHKey.from_string(key_string, "owner")
+
+    #Add the keys
+    ga_repo.add_key(key)
+    ga_repo.add_key(key2)
+    ga_repo.add_key(key3)
+
+    #Remove key2
+    ga_repo.rm_key(key2)
+
+### Save changes ###
+
+    ga_repo.save
+
+When this method is called, all changes get written to the file system and staged in git.  For the time being, gitolite assumes full control of the gitolite-admin repository.  This means that any keys in the keydir that are not being tracked will be removed and any human changes to gitolite.conf will be erased.
+
+### Apply changes ###
+    ga_repo.apply
+
+This method will commit all changes with a generic message (will be improved upon later) and push to <tt>origin master</tt>.
+
+### Save and apply ###
+    ga_repo.save_and_apply
+
+### Updating remote changes ###
+    #In order to avoid conflicts, this will perform a reset! by default
+    #pass :reset => false to disable the reset (Git conflicts will have to be manually fixed)
+    ga_repo.update
+    ga_repo.update(:reset => false)
+
+    #Update while performing a rebase
+    ga_repo.update(:rebase => true)
+
+### Reloading from the file system ###
+    ga_repo.reload!
+
+### Resetting to HEAD, destroying all local changes (including untracked files) ###
+    #This will also perform a reload!
+    ga_repo.reset!
+
+### Bootstrapping ###
+    ga_repo = GitoliteAdmin.bootstrap("/path/to/new/gitolite/repo")
+
+This will create the folders <tt>conf</tt> and <tt>keydir</tt> in the supplied path.  A config file will also be created in the conf directory.  The default configuration supplies RW+ permissions to a user named git for a repo named <tt>gitolite-admin</tt>.  You can specify an options hash to change some values:
+
+    ga_repo = GitoliteAdmin.bootstrap("/path/to/new/gitolite/repo", {:user => "admin", :perm => "RW"})
+
+You can also pass a message to be used for the initial bootstrap commit:
+
+    ga_repo = GitoliteAdmin.bootstrap("/path/to/new/gitolite/repo", {:message => "Bootstrapped new repo"})
+
+Please note that while bootstrapping is supported, I highly recommend that the initial gitolite-admin repo be created by gitolite itself.
+
+## Caveats ##
+### Windows compatibility ###
+The grit gem (which is used for under-the-hood git operations) does not currently support Windows.  Until it does, gitolite will be unable to support Windows.
+
+### Group Ordering ###
+When the gitolite backend parses the config file, it does so in one pass.  Because of this, groups that are modified after being used do not see those changes reflected in previous uses.
+
+For example:
+
+    @groupa = bob joe sue
+    @groupb = jim @groupa
+    @groupa = sam
+
+Group b will contain the users <tt>jim, bob, joe, and sue</tt>
+
+The gitolite gem, on the other hand, will <em>always</em> output groups so that all modifications are represented before it is ever used.  For the above example, group b will be output with the following users: <tt>jim, bob, joe, sue, and sam</tt>.  The groups in the config file will look like this:
+
+    @groupa = bob joe sue sam
+    @groupb = jim @groupa
+
+## Issues ##
+* Gem is not thread safe.  For now, the gem will change directories in order to perform git operations.  It will, however, return to the old working directory once it is finished.  I am looking into making the gem thread safe.  Note that this is only an issue on Rubies that do not have a GIL (ex jRuby or Rubinius)
+
+# Contributing #
+* Tests!  If you ask me to pull changes that are not adequately tested,  I'm not going to do it.
+* If you introduce new features/public methods on objects, you must update the README.
+
+### Contributors ###
+* Alexander Simonov - [simonoff](https://github.com/simonoff)
+* Pierre Guinoiseau - [peikk0](https://github.com/peikk0)
+
+## Documentation ##
+* Rdoc is coming eventually
+
+## Future ##
+* support folders in the keydir
+* support include tags
+* cleanup methods to make adding and removing easier (like add_key should accept an array of keys)
+* Make the gem thread safe

data/Rakefile

@@ -0,0 +1,33 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+require 'rspec/core/rake_task'
+
+# Rake tasks from https://github.com/mojombo/rakegem/blob/master/Rakefile
+
+# Helper Functions
+def name
+  @name ||= Dir['*.gemspec'].first.split('.').first
+end
+
+def version
+  line = File.read("lib/#{name}/version.rb")[/^\s*VERSION\s*=\s*.*/]
+  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+end
+
+# Standard tasks
+RSpec::Core::RakeTask.new(:spec)
+task :test => :spec
+task :default => :spec
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "#{name} #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -r ./lib/#{name}.rb"
+end

data/gitolite.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gitolite/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jbox-gitolite"
+  s.version     = Gitolite::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nicolas Rodriguez"]
+  s.email       = ["nrodriguez@jbox-web.com"]
+  s.homepage    = "https://github.com/n-rodriguez/gitolite"
+  s.summary     = %q{A Ruby gem for manipulating the gitolite git backend via the gitolite-admin repository.}
+  s.description = %q{This gem is designed to provide a Ruby interface to the gitolite git backend system.  This gem aims to provide all management functionality that is available via the gitolite-admin repository (like SSH keys, repository permissions, etc)}
+  s.license     = 'MIT'
+
+  s.rubyforge_project = "jbox-gitolite"
+
+  s.add_development_dependency "rspec", "~> 2.9.0"
+  s.add_development_dependency "forgery", "~> 0.5.0"
+  s.add_development_dependency "rdoc", "~> 3.12"
+  s.add_development_dependency "simplecov", "~> 0.6.2"
+  s.add_development_dependency "rake", "~> 10.0.2"
+
+  s.add_dependency "gitlab-grit", "~> 2.6.0"
+  s.add_dependency "hashery", "~> 1.5.0"
+  s.add_dependency "gratr19", "~> 0.4.4.1"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/gitolite.rb

@@ -0,0 +1,8 @@
+module Gitolite
+  require 'grit'
+  require 'hashery'
+  require 'gratr'
+  require 'gitolite/ssh_key'
+  require 'gitolite/config'
+  require 'gitolite/gitolite_admin'
+end

data/lib/gitolite/config.rb

@@ -0,0 +1,253 @@
+require 'tempfile'
+require File.join(File.dirname(__FILE__), 'config', 'repo')
+require File.join(File.dirname(__FILE__), 'config', 'group')
+
+module Gitolite
+  class Config
+    attr_accessor :repos, :groups, :filename
+
+    def initialize(config)
+      @repos = {}
+      @groups = {}
+      @filename = File.basename(config)
+      process_config(config)
+    end
+
+    def self.init(filename = "gitolite.conf")
+      file = Tempfile.new(filename)
+      conf = self.new(file.path)
+      conf.filename = filename #kill suffix added by Tempfile
+      file.close(unlink_now = true)
+      conf
+    end
+
+    #TODO: merge repo unless overwrite = true
+    def add_repo(repo, overwrite = false)
+      raise ArgumentError, "Repo must be of type Gitolite::Config::Repo!" unless repo.instance_of? Gitolite::Config::Repo
+      @repos[repo.name] = repo
+    end
+
+    def rm_repo(repo)
+      name = normalize_repo_name(repo)
+      @repos.delete(name)
+    end
+
+    def has_repo?(repo)
+      name = normalize_repo_name(repo)
+      @repos.has_key?(name)
+    end
+
+    def get_repo(repo)
+      name = normalize_repo_name(repo)
+      @repos[name]
+    end
+
+    def add_group(group, overwrite = false)
+      raise ArgumentError, "Group must be of type Gitolite::Config::Group!" unless group.instance_of? Gitolite::Config::Group
+      @groups[group.name] = group
+    end
+
+    def rm_group(group)
+      name = normalize_group_name(group)
+      @groups.delete(name)
+    end
+
+    def has_group?(group)
+      name = normalize_group_name(group)
+      @groups.has_key?(name)
+    end
+
+    def get_group(group)
+      name = normalize_group_name(group)
+      @groups[name]
+    end
+
+    def to_file(path=".", filename=@filename)
+      raise ArgumentError, "Path contains a filename or does not exist" unless File.directory?(path)
+
+      new_conf = File.join(path, filename)
+      File.open(new_conf, "w") do |f|
+        #Output groups
+        dep_order = build_groups_depgraph
+        dep_order.each {|group| f.write group.to_s }
+
+        gitweb_descs = []
+        @repos.sort.each do |k, v|
+          f.write "\n"
+          f.write v.to_s
+
+          gwd = v.gitweb_description
+          gitweb_descs.push(gwd) unless gwd.nil?
+        end
+
+        f.write "\n"
+        f.write gitweb_descs.join("\n")
+      end
+
+      new_conf
+    end
+
+    private
+      #Based on
+      #https://github.com/sitaramc/gitolite/blob/pu/src/gl-compile-conf#cleanup_conf_line
+      def cleanup_config_line(line)
+        #remove comments, even those that happen inline
+        line.gsub!(/^((".*?"|[^#"])*)#.*/) {|m| m=$1}
+
+        #fix whitespace
+        line.gsub!('=', ' = ')
+        line.gsub!(/\s+/, ' ')
+        line.strip
+      end
+
+      def process_config(config)
+        context = [] #will store our context for permissions or config declarations
+
+        #Read each line of our config
+        File.open(config, 'r').each do |l|
+
+          line = cleanup_config_line(l)
+          next if line.empty? #lines are empty if we killed a comment
+
+          case line
+            #found a repo definition
+            when /^repo (.*)/
+              #Empty our current context
+              context = []
+
+              repos = $1.split
+              repos.each do |r|
+                context << r
+
+                @repos[r] = Repo.new(r) unless has_repo?(r)
+              end
+            #repo permissions
+            when /^(-|C|R|RW\+?(?:C?D?|D?C?)M?) (.* )?= (.+)/
+              perm = $1
+              refex = $2 || ""
+              users = $3.split
+
+              context.each do |c|
+                @repos[c].add_permission(perm, refex, users)
+              end
+            #repo git config
+            when /^config (.+) = ?(.*)/
+              key = $1
+              value = $2
+
+              context.each do |c|
+                @repos[c].set_git_config(key, value)
+              end
+            #repo gitolite option
+            when /^option (.+) = (.*)/
+              key = $1
+              value = $2
+
+              raise ParseError, "Missing gitolite option value for repo: #{repo} and key: #{key}" if value.nil?
+
+              context.each do |c|
+                @repos[c].set_gitolite_option(key, value)
+              end
+            #group definition
+            when /^#{Group::PREPEND_CHAR}(\S+) = ?(.*)/
+              group = $1
+              users = $2.split
+
+              @groups[group] = Group.new(group) unless has_group?(group)
+              @groups[group].add_users(users)
+            #gitweb definition
+            when /^(\S+)(?: "(.*?)")? = "(.*)"$/
+              repo = $1
+              owner = $2
+              description = $3
+
+              #Check for missing description
+              raise ParseError, "Missing Gitweb description for repo: #{repo}" if description.nil?
+
+              #Check for groups
+              raise ParseError, "Gitweb descriptions cannot be set for groups" if repo =~ /@.+/
+
+              if has_repo? repo
+                r = @repos[repo]
+              else
+                r = Repo.new(repo)
+                add_repo(r)
+              end
+
+              r.owner = owner
+              r.description = description
+            when /^include "(.+)"/
+              #TODO: implement includes
+              #ignore includes for now
+            when /^subconf (\S+)$/
+              #TODO: implement subconfs
+              #ignore subconfs for now
+            else
+              raise ParseError, "'#{line}' cannot be processed"
+          end
+        end
+      end
+
+      # Normalizes the various different input objects to Strings
+      def normalize_name(context, constant = nil)
+        case context
+          when constant
+            context.name
+          when Symbol
+            context.to_s
+          else
+            context
+        end
+      end
+
+      def method_missing(meth, *args, &block)
+        if meth.to_s =~ /normalize_(\w+)_name/
+          #Could use Object.const_get to figure out the constant here
+          #but for only two cases, this is more readable
+          case $1
+            when "repo"
+              normalize_name(args[0], Gitolite::Config::Repo)
+            when "group"
+              normalize_name(args[0], Gitolite::Config::Group)
+          end
+        else
+          super
+        end
+      end
+
+      # Builds a dependency tree from the groups in order to ensure all groups
+      # are defined before they are used
+      def build_groups_depgraph
+        dp = ::GRATR::Digraph.new
+
+        # Add each group to the graph
+        @groups.each_value do |group|
+          dp.add_vertex! group
+
+          # Select group names from the users
+          subgroups = group.users.select {|u| u =~ /^#{Group::PREPEND_CHAR}.*$/}.map{|g| get_group g.gsub(Group::PREPEND_CHAR, '') }
+
+          subgroups.each do |subgroup|
+            dp.add_edge! subgroup, group
+          end
+        end
+
+        # Figure out if we have a good depedency graph
+        dep_order = dp.topsort
+
+        if dep_order.empty?
+          raise GroupDependencyError unless @groups.empty?
+        end
+
+        dep_order
+      end
+
+      #Raised when something in a config fails to parse properly
+      class ParseError < RuntimeError
+      end
+
+      # Raised when group dependencies cannot be suitably resolved for output
+      class GroupDependencyError < RuntimeError
+      end
+  end
+end