jbox-gitolite 1.1.2

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,94 @@
+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 = /-|C|R|RW\+?(?:C?D?|D?C?)M?/
+
+      attr_accessor :permissions, :name, :config, :options, :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
+        @options = {} #gitolite 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 set_gitolite_option(key, value)
+        @options[key] = value
+      end
+
+      def unset_gitolite_option(key)
+        @options.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
+
+        @options.each do |k, v|
+          repo += "  option " + 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/dirty_proxy.rb

@@ -0,0 +1,29 @@
+module Gitolite
+  # Very simple proxy object for checking if the proxied object was modified
+  # since the last clean_up! method called. It works correctly only for objects
+  # with proper hash method!
+
+  class DirtyProxy < BasicObject
+
+    def initialize(target)
+      @target = target
+      clean_up!
+    end
+
+    def method_missing(method, *args, &block)
+      @target.send(method, *args, &block)
+    end
+
+    def respond_to?(symbol, include_private=false)
+      super || [:dirty?, :clean_up!].include?(symbol.to_sym)
+    end
+
+    def dirty?
+      @clean_hash != @target.hash
+    end
+
+    def clean_up!
+      @clean_hash = @target.hash
+    end
+  end
+end

data/lib/gitolite/gitolite_admin.rb

@@ -0,0 +1,206 @@
+require File.join(File.dirname(__FILE__), "dirty_proxy")
+
+module Gitolite
+  class GitoliteAdmin
+    attr_accessor :gl_admin
+
+    CONF = "gitolite.conf"
+    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
+    end
+
+    # 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
+
+      FileUtils.mkdir_p([File.join(path,"conf"), File.join(path,"keydir")])
+
+      options[:perm] ||= "RW+"
+      options[:refex] ||= ""
+      options[:user] ||= "git"
+
+      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
+
+    #Writes all changed aspects out to the file system
+    #will also stage all changes
+    def save
+      Dir.chdir(@gl_admin.working_dir) do
+        #Process config file (if loaded, i.e. may be modified)
+        if @config
+          new_conf = @config.to_file(@confdir)
+          @gl_admin.add(new_conf)
+        end
+
+        #Process ssh keys (if loaded, i.e. may be modified)
+        if @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|
+            #Write only keys from sets that has been modified
+            next if key.respond_to?(:dirty?) && !key.dirty?
+            key.each do |k|
+              @gl_admin.add(k.to_file(@keydir))
+            end
+          end
+        end
+      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!
+      @ssh_keys = load_keys
+      @config = load_config
+    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 = DEFAULT_COMMIT_MSG)
+      @gl_admin.commit_index(commit_message)
+      @gl_admin.git.push({}, "origin", "master")
+    end
+
+    def save_and_apply(commit_message = DEFAULT_COMMIT_MSG)
+      self.save
+      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)
+      raise "Key must be of type Gitolite::SSHKey!" unless key.instance_of? Gitolite::SSHKey
+      ssh_keys[key.owner] << key
+    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
+
+    #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
+
+    def ssh_keys
+      @ssh_keys ||= load_keys
+    end
+
+    def config
+      @config ||= load_config
+    end
+
+    private
+      #Loads all .pub files in the gitolite-admin
+      #keydir directory
+      def load_keys(path = nil)
+        path ||= File.join(@path, @keydir)
+        keys = Hash.new {|k,v| k[v] = DirtyProxy.new([])}
+
+        list_keys(path).each do |key|
+          new_key = SSHKey.from_file(File.join(path, key))
+          owner = new_key.owner
+
+          keys[owner] << new_key
+        end
+        #Mark key sets as unmodified (for dirty checking)
+        keys.values.each{|set| set.clean_up!}
+
+        keys
+      end
+
+      def load_config(path = nil)
+        path ||= File.join(@path, @confdir, @conf)
+        Config.new(path)
+      end
+
+      def list_keys(path)
+        Dir.chdir(path) do
+          keys = Dir.glob("**/*.pub")
+          keys
+        end
+      end
+  end
+end

data/lib/gitolite/ssh_key.rb

@@ -0,0 +1,87 @@
+module Gitolite
+  #Models an SSH key within gitolite
+  #provides support for multikeys
+  #
+  #Types of multi keys:
+  #  bob.pub => username: bob
+  #  bob@desktop.pub => username: bob, location: desktop
+  #  bob@email.com.pub => username: bob@email.com
+  #  bob@email.com@desktop.pub => username: bob@email.com, location: desktop
+
+  class SSHKey
+    attr_accessor :owner, :location, :type, :blob, :email
+
+    def initialize(type, blob, email, owner = nil, location = "")
+      @type = type
+      @blob = blob
+      @email = email
+
+      @owner = owner || email
+      @location = location
+    end
+
+    def self.from_file(key)
+      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
+      owner = $1
+      location = $2 || ""
+
+      # Use string key constructor
+      self.from_string(File.read(key), owner, location)
+    end
+
+    # Construct a SSHKey from a string
+    def self.from_string(key_string, owner, location = "")
+      if owner.nil?
+        raise ArgumentError, "owner was nil, you must specify an owner"
+      end
+
+      #Get parts of the key
+      type, blob, email = key_string.split
+
+      # We need at least a type or blob
+      if type.nil? || blob.nil?
+        raise ArgumentError, "'#{key_string}' is not a valid SSH key string"
+      end
+
+      #If the key didn't have an email, just use the owner
+      if email.nil?
+        email = owner
+      end
+
+      self.new(type, blob, email, owner, location)
+    end
+
+    def to_s
+      [@type, @blob, @email].join(' ')
+    end
+
+    def to_file(path)
+      key_file = File.join(path, self.filename)
+      File.open(key_file, "w") do |f|
+        f.write(self.to_s)
+      end
+      key_file
+    end
+
+    def filename
+      file = @owner
+      file += "@#{@location}" unless @location.empty?
+      file += ".pub"
+    end
+
+    def ==(key)
+      @type == key.type &&
+      @blob == key.blob &&
+      @email == key.email &&
+      @owner == key.owner &&
+      @location == key.location
+    end
+
+    def hash
+      [@owner, @location, @type, @blob, @email].hash
+    end
+  end
+end