gitolite 0.0.2.alpha → 0.0.3.alpha

data/.gitignore

@@ -1,3 +1,6 @@
 pkg/*
 *.gem
 .bundle
+rdoc/*
+*.conf
+coverage

data/Gemfile.lock

@@ -1,32 +1,37 @@
 PATH
   remote: .
   specs:
-    gitolite (0.0.1.alpha)
+    gitolite (0.0.3.alpha)
       grit (~> 2.4.1)
+      hashery (~> 1.4.0)
 
 GEM
   remote: http://rubygems.org/
   specs:
     diff-lcs (1.1.2)
-    forgery (0.3.6)
+    forgery (0.5.0)
     grit (2.4.1)
       diff-lcs (~> 1.1)
       mime-types (~> 1.15)
+    hashery (1.4.0)
     mime-types (1.16)
-    rspec (2.4.0)
-      rspec-core (~> 2.4.0)
-      rspec-expectations (~> 2.4.0)
-      rspec-mocks (~> 2.4.0)
-    rspec-core (2.4.0)
-    rspec-expectations (2.4.0)
+    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.4.0)
+    rspec-mocks (2.6.0)
 
 PLATFORMS
   ruby
-  x86-mingw32
 
 DEPENDENCIES
-  forgery (~> 0.3.6)
+  forgery (~> 0.5.0)
   gitolite!
-  rspec (~> 2.4.0)
+  rcov (~> 0.9.11)
+  rdoc (~> 3.9.4)
+  rspec (~> 2.6.0)

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.rdoc

@@ -7,9 +7,13 @@ This gem is still under very active development.  There are a number of issues w
 == 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.9.2 or higher
+* 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
 
@@ -23,28 +27,65 @@ This gem is still under very active development.  There are a number of issues w
 
   require 'gitolite'
   ga_repo = Gitolite::GitoliteAdmin.new("/path/to/gitolite/admin/repo")
-  
-For now, this method can only be called on an existing gitolite-admin repo.  Support for bootstrapping a gitolite-repo will be added in the future (but will never be recommended).
-  
+
+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 = Config::Repo.new("AwesomeRepo")
-  
+  repo = Gitolite::Config::Repo.new("AwesomeRepo")
+
   #For a list of permissions, see https://github.com/sitaramc/gitolite/blob/pu/doc/gitolite.conf.mkd
   repo.add_permission("RW+", "", "bob", "joe", "susan")
-  
-  #Add repo
-  ga_repo.add_repo(repo)
-  
-  #Delete repo
-  ga_repo.rm_repo(repo)
+
+  #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
 
   #Two ways to create keys: manually or from an existing key
   key = Gitolite::SSHKey.new("ssh-rsa", "big-public-key-blob", "email")
   key2 = Gitolite::SSHKey.from_file("/path/to/ssh/key.pub")
-  
+
   #Add the keys
   ga_repo.add_key(key)
   ga_repo.add_key(key2)
@@ -55,26 +96,49 @@ For now, this method can only be called on an existing gitolite-admin repo.  Sup
 === 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
 
+=== 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
-=== 1.8.x compatibility
-This gem should work properly on Ruby 1.8.x with the exception of deny rules.  In order to fully support Ruby < 1.9.x, an ordered Hash is required. The one implemented by ActiveSupport could probably be used.  Support will be added if there appears to be a demand for it.
+=== 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.
+
+== 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 soon
 
 == Future
 * support folders in the keydir
-* support includes tags
-* support bootstrapping a gitolite-admin repo
-* cleanup methods to make adding and removing easier (like add_key should accept an array of keys)
+* support include tags
+* support pull operations to sync the local gitolite-admin repository with the server
+* cleanup methods to make adding and removing easier (like add_key should accept an array of keys)
+* Rails integration
+* Make the gem thread safe
+* Add full support for Wildcard repos

data/Rakefile

@@ -1,2 +1,34 @@
 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
+require 'rcov'
+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

@@ -14,9 +14,12 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "gitolite"
 
-  s.add_development_dependency "rspec", "~> 2.4.0"
-  s.add_development_dependency "forgery", "~> 0.3.6"
+  s.add_development_dependency "rspec", "~> 2.6.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.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/gitolite.rb

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

data/lib/gitolite/config.rb

@@ -1,83 +1,84 @@
+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 = Hash.new { |k,v| k[v] = [] }
+      @groups = {}
       @filename = File.basename(config)
       process_config(config)
     end
 
-    #Represents a repo inside the gitolite configuration.  The name, permissions, and git config
-    #options are all encapsulated in this class
-    class Repo
-      ALLOWED_PERMISSIONS = ['C', 'R', 'RW', 'RW+', 'RWC', 'RW+C', 'RWD', 'RW+D', 'RWCD', 'RW+CD', '-']
-
-      attr_accessor :permissions, :name, :config
-
-      def initialize(name)
-        @name = name
-        @permissions = Hash.new {|k,v| k[v] = Hash.new{|k2, v2| k2[v2] = [] }}
-        @config = {}
-      end
-
-      def add_permission(perm, refex, *users)
-        if ALLOWED_PERMISSIONS.include? perm
-          @permissions[perm][refex].concat users
-        else
-          raise InvalidPermissionError, "#{perm} is not in the allowed list of permissions!"
-        end
-      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
 
-      def set_git_config(key, value)
-        @config[key] = value
-      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 unset_git_config(key)
-        @config.delete(key)
-      end
+    def rm_repo(repo)
+      name = normalize_repo_name(repo)
+      @repos.delete(name)
+    end
 
-      def to_s
-        repo = "repo    #{@name}\n"
+    def has_repo?(repo)
+      name = normalize_repo_name(repo)
+      @repos.has_key?(name)
+    end
 
-        @permissions.each do |perm, list|
-          list.each do |refex, users|
-            repo += "  " + perm.ljust(6) + refex.ljust(20) + "= " + users.join(' ') + "\n"
-          end
-        end
+    def get_repo(repo)
+      name = normalize_repo_name(repo)
+      @repos[name]
+    end
 
-        repo
-      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
 
-      #Gets raised if a permission that isn't in the allowed
-      #list is passed in
-      class InvalidPermissionError < RuntimeError
-      end
+    def rm_group(group)
+      name = normalize_group_name(group)
+      @groups.delete(name)
     end
 
-    #TODO: merge repo unless overwrite = true
-    def add_repo(repo, overwrite = false)
-      raise "Repo must be of type Gitolite::Config::Repo!" unless repo.instance_of? Gitolite::Config::Repo
-      @repos[repo.name] = repo
+    def has_group?(group)
+      name = normalize_group_name(group)
+      @groups.has_key?(name)
     end
-    
-    def rm_repo(repo)
-      raise "Repo must be of type Gitolite::Config::Repo!" unless repo.instance_of? Gitolite::Config::Repo
-      @repos.delete repo.name
+
+    def get_group(group)
+      name = normalize_group_name(group)
+      @groups[name]
     end
 
-    def to_file(path)
-      new_conf = File.join(path, @filename)
+    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|
-        @groups.each do |k,v|
-          members = v.join(' ')
-          f.write "#{k.ljust(20)}=  #{members}\n"
-        end
+        #Output groups
+        @groups.each_value {|group| f.write group.to_s }
 
+        gitweb_descs = []
         @repos.each do |k, v|
           f.write v.to_s
+
+          gwd = v.gitweb_description
+          gitweb_descs.push(gwd) unless gwd.nil?
         end
+
+        f.write gitweb_descs.join("\n")
       end
 
       new_conf
@@ -93,7 +94,7 @@ module Gitolite
         #fix whitespace
         line.gsub!('=', ' = ')
         line.gsub!(/\s+/, ' ')
-        line.strip!
+        line.strip
       end
 
       def process_config(config)
@@ -115,7 +116,7 @@ module Gitolite
               repos.each do |r|
                 context << r
 
-                @repos[r] = Repo.new(r) unless @repos.has_key? r
+                @repos[r] = Repo.new(r) unless has_repo?(r)
               end
             #repo permissions
             when /^(-|C|R|RW\+?(?:C?D?|D?C?)) (.* )?= (.+)/
@@ -135,23 +136,71 @@ module Gitolite
                 @repos[c].set_git_config(key, value)
               end
             #group definition
-            when /^(@\S+) = ?(.*)/
+            when /^#{Group::PREPEND_CHAR}(\S+) = ?(.*)/
               group = $1
               users = $2.split
 
-              @groups[group].concat users
-              @groups[group].uniq!
+              @groups[group] = Group.new(group) unless has_group?(group)
+              @groups[group].add_users(users)
             #gitweb definition
             when /^(\S+)(?: "(.*?)")? = "(.*)"$/
-              #ignore gitweb right now
-              puts line
+              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
             else
-              puts "The following line cannot be processed:"
-              puts "'#{line}'"
+              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
+
+      #Raised when something in a config fails to parse properly
+      class ParseError < RuntimeError
+      end
   end
 end