gitolite 0.0.2.alpha → 0.0.3.alpha

data/lib/gitolite/config/group.rb

@@ -0,0 +1,51 @@
+module Gitolite
+  class Config
+    # Represents a group inside the gitolite configuration.  The name and users
+    # options are all encapsulated in this class.  All users are stored as
+    # Strings!
+    class Group
+      attr_accessor :name, :users
+
+      PREPEND_CHAR = '@'
+
+      def initialize(name)
+        # naively remove the prepend char
+        # I don't think you can have two of them in a group name
+        @name = name.gsub(PREPEND_CHAR, '')
+        @users = []
+      end
+
+      def empty!
+        @users.clear
+      end
+
+      def add_user(user)
+        return if has_user?(user)
+        @users.push(user.to_s).sort!
+      end
+
+      def add_users(*users)
+        fixed_users = users.flatten.map{ |u| u.to_s }
+        @users.concat(fixed_users).sort!.uniq!
+      end
+
+      def rm_user(user)
+        @users.delete(user.to_s)
+      end
+
+      def has_user?(user)
+        @users.include? user.to_s
+      end
+
+      def size
+        @users.length
+      end
+
+      def to_s
+        members = @users.join(' ')
+        name = "#{PREPEND_CHAR}#{@name}"
+        "#{name.ljust(20)}= #{members}\n"
+      end
+    end
+  end
+end

data/lib/gitolite/config/repo.rb

@@ -0,0 +1,83 @@
+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?/
+
+      attr_accessor :permissions, :name, :config, :owner, :description
+
+      def initialize(name)
+        #Store the perm hash in a lambda since we have to create a new one on every deny rule
+        #The perm hash is stored as a 2D hash, with individual permissions being the first
+        #degree and individual refexes being the second degree.  Both Hashes must respect order
+        @perm_hash_lambda = lambda { OrderedHash.new {|k,v| k[v] = OrderedHash.new{|k2, v2| k2[v2] = [] }} }
+        @permissions = Array.new.push(@perm_hash_lambda.call)
+
+        @name = name
+        @config = {} #git config
+      end
+
+      def clean_permissions
+        @permissions = Array.new.push(@perm_hash_lambda.call)
+      end
+
+      def add_permission(perm, refex = "", *users)
+        if perm =~ ALLOWED_PERMISSIONS
+          #Handle deny rules
+          if perm == '-'
+            @permissions.push(@perm_hash_lambda.call)
+          end
+
+          @permissions.last[perm][refex].concat users.flatten
+          @permissions.last[perm][refex].uniq!
+        else
+          raise InvalidPermissionError, "#{perm} is not in the allowed list of permissions!"
+        end
+      end
+
+      def set_git_config(key, value)
+        @config[key] = value
+      end
+
+      def unset_git_config(key)
+        @config.delete(key)
+      end
+
+      def to_s
+        repo = "repo    #{@name}\n"
+
+        @permissions.each do |perm_hash|
+          perm_hash.each do |perm, list|
+            list.each do |refex, users|
+              repo += "  " + perm.ljust(6) + refex.ljust(25) + "= " + users.join(' ') + "\n"
+            end
+          end
+        end
+
+        @config.each do |k, v|
+          repo += "  config " + k + " = " + v + "\n"
+        end
+
+        repo
+      end
+
+      def gitweb_description
+        if @description.nil?
+          nil
+        else
+          desc = "#{@name} "
+          desc += "\"#{@owner}\" " unless @owner.nil?
+          desc += "= \"#{@description}\""
+        end
+      end
+
+      #Gets raised if a permission that isn't in the allowed
+      #list is passed in
+      class InvalidPermissionError < ArgumentError
+      end
+    end
+  end
+end

data/lib/gitolite/gitolite_admin.rb

@@ -6,8 +6,8 @@ module Gitolite
     CONFDIR = "conf"
     KEYDIR = "keydir"
 
-    #Intialize with the path to
-    #the gitolite-admin repository
+    # Intialize with the path to
+    # the gitolite-admin repository
     def initialize(path, options = {})
       @gl_admin = Grit::Repo.new(path)
 
@@ -19,38 +19,78 @@ module Gitolite
       @config = Config.new(File.join(path, @confdir, @conf))
     end
 
