gitolite-dtg 0.1.0

data/.gitignore

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

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,49 @@
+PATH
+  remote: .
+  specs:
+    gitolite-dtg (0.0.1)
+      gratr19 (~> 0.4.4.1)
+      grit (~> 2.5.0)
+      hashery (~> 1.5.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    blankslate (3.1.2)
+    diff-lcs (1.1.3)
+    forgery (0.5.0)
+    gratr19 (0.4.4.1)
+    grit (2.5.0)
+      diff-lcs (~> 1.1)
+      mime-types (~> 1.15)
+      posix-spawn (~> 0.3.6)
+    hashery (1.5.0)
+      blankslate
+    json (1.6.6)
+    mime-types (1.19)
+    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
+
+DEPENDENCIES
+  forgery (~> 0.5.0)
+  gitolite-dtg!
+  rdoc (~> 3.12)
+  rspec (~> 2.9.0)
+  simplecov (~> 0.6.2)

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,58 @@
+# gitolite-dtg #
+Digital Technology Group, University of Cambridge
+
+Forked from [wingrunr21/gitolite](https://github.com/wingrunr21/gitolite)
+
+This gem provides a Ruby read-only interface to the [gitolite](https://github.com/sitaramc/gitolite) git backend system 
+(by parsing the configuration file found in the bare gitolite-admin repository).  It aims to enable an application to query
+gitolite repository permissions based on data written in the gitolite-admin repository. 
+
+This fork is designed to work as part of a Ruby authorization mechanism to gitolite repositories (see the related
+gollum-dtg project for an example of how we use it).
+
+Please see the upstream project for a Ruby API aiming to provide all management functionality (read and write) that is 
+available via the gitolite-admin repository (like SSH keys, adding/removing repositories, etc). 
+
+
+## Requirements ##
+* Ruby 1.8.x or 1.9.x
+* a working [gitolite](https://github.com/sitaramc/gitolite) installation
+* appropiate read permisions for the <tt>gitolite-admin</tt> bare repository
+
+## Installation ##
+
+    gem install gitolite-dtg
+
+## Usage ##
+
+### Load a gitolite-admin repo ###
+
+    require 'gitolite-dtg'
+    ga_repo = Gitolite::Dtg::GitoliteAdmin.new("/path/to/gitolite/repos/gitolite-admin.git")
+
+This method can only be called on an existing gitolite-admin repo.
+
+## 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
+
+
+### Contributors ###
+* Stafford Brunk - [wingrunr21](https://github.com/wingrunr21) (original developer of the API)
+* Alexander Simonov - [simonoff](https://github.com/simonoff)

data/Rakefile

@@ -0,0 +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-dtg.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gitolite-dtg/version"
+
+Gem::Specification.new do |s|
+  s.name        = "gitolite-dtg"
+  s.version     = Gitolite::Dtg::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Stafford Brunk", "Lucian Carata"]
+  s.email       = ["wingrunr21@gmail.com", "lc525@cam.ac.uk"]
+  s.homepage    = "https://github.com/lc525/gitolite-dtg"
+  s.summary     = %q{A Ruby gem based on wingrunr21/gitolite for querying the permisions of gitolite repositories.}
+  s.description = %q{This gem provides a Ruby read-only interface to the gitolite git backend system (by parsing the configuration file found in the bare gitolite-admin repository).  It aims to enable permission queries based on data written in the gitolite-admin repository. This fork is designed to work as part of a Ruby authorization mechanism to gitolite repositories.}
+
+  s.rubyforge_project = "gitolite-dtg"
+
+  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_dependency "grit", "~> 2.5.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-dtg/config/group.rb

@@ -0,0 +1,53 @@
+module Gitolite
+  module Dtg
+    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
+end

data/lib/gitolite-dtg/config/repo.rb

@@ -0,0 +1,83 @@
+module Gitolite
+  module Dtg
+    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, :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
+end

data/lib/gitolite-dtg/config.rb

@@ -0,0 +1,267 @@
+require 'tempfile'
+require File.join(File.dirname(__FILE__), 'config', 'repo')
+require File.join(File.dirname(__FILE__), 'config', 'group')
+
+module Gitolite
+  module Dtg
+  class Config
+    attr_accessor :repos, :groups, :config_blob, :flat_groups, :special_groups
+
+    def initialize(config)
+      @special_groups = ["all","raven"]
+      @repos = {}
+      @groups = {}
+      @flat_groups = {}
+      @config_blob = config
+      process_config(config)
+      flatten_groups
+    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
+        config.data.lines.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
+            #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
+      
+      def flatten_groups
+		@groups.each_value do |group|
+			@flat_groups[group.name]=flatten_group(group)
+		end
+	  end
+	  
+	  def flatten_group(group)
+		users = []
+		group.users.each do |user|
+			if user[0,1]=='@'
+				gname = user.gsub('@', '')
+				if ((@special_groups.include? gname) == false)
+					grp = @groups[gname]
+					gusr = flatten_group(grp)
+					if gusr != nil
+						users.concat(gusr)
+					end
+				end
+			else
+				users.push(user)
+			end
+		end
+		return users
+	  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::Dtg::Config::Repo)
+            when "group"
+              normalize_name(args[0], Gitolite::Dtg::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
+end