gitolite 0.0.3.alpha → 1.0.0

data/Gemfile.lock

@@ -1,30 +1,40 @@
 PATH
   remote: .
   specs:
-    gitolite (0.0.3.alpha)
-      grit (~> 2.4.1)
-      hashery (~> 1.4.0)
+    gitolite (0.0.4.alpha)
+      grit (~> 2.5.0)
+      hashery (~> 1.5.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
-    diff-lcs (1.1.2)
+    blankslate (2.1.2.4)
+    diff-lcs (1.1.3)
     forgery (0.5.0)
-    grit (2.4.1)
+    grit (2.5.0)
       diff-lcs (~> 1.1)
       mime-types (~> 1.15)
-    hashery (1.4.0)
-    mime-types (1.16)
-    rcov (0.9.11)
-    rdoc (3.9.4)
-    rspec (2.6.0)
-      rspec-core (~> 2.6.0)
-      rspec-expectations (~> 2.6.0)
-      rspec-mocks (~> 2.6.0)
-    rspec-core (2.6.0)
-    rspec-expectations (2.6.0)
-      diff-lcs (~> 1.1.2)
-    rspec-mocks (2.6.0)
+      posix-spawn (~> 0.3.6)
+    hashery (1.5.0)
+      blankslate
+    json (1.6.6)
+    mime-types (1.18)
+    multi_json (1.3.2)
+    posix-spawn (0.3.6)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+    simplecov (0.6.2)
+      multi_json (~> 1.3)
+      simplecov-html (~> 0.5.3)
+    simplecov-html (0.5.3)
 
 PLATFORMS
   ruby
@@ -32,6 +42,6 @@ PLATFORMS
 DEPENDENCIES
   forgery (~> 0.5.0)
   gitolite!
-  rcov (~> 0.9.11)
-  rdoc (~> 3.9.4)
-  rspec (~> 2.6.0)
+  rdoc (~> 3.12)
+  rspec (~> 2.9.0)
+  simplecov (~> 0.6.2)

data/README.markdown

@@ -0,0 +1,179 @@
+# 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
+
+## 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.
+
+## 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")
+
+    #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
+
+# 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)
+
+## 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
+* Rails integration via [gitolite-rails](https://www.github.com/wingrunr21/gitolite-rails)

data/gitolite.gemspec

@@ -14,12 +14,13 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "gitolite"
 
-  s.add_development_dependency "rspec", "~> 2.6.0"
+  s.add_development_dependency "rspec", "~> 2.9.0"
   s.add_development_dependency "forgery", "~> 0.5.0"
-  s.add_development_dependency "rdoc", "~> 3.9.4"
-  s.add_development_dependency "rcov", "~> 0.9.11"
-  s.add_dependency "grit", "~> 2.4.1"
-  s.add_dependency "hashery", "~> 1.4.0"
+  s.add_development_dependency "rdoc", "~> 3.12"
+  s.add_development_dependency "simplecov", "~> 0.6.2"
+  s.add_dependency "grit", "~> 2.5.0"
+  s.add_dependency "hashery", "~> 1.5.0"
+  s.add_dependency "plexus", "~> 0.5.10"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/gitolite.rb

@@ -1,6 +1,7 @@
 module Gitolite
   require 'grit'
   require 'hashery'
+  require 'plexus'
   require 'gitolite/ssh_key'
   require 'gitolite/config'
   require 'gitolite/gitolite_admin'

data/lib/gitolite/config.rb

@@ -68,7 +68,8 @@ module Gitolite
       new_conf = File.join(path, filename)
       File.open(new_conf, "w") do |f|
         #Output groups
-        @groups.each_value {|group| f.write group.to_s }
+        dep_order = build_groups_depgraph
+        dep_order.each {|group| f.write group.to_s }
 
         gitweb_descs = []
         @repos.each do |k, v|
@@ -106,7 +107,7 @@ module Gitolite
           line = cleanup_config_line(l)
           next if line.empty? #lines are empty if we killed a comment
 
-          case line.strip
+          case line
             #found a repo definition
             when /^repo (.*)/
               #Empty our current context
@@ -119,7 +120,7 @@ module Gitolite
                 @repos[r] = Repo.new(r) unless has_repo?(r)
               end
             #repo permissions
-            when /^(-|C|R|RW\+?(?:C?D?|D?C?)) (.* )?= (.+)/
+            when /^(-|C|R|RW\+?(?:C?D?|D?C?)M?) (.* )?= (.+)/
               perm = $1
               refex = $2 || ""
               users = $3.split
@@ -199,8 +200,38 @@ module Gitolite
         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 = ::Plexus::Digraph.new
+
+        # Add each group to the graph
+        @groups.each_value do |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

data/lib/gitolite/config/repo.rb

@@ -1,11 +1,9 @@
-require 'hashery'
-
 module Gitolite
   class Config
     #Represents a repo inside the gitolite configuration.  The name, permissions, and git config
     #options are all encapsulated in this class
     class Repo
-      ALLOWED_PERMISSIONS = /-|R|RW+?C?D?/
+      ALLOWED_PERMISSIONS = /-|C|R|RW\+?(?:C?D?|D?C?)M?/
 
       attr_accessor :permissions, :name, :config, :owner, :description
 

data/lib/gitolite/gitolite_admin.rb

@@ -6,17 +6,21 @@ module Gitolite
     CONFDIR = "conf"
     KEYDIR = "keydir"
 
+    #Gitolite gem's default git commit message
+    DEFAULT_COMMIT_MSG = "Committed by the gitolite gem"
+
     # Intialize with the path to
     # the gitolite-admin repository
     def initialize(path, options = {})
+      @path = path
       @gl_admin = Grit::Repo.new(path)
 
       @conf = options[:conf] || CONF
       @confdir = options[:confdir] || CONFDIR
       @keydir = options[:keydir] || KEYDIR
 
-      @ssh_keys = load_keys(File.join(path, @keydir))
-      @config = Config.new(File.join(path, @confdir, @conf))
+      # Load the ssh keys and the configuration
+      load_data
     end
 
     # This method will bootstrap a gitolite-admin repo
@@ -80,20 +84,50 @@ module Gitolite
       end
     end
 
+    # This method will destroy all local tracked changes, resetting the local gitolite
+    # git repo to HEAD and reloading the entire repository
+    # Note that this will also delete all untracked files
+    def reset!
+      Dir.chdir(@gl_admin.working_dir) do
+        @gl_admin.git.reset({:hard => true}, 'HEAD')
+        @gl_admin.git.clean({:d => true, :q => true, :f => true})
+      end
+      reload!
+    end
+
+    # This method will destroy the in-memory data structures and reload everything
+    # from the file system
+    def reload!
+      load_data
+    end
+
     #commits all staged changes and pushes back
     #to origin
     #
     #TODO: generate a better commit message
     #TODO: add the ability to specify the remote and branch
     #TODO: detect existance of origin instead of just dying
-    def apply(commit_message = "Commit by gitolite gem")
+    def apply(commit_message = DEFAULT_COMMIT_MSG)
       @gl_admin.commit_index(commit_message)
       @gl_admin.git.push({}, "origin", "master")
     end
 
-    def save_and_apply
+    def save_and_apply(commit_message = DEFAULT_COMMIT_MSG)
       self.save
-      self.apply
+      self.apply(commit_message)
+    end
+
+    # Updates the repo with changes from remote master
+    def update(options = {})
+      options = {:reset => true, :rebase => false }.merge(options)
+
+      reset! if options[:reset]
+
+      Dir.chdir(@gl_admin.working_dir) do
+        @gl_admin.git.pull({:rebase => options[:rebase]}, "origin", "master")
+      end
+
+      reload!
     end
 
     def add_key(key)
@@ -102,6 +136,7 @@ module Gitolite
     end
 
     def rm_key(key)
+      raise "Key must be of type Gitolite::SSHKey!" unless key.instance_of? Gitolite::SSHKey
       @ssh_keys[key.owner].delete key
     end
 
@@ -124,6 +159,11 @@ module Gitolite
     end
 
     private
+      def load_data
+        @ssh_keys = load_keys(File.join(@path, @keydir))
+        @config = Config.new(File.join(@path, @confdir, @conf))
+      end
+
       #Loads all .pub files in the gitolite-admin
       #keydir directory
       def load_keys(path)