-    #Writes all aspects out to the file system
-    #will also stage all changes
-    def save
-      Dir.chdir(@gl_admin.working_dir)
+    # This method will bootstrap a gitolite-admin repo
+    # at the given path.  A typical gitolite-admin
+    # repo will have the following tree:
+    #
+    # gitolite-admin
+    #   conf
+    #     gitolite.conf
+    #   keydir
+    def self.bootstrap(path, options = {})
+      if self.is_gitolite_admin_repo?(path)
+        if options[:overwrite]
+          FileUtils.rm_rf(File.join(path, '*'))
+        else
+          return self.new(path)
+        end
+      end
 
-      #Process config file
-      new_conf = @config.to_file(@confdir)
-      @gl_admin.add(new_conf)
+      FileUtils.mkdir_p([File.join(path,"conf"), File.join(path,"keydir")])
 
-      #Process ssh keys
-      files = list_keys(@keydir).map{|f| File.basename f}
-      keys = @ssh_keys.values.map{|f| f.map {|t| t.filename}}.flatten
+      options[:perm] ||= "RW+"
+      options[:refex] ||= ""
+      options[:user] ||= "git"
 
-      to_remove = (files - keys).map { |f| File.join(@keydir, f)}
-      @gl_admin.remove(to_remove)
+      c = Config.init
+      r = Config::Repo.new(options[:repo] || "gitolite-admin")
+      r.add_permission(options[:perm], options[:refex], options[:user])
+      c.add_repo(r)
+      config = c.to_file(File.join(path, "conf"))
+
+      repo = Grit::Repo.init(path)
+      Dir.chdir(path) do
+        repo.add(config)
+        repo.commit_index(options[:message] || "Config bootstrapped by the gitolite gem")
+      end
+
+      self.new(path)
+    end
 
-      @ssh_keys.each_value do |key|
-        key.each do |k|
-          @gl_admin.add(k.to_file(@keydir))
+    #Writes all aspects out to the file system
+    #will also stage all changes
+    def save
+      Dir.chdir(@gl_admin.working_dir) do
+        #Process config file
+        new_conf = @config.to_file(@confdir)
+        @gl_admin.add(new_conf)
+
+        #Process ssh keys
+        files = list_keys(@keydir).map{|f| File.basename f}
+        keys = @ssh_keys.values.map{|f| f.map {|t| t.filename}}.flatten
+
+        to_remove = (files - keys).map { |f| File.join(@keydir, f)}
+        @gl_admin.remove(to_remove)
+
+        @ssh_keys.each_value do |key|
+          key.each do |k|
+            @gl_admin.add(k.to_file(@keydir))
+          end
         end
       end
     end
 
     #commits all staged changes and pushes back
     #to origin
-    def apply
-      #TODO: generate a better commit message
-      @gl_admin.commit_index("Commit by gitolite gem")
+    #
+    #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")
+      @gl_admin.commit_index(commit_message)
       @gl_admin.git.push({}, "origin", "master")
     end
 
-    #Calls save and apply in order
     def save_and_apply
       self.save
       self.apply
@@ -65,6 +105,24 @@ module Gitolite
       @ssh_keys[key.owner].delete key
     end
 
+    #Checks to see if the given path is a gitolite-admin repository
+    #A valid repository contains a conf folder, keydir folder,
+    #and a configuration file within the conf folder
+    def self.is_gitolite_admin_repo?(dir)
+      # First check if it is a git repository
+      begin
+        Grit::Repo.new(dir)
+      rescue Grit::InvalidGitRepositoryError
+        return false
+      end
+
+      # If we got here it is a valid git repo,
+      # now check directory structure
+      File.exists?(File.join(dir, 'conf')) &&
+        File.exists?(File.join(dir, 'keydir')) &&
+        !Dir.glob(File.join(dir, 'conf', '*.conf')).empty?
+    end
+
     private
       #Loads all .pub files in the gitolite-admin
       #keydir directory
@@ -82,11 +140,10 @@ module Gitolite
       end
 
       def list_keys(path)
-        old_path = Dir.pwd
-        Dir.chdir(path)
-        keys = Dir.glob("**/*.pub")
-        Dir.chdir(old_path)
-        keys
+        Dir.chdir(path) do
+          keys = Dir.glob("**/*.pub")
+          keys
+        end
       end
   end
 end

data/lib/gitolite/ssh_key.rb

@@ -25,7 +25,7 @@ module Gitolite
       raise "#{key} does not exist!" unless File.exists?(key)
 
       #Get our owner and location
-      File.basename(key) =~ /^(\w+(?:@(?:\w+\.)+\D{2,4})?)(?:@(\w+))?.pub$/i
+      File.basename(key) =~ /^([\w\.-]+(?:@(?:[\w-]+\.)+\D{2,4})?)(?:@(\w+))?.pub$/i
       owner = $1
       location = $2 || ""
 
