rubolite 0.0.1 → 0.0.2

data/.gitignore

@@ -12,7 +12,11 @@ test/tmp
 test/version_tmp
 tmp
 
+# Ignore gitolite-admin
+spec/support/gitolite-admin
+
 # YARD artifacts
 .yardoc
 _yardoc
 doc/
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -1,4 +1,13 @@
 rubolite
 ========
 
-Rubolite is an interface to Gitolite (https://github.com/sitaramc/gitolite)
+Rubolite is an interface to Gitolite (https://github.com/sitaramc/gitolite)
+
+This is a work in progress. It's end goal is to give a full interface to interact with Gitolite and save changes.
+
+```
+>> admin = Rubolite::Admin.new("/Users/robertross/Sites/gitolite-admin")
+=> #<Rubolite::Admin:0x007f96be332de8 @path="/Users/robertross/Sites/gitolite-admin">
+>> admin.parser.repos.first
+=> #<Rubolite::Repo:0x007f96be347068 @name="gitolite-admin", @users=[#<Rubolite::User:0x007f96be346dc0 @name="gitolite", @permissions="RW+">]>
+```

data/lib/rubolite/admin.rb

@@ -0,0 +1,54 @@
+require "git"
+
+module Rubolite
+  class Admin
+    InvalidPath = Class.new(Exception)
+    InvalidGitRepo = Class.new(Exception)
+    InvalidRepo = Class.new(Exception)
+
+    attr_reader :path, :repos
+
+    def initialize(path=nil)
+      @path = path if path && valid_path?(path)
+    end
+
+    def path=(new_path)
+      valid_path?(new_path)
+      @path = new_path
+    end
+
+    def add_repo(repo)
+      raise InvalidRepo, "Repo not type of Rubolite::Repo, got #{repo.class}" unless repo.kind_of?(Repo)
+      (@repos ||= []) << repo
+    end
+    alias :<< :add_repo
+
+    def parser
+      @parser ||= Parser.new("#{path}/conf/gitolite.conf")
+    end
+
+    def writer
+      @writer ||= parser.writer
+    end
+
+    def git
+      @git ||= Git.open(path)
+    end
+
+    def repo_origin
+      @repo_origin ||= git.remote("origin")
+    end
+
+    def client
+      @client ||= Client.new(self)
+    end
+
+    private
+
+    def valid_path?(path)
+      raise InvalidPath, "#{path} is not a directory" unless File.directory?(path)
+      raise InvalidGitRepo, "#{path} is not a git repository" unless File.directory?("#{path}/.git")
+      true
+    end
+  end
+end

data/lib/rubolite/client.rb

@@ -0,0 +1,55 @@
+module Rubolite
+  class Client
+    attr_reader :admin, :ssh_keys
+
+    def initialize(admin)
+      @admin = admin
+      @ssh_keys = {}
+    end
+
+    def repos
+      @repos ||= admin.parser.repos
+    end
+
+    def groups
+      @groups ||= admin.parser.groups
+    end
+
+    def add_group(name, users)
+      groups[name] = users
+    end
+
+    def add_repo(repo)
+      repos << repo
+    end
+
+    def add_ssh_key(user, ssh_key)
+      ssh_keys[user] = ssh_key
+    end
+
+    def save!
+      admin.writer.write!
+    end
+
+    def save_ssh_keys!
+      ssh_keys.each do |user, key|
+        key.write_for user, "#{admin.path}/keydir"
+      end
+    end
+
+    def commit!
+      admin.git.commit_all("Modified configuration by rubolite")
+    end
+
+    def push!
+      admin.git.push(admin.repo_origin)
+    end
+
+    def save_and_push!
+      save!
+      save_ssh_keys!
+      commit!
+      push!
+    end
+  end
+end

data/lib/rubolite/parser.rb

@@ -0,0 +1,77 @@
+module Rubolite
+  class Parser
+    attr_reader :conf_file, :repos, :groups
+
+    def initialize(conf_file)
+      @conf_file = conf_file
+      @groups = {}
+      parse!
+    end
+
+    def writer
+      @writer ||= Writer.new(self)
+    end
+
+    def parse_repo_line(repo_line)
+      if matched = repo_line.match(/repo ([\w\-\d]+)/)
+        matched[1]
+      else
+        nil
+      end
+    end
+
+    def parse_permissions_line(permission_line)
+      if matched = permission_line.match(/([R|W|\+\-]+)\s+=\s+([\@\w\d\-]+)/)
+        [matched[1], matched[2]]
+      else
+        []
+      end
+    end
+
+    def parse_group_line(group_line)
+      if matched = group_line.match(/@([\w]+)\s+=\s+(.*)/)
+        group_name = matched[1]
+        names = matched[2].split(" ")
+        
+        [group_name, names]
+      else
+        nil
+      end
+    end
+
+    private
+
+    def parse!
+      current_repo = nil
+
+      conf_contents.each do |line|
+        keyword = line.strip
+        case keyword
+        when /^repo\s/
+          repo_name = parse_repo_line(line)
+          repo = Repo.new(repo_name)
+
+          (@repos ||= []) << repo
+
+          current_repo = repo
+        when /^(R|W|\-)/
+          next unless current_repo
+
+          permissions, user = parse_permissions_line(line)
+          user = User.new(user, permissions)
+          current_repo.add_user(user)
+        when /^@\w/
+          group_name, users = parse_group_line(line)
+          @groups[group_name] ||= [] 
+          @groups[group_name] += users
+        end
+      end
+
+      self
+    end
+
+    def conf_contents
+      @conf_contents ||= File.readlines(conf_file)
+    end
+  end
+end

data/lib/rubolite/repo.rb

@@ -0,0 +1,15 @@
+module Rubolite
+  class Repo
+    attr_accessor :name
+    attr_reader :users
+
+    def initialize(name=nil)
+      @name = name
+      @users = []
+    end
+
+    def add_user(user)
+      (@users ||= []) << user
+    end
+  end
+end

data/lib/rubolite/ssh_key.rb

@@ -0,0 +1,40 @@
+module Rubolite
+  # http://unix.stackexchange.com/questions/23590/ssh-public-key-comment-separator
+  # This class represents the structure of SSH public keys as defined in RFC4716
+
+  class SSHKey
+    attr_accessor :type, :key, :comment
+
+    def initialize(type, key, comment)
+      self.type    = type
+      self.key     = key
+      self.comment = comment
+    end
+
+    def self.from_file(path)
+      key_contents = File.read(path)
+      new(*key_parts(key_contents))
+    end
+
+    def self.from_string(string)
+      new(*key_parts(string))
+    end
+
+    def self.key_parts(key_contents)
+      key_contents.split " "
+    end
+
+    def write_for(username, directory)
+      File.open("#{directory}/#{username}.pub", "w") do |handle|
+        handle.write public_key_contents
+        handle.close
+      end
+    end
+
+    private
+
+    def public_key_contents
+      [type, key, comment].join(" ")
+    end
+  end
+end

data/lib/rubolite/user.rb

@@ -0,0 +1,10 @@
+module Rubolite
+  class User
+    attr_accessor :name, :permissions
+
+    def initialize(name=nil, permissions=nil)
+      self.name = name
+      self.permissions = permissions
+    end
+  end
+end

data/lib/rubolite/version.rb

@@ -1,3 +1,3 @@
 module Rubolite
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/rubolite/writer.rb

@@ -0,0 +1,40 @@
+module Rubolite
+  class Writer
+    attr_accessor :write_path
+    attr_reader :parser
+
+    def initialize(parser)
+      @parser = parser
+      @write_path = parser.conf_file
+    end
+
+    def write!
+      File.open(write_path, "w") do |handler|
+        handler.write groups
+        handler.write repos
+      end
+    end
+
+    def groups
+      parser.groups.each_with_object([]) do |(name, users), lines|
+        lines << "@#{name} = #{users.join(" ")}"
+      end.join("\n") + "\n\n"
+    end
+
+    def repos
+      parser.repos.each_with_object([]) do |repo, blocks|
+        blocks << repo_block(repo)
+      end.join("\n\n") + "\n"
+    end
+
+    def repo_block(repo)
+      lines = []
+      lines << "repo #{repo.name}"
+      repo.users.each do |user|
+        lines << "    #{user.permissions} = #{user.name}"
+      end
+
+      lines.join("\n")
+    end
+  end
+end

data/lib/rubolite.rb

@@ -1,5 +1,11 @@
 require "rubolite/version"
+require "rubolite/admin"
+require "rubolite/repo"
+require "rubolite/user"
+require "rubolite/parser"
+require "rubolite/writer"
+require "rubolite/ssh_key"
+require "rubolite/client"
 
 module Rubolite
-  
 end

data/rubolite.gemspec

@@ -16,4 +16,12 @@ Gem::Specification.new do |gem|
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
+
+  gem.add_development_dependency "rspec", "~> 2.11.0"
+  gem.add_development_dependency "guard-rspec"
+  gem.add_development_dependency "awesome_print"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "fakefs"
+
+  gem.add_dependency "git", "~> 1.2.5"
 end

data/spec/fixtures/example.pub

@@ -0,0 +1 @@
+ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC/Zkiw2QoYtekwZUYULwQsrPJubWafiuewoP03DRn3xjwoNo0q7FE0nIw2ENODiaM8KD0+L+ax0UCdNcCiJYuzouHENBvXYxsWSk5sZicRWINJ91Jd6KZnMvCr06oObNnJKdE+7UxeC06512nBREW7xHc4urHSiBoejx8fJOUraI6Y0t+Y7l4EiugTUcZLdN3b4YNksQvv16GDnreS+0SkZKcU5zj8pIE3DRBvs8MeuK5N1oQQNkbLXLbTtBqTPfiQz7Ikj8YFaBBX8rXd66yu0sMjGImxWZjBNGPscvch/G5MGSabpRSZALWi+uN67CxJcj3vZPg6mJSxnpsXxOdZ robertross@paperwalls.local

data/spec/fixtures/gitolite-conf.conf

@@ -0,0 +1,9 @@
+@staff = gitolite robert
+
+repo gitolite-admin
+    RW+     =   gitolite
+
+repo gitolite-awesome
+    R     =    robert
+    RW    =    bobby-tables
+    -     =    somedude

data/spec/lib/rubolite/admin_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+
+describe Rubolite::Admin do
+  subject { Rubolite::Admin.new }
+
+  it "returns a client object" do
+    expect(subject.client).to be_kind_of Rubolite::Client
+  end
+
+  context "location" do
+    it "sets a location on initialization if given" do
+      admin = Rubolite::Admin.new("./spec/support/gitolite-admin")
+      expect(admin.path).to eq("./spec/support/gitolite-admin")
+    end
+
+    it "sets a location for a repository" do
+      path_location = "./spec/support/gitolite-admin"
+      subject.path = path_location
+      expect(subject.path).to eq(path_location)
+    end
+
+    it "raises an error when the path is bad" do
+      expect { subject.path = "./idontexist" }.to raise_error(Rubolite::Admin::InvalidPath)
+    end
+
+    it "raises an error when the path given isn't a git repository" do
+      expect { subject.path = "./spec/support" }.to raise_error(Rubolite::Admin::InvalidGitRepo)
+    end
+
+    it "does not raise an error when the path given is a valid git repository" do
+      expect { subject.path = "./spec/support/gitolite-admin" }.not_to raise_error(Rubolite::Admin::InvalidGitRepo)
+    end
+  end
+
+  context "adding repos" do
+    let(:repo) { Rubolite::Repo.new }
+
+    it "adds a repo" do
+      subject.add_repo repo
+      subject.should have(1).repos
+    end
+
+    it "raises when trying to add a repo of a bad class" do
+      expect { subject.add_repo "bad" }.to raise_error(Rubolite::Admin::InvalidRepo)
+    end
+  end
+
+  context "config parsing" do
+    it "#parser returns a parser object" do
+      subject.path = "./spec/support/gitolite-admin"
+      expect(subject.parser).to be_kind_of Rubolite::Parser
+    end
+
+    it "#writer returns a writer object" do
+      subject.path = "./spec/support/gitolite-admin"
+      expect(subject.writer).to be_kind_of Rubolite::Writer
+    end
+  end
+
+  context "git" do
+    subject { Rubolite::Admin.new("./spec/support/gitolite-admin") }
+
+    specify "#git returns a grit repo instance" do
+      expect(subject.git).to be_kind_of Git::Base
+    end
+  end
+end

data/spec/lib/rubolite/client_spec.rb

@@ -0,0 +1,76 @@
+require "spec_helper"
+
+describe Rubolite::Client do
+  let(:admin) { Rubolite::Admin.new("./spec/support/gitolite-admin") }
+  subject { Rubolite::Client.new(admin) }
+
+  it "initializes with an admin object" do
+    expect { Rubolite::Client.new(admin) }.not_to raise_error
+  end
+
+  context "repos" do
+    it "represents repos from the parser" do
+      expect(subject.repos.map(&:name)).to include "gitolite-admin"
+    end
+
+    specify "#add_repo adds a repo" do
+      subject.add_repo Rubolite::Repo.new("awesome-repo")
+      subject.should have(3).repos
+    end
+  end
+
+  context "groups" do
+    specify "#add_group adds a group" do
+      subject.add_group "staff", ["robert", "bobby"]
+      subject.should have(1).groups
+    end
+
+    specify "#add_group adds a group with users" do
+      subject.add_group "staff", ["robert", "bobby"]
+      expect(subject.groups["staff"]).to eq %w(robert bobby)
+    end
+  end
+
+  context "ssh keys" do
+    specify "#add_ssh_key adds an ssh key" do
+      subject.add_ssh_key "robert", Rubolite::SSHKey.new("ssh-rsa", "whatupfinger", "robert@local")
+      subject.should have(1).ssh_keys
+    end
+  end
+
+  context "saving" do
+    it "saves changes" do
+      admin.writer.should_receive(:write!)
+      subject.save!
+    end
+
+    it "saves ssh keys" do
+      ssh_key = Rubolite::SSHKey.new("ssh-rsa", "whatupfinger", "robert@local")
+      key_path = "#{admin.path}/keydir"
+
+      ssh_key.should_receive(:write_for).with("robert", key_path)
+
+      subject.add_ssh_key("robert", ssh_key)
+      subject.save_ssh_keys!
+    end
+
+    it "commits the changes to the repo" do
+      admin.git.should_receive(:commit_all)
+      subject.commit!
+    end
+
+    it "pushes changes" do
+      origin = admin.repo_origin
+      admin.git.should_receive(:push).with(origin)
+      subject.push!
+    end
+
+    it "saves, commits, and pushes" do
+      subject.should_receive(:save!)
+      subject.should_receive(:save_ssh_keys!)
+      subject.should_receive(:commit!)
+      subject.should_receive(:push!)
+      subject.save_and_push!
+    end
+  end
+end

data/spec/lib/rubolite/parser_spec.rb

@@ -0,0 +1,89 @@
+require "spec_helper"
+
+describe Rubolite::Parser do
+  subject { Rubolite::Parser.new("./spec/fixtures/gitolite-conf.conf") }
+  
+  it "initializes with a conf file" do
+    conf_file = "./spec/fixtures/gitolite-conf.conf"
+    parser = Rubolite::Parser.new(conf_file)
+    expect(parser.conf_file).to eq(conf_file)
+  end
+
+  specify "#writer returns a writer object" do
+    expect(subject.writer).to be_kind_of Rubolite::Writer
+  end
+
+  context "parses" do
+
+    specify "repo lines" do
+      expect(subject.parse_repo_line("repo somerepo")).to eq("somerepo")
+    end
+
+    context "permissions" do
+      specify "read permissions" do
+        line = "R = robert"
+        expect(subject.parse_permissions_line(line)).to eq(["R", "robert"])
+      end
+
+      specify "write permissions" do
+        line = "W = robert"
+        expect(subject.parse_permissions_line(line)).to eq(["W", "robert"])
+      end
+
+      specify "read / write permissions" do
+        line = "RW = robert"
+        expect(subject.parse_permissions_line(line)).to eq(["RW", "robert"])
+      end
+
+      specify "read / write / force-push permissions" do
+        line = "RW+ = robert"
+        expect(subject.parse_permissions_line(line)).to eq(["RW+", "robert"])
+      end
+
+      specify "any push permissions" do
+        line = "- = robert"
+        expect(subject.parse_permissions_line(line)).to eq(["-", "robert"])
+      end
+
+      specify "space agnostic" do
+        line = "RW+       =      robert"
+        expect(subject.parse_permissions_line(line)).to eq(["RW+", "robert"])
+      end
+    end
+
+    it "parses repos" do
+      repo_names = subject.repos.map(&:name)
+      expect(repo_names).to include "gitolite-admin"
+      expect(repo_names).to include "gitolite-awesome"
+    end
+
+    it "parses users" do
+      repo = subject.repos.select {|r| r.name == "gitolite-admin" }.first
+      expect(repo).to have(1).users
+    end
+
+    it "parses users with permissions" do
+      repo = subject.repos.select {|r| r.name == "gitolite-admin" }.first
+      user = repo.users.first
+
+      expect(user.permissions).to eq "RW+"
+    end
+
+    it "parses multiple users" do
+      repo = subject.repos.select {|r| r.name == "gitolite-awesome" }.first
+      expect(repo).to have(3).users
+    end
+
+    context "groups" do
+      let(:group_line) { "@somegroup = robert bobby lauren" }
+
+      it "returns group name and users" do
+        expect(subject.parse_group_line(group_line)).to eq ["somegroup", %w(robert bobby lauren)]
+      end
+
+      it "parses groups" do
+        subject.should have(1).groups
+      end
+    end
+  end
+end

data/spec/lib/rubolite/repo_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+
+describe Rubolite::Repo do
+  subject { Rubolite::Repo.new }
+  let(:admin) { Rubolite::Admin.new }
+
+  context "names" do
+    specify { expect(subject).to respond_to :name= }
+    specify { expect(subject).to respond_to :name }
+
+    it "initializes with a name" do
+      repo = Rubolite::Repo.new("newname")
+      expect(repo.name).to eq("newname")
+    end
+  end
+
+  context "users" do
+    let(:user) { Rubolite::User.new "robert", "RW+" }
+    let(:repo) { Rubolite::Repo.new("newname") }
+
+    it "adds a user" do
+      repo.add_user(user)
+      expect(repo.users).to include user
+    end
+  end
+end

data/spec/lib/rubolite/ssh_key_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Rubolite::SSHKey do
+  context "from a file" do
+    it "generates an ssh key from a file" do
+      ssh_key = Rubolite::SSHKey.from_file("./spec/fixtures/example.pub")
+
+      # Yes this should be 3 separate tests but it's ok, we'll live.
+      expect(ssh_key.type).to eq("ssh-rsa")
+      expect(ssh_key.key).to eq("AAAAB3NzaC1yc2EAAAADAQABAAABAQC/Zkiw2QoYtekwZUYULwQsrPJubWafiuewoP03DRn3xjwoNo0q7FE0nIw2ENODiaM8KD0+L+ax0UCdNcCiJYuzouHENBvXYxsWSk5sZicRWINJ91Jd6KZnMvCr06oObNnJKdE+7UxeC06512nBREW7xHc4urHSiBoejx8fJOUraI6Y0t+Y7l4EiugTUcZLdN3b4YNksQvv16GDnreS+0SkZKcU5zj8pIE3DRBvs8MeuK5N1oQQNkbLXLbTtBqTPfiQz7Ikj8YFaBBX8rXd66yu0sMjGImxWZjBNGPscvch/G5MGSabpRSZALWi+uN67CxJcj3vZPg6mJSxnpsXxOdZ")
+      expect(ssh_key.comment).to eq("robertross@paperwalls.local")
+    end
+  end
+
+  context "from a string" do
+    it "generates an ssh key from a string" do
+      ssh_key = Rubolite::SSHKey.from_string("ssh-rsa somekeyfingerprint comment")
+      expect(ssh_key.type).to eq("ssh-rsa")
+      expect(ssh_key.key).to eq("somekeyfingerprint")
+      expect(ssh_key.comment).to eq("comment")
+    end
+  end
+
+  context "saving", fake_fs: true do
+    subject { Rubolite::SSHKey.from_string("ssh-rsa awesomekeyprint robertross@local") }
+
+    before(:each) { FileUtils.mkdir_p("./spec/fixtures") }
+
+    it "saves a public key for a username to a path" do
+      subject.write_for "kermit", "./spec/fixtures"
+      expect(File.exists?("./spec/fixtures/kermit.pub")).to be_true
+    end
+  end
+end

data/spec/lib/rubolite/user_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe Rubolite::User do
+  subject { Rubolite::User.new }
+
+  context "names" do
+    specify { expect(subject).to respond_to :name= }
+    specify { expect(subject).to respond_to :name }
+  end
+
+  context "permissions" do
+    specify { expect(subject).to respond_to :permissions= }
+    specify { expect(subject).to respond_to :permissions }
+  end
+
+  it "initializes with a name and permissions" do
+    user = Rubolite::User.new("robert", "RW+")
+    expect(user.name).to eq("robert")
+    expect(user.permissions).to eq("RW+")
+  end
+end

data/spec/lib/rubolite/writer_spec.rb

@@ -0,0 +1,65 @@
+require "spec_helper"
+require "tempfile"
+
+describe Rubolite::Writer do
+  subject { Rubolite::Writer.new(writer_parser) }
+  let(:temp_file) { Tempfile.new("writespec") }
+
+  let(:writer_parser) { Rubolite::Parser.new("./spec/fixtures/gitolite-conf.conf") }
+  let(:parser) { Rubolite::Parser.new(temp_file.path) }
+
+  before(:each) { subject.write_path = temp_file.path }
+
+  it "sets write path to parser config path on initialize" do
+    writer = Rubolite::Writer.new(parser)
+    expect(writer.write_path).to eq parser.conf_file
+  end
+
+  it "accepts a write path" do
+    expect(subject).to respond_to :write_path
+    expect(subject).to respond_to :write_path=
+  end
+
+  context "groups" do
+    it "creates groups correctly" do
+      expect(subject.groups).to include "@staff = gitolite robert"
+    end
+
+    it "writes groups correctly" do
+      subject.write!
+      expect(parser).to have(1).groups
+    end
+  end
+
+  context "repos" do
+    it "creates repos correctly" do
+      expect(subject.repos).to include "repo gitolite-admin"
+      expect(subject.repos).to include "repo gitolite-awesome"
+    end
+
+    it "writes repos correctly" do
+      subject.write!
+      expect(parser).to have(2).repos
+    end
+
+    context "users" do
+      let(:repo) { Rubolite::Repo.new("somerepo") }
+      before(:each) do
+        repo.add_user Rubolite::User.new "robert", "RW+"
+      end
+
+      it "adds users for a repo block correctly" do
+        expect(subject.repo_block(repo)).to include "RW+ = robert"
+      end
+
+      it "writes users correctly" do
+        subject.write!
+        repo = parser.repos.select {|r| r.name == "gitolite-admin" }.first
+        user = repo.users.select {|u| u.name == "gitolite" }.first
+
+        expect(user.name).to eq("gitolite")
+        expect(user.permissions).to eq("RW+")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require "rubolite"
+require "ap"
+require "pry"
+require 'fakefs/spec_helpers'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.include FakeFS::SpecHelpers, fake_fs: true
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubolite
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,104 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-11 00:00:00.000000000 Z
-dependencies: []
+date: 2012-11-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.11.0
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.5
 description: Rubolite is a ruby interface to gitolite.
 email:
 - robert@creativequeries.com
@@ -19,13 +115,32 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - lib/rubolite.rb
+- lib/rubolite/admin.rb
+- lib/rubolite/client.rb
+- lib/rubolite/parser.rb
+- lib/rubolite/repo.rb
+- lib/rubolite/ssh_key.rb
+- lib/rubolite/user.rb
 - lib/rubolite/version.rb
+- lib/rubolite/writer.rb
 - rubolite.gemspec
+- spec/fixtures/example.pub
+- spec/fixtures/gitolite-conf.conf
+- spec/lib/rubolite/admin_spec.rb
+- spec/lib/rubolite/client_spec.rb
+- spec/lib/rubolite/parser_spec.rb
+- spec/lib/rubolite/repo_spec.rb
+- spec/lib/rubolite/ssh_key_spec.rb
+- spec/lib/rubolite/user_spec.rb
+- spec/lib/rubolite/writer_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/bobbytables/rubolite
 licenses: []
 post_install_message: 
@@ -50,4 +165,14 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: This gem allows you to administer your gitolite instance
-test_files: []
+test_files:
+- spec/fixtures/example.pub
+- spec/fixtures/gitolite-conf.conf
+- spec/lib/rubolite/admin_spec.rb
+- spec/lib/rubolite/client_spec.rb
+- spec/lib/rubolite/parser_spec.rb
+- spec/lib/rubolite/repo_spec.rb
+- spec/lib/rubolite/ssh_key_spec.rb
+- spec/lib/rubolite/user_spec.rb
+- spec/lib/rubolite/writer_spec.rb
+- spec/spec_helper.rb