@@ -47,7 +47,7 @@ module Gitolite
     def to_file(path)
       key_file = File.join(path, self.filename)
       File.open(key_file, "w") do |f|
-        f.write (self.to_s)
+        f.write(self.to_s)
       end
       key_file
     end

data/lib/gitolite/version.rb

@@ -1,3 +1,3 @@
 module Gitolite
-  VERSION = "0.0.2.alpha"
+  VERSION = "0.0.3.alpha"
 end

data/spec/concurrency_spec.rb

@@ -0,0 +1,2 @@
+#require 'gitolite'
+#require 'spec_helper'

data/spec/config_spec.rb

@@ -1,4 +1,357 @@
 require 'gitolite/config'
+require 'spec_helper'
 
 describe Gitolite::Config do
-end
+  conf_dir = File.join(File.dirname(__FILE__),'configs')
+
+  describe "#new" do
+    it 'should read a simple configuration' do
+      c = Gitolite::Config.new(File.join(conf_dir, 'simple.conf'))
+      c.repos.length.should == 2
+      c.groups.length.should == 0
+    end
+
+    it 'should read a complex configuration' do
+      c = Gitolite::Config.new(File.join(conf_dir, 'complicated.conf'))
+      c.groups.length.should == 5
+      c.repos.length.should == 12
+    end
+
+    describe 'gitweb operations' do
+      before :all do
+        @config = Gitolite::Config.new(File.join(conf_dir, 'complicated.conf'))
+      end
+
+      it 'should correctly read gitweb options for an existing repo' do
+        r = @config.get_repo('gitolite')
+        r.owner.should == "Sitaram Chamarty"
+        r.description.should == "fast, secure, access control for git in a corporate environment"
+      end
+
+      it 'should correctly read a gitweb option with no owner for an existing repo' do
+        r = @config.get_repo('foo')
+        r.owner.should be nil
+        r.description.should == "Foo is a nice test repo"
+      end
+
+      it 'should correctly read gitweb options for a new repo' do
+        r = @config.get_repo('foobar')
+        r.owner.should == "Bob Zilla"
+        r.description.should == "Foobar is top secret"
+      end
+
+      it 'should correctly read gitweb options with no owner for a new repo' do
+        r = @config.get_repo('bar')
+        r.owner.should be nil
+        r.description.should == "A nice place to get drinks"
+      end
+
+      it 'should raise a ParseError when a description is not specified' do
+        t = Tempfile.new('bad_conf.conf')
+        t.write('gitolite "Bob Zilla"')
+        t.close
+
+        lambda { Gitolite::Config.new(t.path) }.should raise_error(Gitolite::Config::ParseError)
+
+        t.unlink
+      end
+
+      it 'should raise a ParseError when a Gitweb description is specified for a group' do
+        t = Tempfile.new('bad_conf.conf')
+        t.write('@gitolite "Bob Zilla" = "Test description"')
+        t.close
+
+        lambda { Gitolite::Config.new(t.path) }.should raise_error(Gitolite::Config::ParseError)
+
+        t.unlink
+      end
+    end
+  end
+
+  describe "#init" do
+    it 'should create a valid, blank Gitolite::Config' do
+      c = Gitolite::Config.init
+
+      c.should be_an_instance_of Gitolite::Config
+      c.repos.should_not be nil
+      c.repos.length.should be 0
+      c.groups.should_not be nil
+      c.groups.length.should be 0
+      c.filename.should == "gitolite.conf"
+    end
+
+    it 'should create a valid, blank Gitolite::Config with the given filename' do
+      filename = "test.conf"
+      c = Gitolite::Config.init(filename)
+
+      c.should be_an_instance_of Gitolite::Config
+      c.repos.should_not be nil
+      c.repos.length.should be 0
+      c.groups.should_not be nil
+      c.groups.length.should be 0
+      c.filename.should == filename
+    end
+  end
+
+  describe "repo management" do
+    before :each do
+      @config = Gitolite::Config.new(File.join(conf_dir, 'complicated.conf'))
+    end
+
+    describe "#get_repo" do
+      it 'should fetch a repo by a string containing the name' do
+        @config.get_repo('gitolite').should be_an_instance_of Gitolite::Config::Repo
+      end
+
+      it 'should fetch a repo via a symbol representing the name' do
+        @config.get_repo(:gitolite).should be_an_instance_of Gitolite::Config::Repo
+      end
+
+      it 'should return nil for a repo that does not exist' do
+        @config.get_repo(:glite).should be nil
+      end
+    end
+
+    describe "#has_repo?" do
+      it 'should return false for a repo that does not exist' do
+        @config.has_repo?(:glite).should be false
+      end
+
+      it 'should check for the existance of a repo given a repo object' do
+        r = @config.repos["gitolite"]
+        @config.has_repo?(r).should be true
+      end
+
+      it 'should check for the existance of a repo given a string containing the name' do
+        @config.has_repo?('gitolite').should be true
+      end
+
+      it 'should check for the existance of a repo given a symbol representing the name' do
+        @config.has_repo?(:gitolite).should be true
+      end
+    end
+
+    describe "#add_repo" do
+      it 'should throw an ArgumentError for non-Gitolite::Config::Repo objects passed in' do
+        lambda{ @config.add_repo("not-a-repo") }.should raise_error(ArgumentError)
+      end
+
+      it 'should add a given repo to the list of repos' do
+        r = Gitolite::Config::Repo.new('cool_repo')
+        nrepos = @config.repos.size
+        @config.add_repo(r)
+
+        @config.repos.size.should == nrepos + 1
+        @config.has_repo?(:cool_repo).should be true
+      end
+
+      it 'should merge a given repo with an existing repo' do
+        #Make two new repos
+        repo1 = Gitolite::Config::Repo.new('cool_repo')
+        repo2 = Gitolite::Config::Repo.new('cool_repo')
+
+        #Add some perms to those repos
+        repo1.add_permission("RW+", "", "bob", "joe", "sam")
+        repo1.add_permission("R", "", "sue", "jen", "greg")
+        repo1.add_permission("-", "refs/tags/test[0-9]", "@students", "jessica")
+        repo1.add_permission("RW", "refs/tags/test[0-9]", "@teachers", "bill", "todd")
+        repo1.add_permission("R", "refs/tags/test[0-9]", "@profs")
+
+        repo2.add_permission("RW+", "", "jim", "cynthia", "arnold")
+        repo2.add_permission("R", "", "daniel", "mary", "ben")
+        repo2.add_permission("-", "refs/tags/test[0-9]", "@more_students", "stephanie")
+        repo2.add_permission("RW", "refs/tags/test[0-9]", "@student_teachers", "mike", "judy")
+        repo2.add_permission("R", "refs/tags/test[0-9]", "@leaders")
+
+        #Add the repos
+        @config.add_repo(repo1)
+        @config.add_repo(repo2)
+
+        #Make sure perms were properly merged
+      end
+
+      it 'should overwrite an existing repo when overwrite = true' do
+        #Make two new repos
+        repo1 = Gitolite::Config::Repo.new('cool_repo')
+        repo2 = Gitolite::Config::Repo.new('cool_repo')
+
+        #Add some perms to those repos
+        repo1.add_permission("RW+", "", "bob", "joe", "sam")
+        repo1.add_permission("R", "", "sue", "jen", "greg")
+        repo2.add_permission("RW+", "", "jim", "cynthia", "arnold")
+        repo2.add_permission("R", "", "daniel", "mary", "ben")
+
+        #Add the repos
+        @config.add_repo(repo1)
+        @config.add_repo(repo2, true)
+
+        #Make sure repo2 overwrote repo1
+      end
+    end
+
+    describe "#rm_repo" do
+      it 'should remove a repo for the Gitolite::Config::Repo object given' do
+        r = @config.get_repo(:gitolite)
+        r2 = @config.rm_repo(r)
+        r2.name.should == r.name
+        r2.permissions.length.should == r.permissions.length
+        r2.owner.should == r.owner
+        r2.description.should == r.description
+      end
+
+      it 'should remove a repo given a string containing the name' do
+        r = @config.get_repo(:gitolite)
+        r2 = @config.rm_repo('gitolite')
+        r2.name.should == r.name
+        r2.permissions.length.should == r.permissions.length
+        r2.owner.should == r.owner
+        r2.description.should == r.description
+      end
+
+      it 'should remove a repo given a symbol representing the name' do
+        r = @config.get_repo(:gitolite)
+        r2 = @config.rm_repo(:gitolite)
+        r2.name.should == r.name
+        r2.permissions.length.should == r.permissions.length
+        r2.owner.should == r.owner
+        r2.description.should == r.description
+      end
+    end
+  end
+
+  describe "group management" do
+    before :each do
+      @config = Gitolite::Config.new(File.join(conf_dir, 'complicated.conf'))
+    end
+
+    describe "#has_group?" do
+      it 'should find the staff group using a symbol' do
+        @config.has_group?(:staff).should be true
+      end
+
+      it 'should find the staff group using a string' do
+       @config.has_group?('staff').should be true
+      end
+
+      it 'should find the staff group using a Gitolite::Config::Group object' do
+        g = Gitolite::Config::Group.new("staff")
+        @config.has_group?(g).should be true
+      end
+    end
+
+    describe "#get_group" do
+      it 'should return the Gitolite::Config::Group object for the group name String' do
+        g = @config.get_group("staff")
+        g.is_a?(Gitolite::Config::Group).should be true
+        g.size.should == 6
+      end
+
+      it 'should return the Gitolite::Config::Group object for the group name Symbol' do
+        g = @config.get_group(:staff)
+        g.is_a?(Gitolite::Config::Group).should be true
+        g.size.should == 6
+      end
+    end
+
+    describe "#add_group" do
+      it 'should throw an ArgumentError for non-Gitolite::Config::Group objects passed in' do
+        lambda{ @config.add_group("not-a-group") }.should raise_error(ArgumentError)
+      end
+
+      it 'should add a given group to the groups list' do
+        g = Gitolite::Config::Group.new('cool_group')
+        ngroups = @config.groups.size
+        @config.add_group(g)
+        @config.groups.size.should be ngroups + 1
+        @config.has_group?(:cool_group).should be true
+      end
+
+    end
+
+    describe "#rm_group" do
+      it 'should remove a group for the Gitolite::Config::Group object given' do
+        g = @config.get_group(:oss_repos)
+        g2 = @config.rm_group(g)
+        g.should_not be nil
+        g2.name.should == g.name
+      end
+
+      it 'should remove a group given a string containing the name' do
+        g = @config.get_group(:oss_repos)
+        g2 = @config.rm_group('oss_repos')
+        g2.name.should == g.name
+      end
+
+      it 'should remove a group given a symbol representing the name' do
+        g = @config.get_group(:oss_repos)
+        g2 = @config.rm_group(:oss_repos)
+        g2.name.should == g.name
+      end
+    end
+
+  end
+
+  describe "#to_file" do
+    it 'should create a file at the given path with the config\'s file name' do
+      c = Gitolite::Config.init
+      file = c.to_file('/tmp')
+      File.file?(File.join('/tmp', c.filename)).should be true
+      File.unlink(file)
+    end
+
+    it 'should create a file at the given path when a different filename is specified' do
+      filename = "test.conf"
+      c = Gitolite::Config.init
+      c.filename = filename
+      file = c.to_file('/tmp')
+      File.file?(File.join('/tmp', filename)).should be true
+      File.unlink(file)
+    end
+
+    it 'should raise an ArgumentError when an invalid path is specified' do
+      c = Gitolite::Config.init
+      lambda { c.to_file('/does/not/exist') }.should raise_error(ArgumentError)
+    end
+
+    it 'should raise an ArgumentError when a filename is specified in the path' do
+      c = Gitolite::Config.init
+      lambda{ c.to_file('/home/test.rb') }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#cleanup_config_line" do
+    before(:each) do
+      @config = Gitolite::Config.init
+    end
+
+    it 'should remove comments' do
+      s = "#comment"
+      @config.instance_eval { cleanup_config_line(s) }.empty?.should == true
+    end
+
+    it 'should remove inline comments, keeping content before the comment' do
+      s = "blablabla #comment"
+      @config.instance_eval { cleanup_config_line(s) }.should == "blablabla"
+    end
+
+    it 'should pad = with spaces on each side' do
+      s = "bob=joe"
+      @config.instance_eval { cleanup_config_line(s) }.should == "bob = joe"
+    end
+
+    it 'should replace multiple space characters with a single space' do
+      s = "bob       =        joe"
+      @config.instance_eval { cleanup_config_line(s) }.should == "bob = joe"
+    end
+
+    it 'should cleanup whitespace at the beginning and end of lines' do
+      s = "            bob = joe            "
+      @config.instance_eval { cleanup_config_line(s) }.should == "bob = joe"
+    end
+
+    it 'should cleanup whitespace and comments effectively' do
+      s = "            bob     =     joe             #comment"
+      @config.instance_eval { cleanup_config_line(s) }.should == "bob = joe"
+    end
+  end
+end