garlic 0.1.10

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+garlic-*.gem
+doc

data/History.txt

@@ -0,0 +1,64 @@
+== 0.1.10
+
+* 2 minor enhancements
+  * updated gemspec for gemcutter and rubyforge
+  * templates now include rails 2.3
+  
+  
+== 0.1.9
+
+* 1 major enhancement
+  * added garlic shell commands (sh/garlic.sh) for easing the garlic workflow
+    to use them, add this to your ~/.profile
+    
+      source `garlic --path`/sh/garlic.sh
+
+== 0.1.8
+
+* 1 bugfix
+  * fix problem where dependencies weren't checking out repo tags or branches properly
+
+== 0.1.7
+
+* 2 minor enhancement
+  * Fix problem whereby garlic update_repos wasn't updating repos correctly
+  * utilise Garlic::Generator in tabtab definition
+
+== 0.1.6 2008-11-27
+
+* 3 minor enhancements
+  * Updated Readme/TODO
+  * Some crufty output is now suppressed/removed
+  * garlic all command cleans the work path
+
+* 1 bugfix
+  * --targets, -t option now actually works
+
+== 0.1.5 2008-11-25
+
+* 4 minor enhancements
+  * Removed 'all_targets' - just use ruby to DRY up garlic.rb
+  * Changed templates wrt above
+  * Better tabtab completions
+  * Updated TODO
+
+== 0.1.4 2008-11-20
+
+* 1 minor enhancement
+  * Added tabtab definitions that are in the right place
+
+== 0.1.3 2008-11-20
+
+* 1 minor enhancement
+  * Added tabtab definitions
+
+== 0.1.2
+
+* 2 major enhancements
+  * garlic CLI
+  * repos are now stored in ~/.garlic/repos (and this shared across multiple garlic sessions), work is in ./.garlic
+
+== 0.1.1
+
+* 1 major enhancement:
+  * freelancing-god added gem goodness

data/License.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2009 Ian White - ian.w.white@ardes.com
+ 
+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

@@ -0,0 +1,143 @@
+= garlic
+
+<b>lightweight continuous integration for rails using git</b>
+
+This is not a CI server, use cruisecontrol.rb or integrity for that.  This is a simple set
+of commands (or rake tasks) that let you specify a bunch of rails builds to run against, and
+dependencies to install.
+
+This is aimed at testing plugins (or apps) against multiple versions of rails,
+and allows specifying other plugin dependencies (and their versions and any
+setup requried).
+
+If you want to run your specs (or whatever) against different versions of gems
+that you have installed, then check out {ginger}[http://github.com/freelancing-god/ginger] by {Pat Allen}[http://github.com/freelancing-god]
+
+Garlic works by cloning git repos for all your dependencies (so they all must be
+git repos), and then using git to checkout various tags and branches to build
+your app against.
+
+Here's an example of running a plugin against 3 different rails verisons and 3 different rspec versions: {gist 28786}[http://gist.github.com/28786]
+
+== It's still new, and not shiny yet
+
+Please feel free to make it shinier.  I'm successfully using it on most of my plugins, and I test
+with rspec and cucumber.
+
+Check out the {TODO LIST}[http://github.com/ianwhite/garlic/tree/master/Todo.txt]
+
+== Get up and running quickly
+
+You have a plugin and you want it tested against different versions of rails?
+
+<b>1.</b> install garlic as a gem (see below)
+
+<b>2.</b> cd into your (say, rspec tested) plugin directory
+
+  garlic generate rspec > garlic.rb
+  garlic install_repos
+  garlic
+
+<b>3.</b> See what happens, edit garlic.rb to change rails versions and other stuff.
+
+  garlic --help # will probably help
+
+== Installing
+
+Install the garlic gem
+
+  # from rubyforge or gemcutter
+  sudo gem install garlic
+  
+  # from github
+  sudo gem install ianwhite-garlic --source=http://gems.github.com
+
+(if you want the very latest version)
+
+  git clone git://github.com/ianwhite/garlic
+  cd garlic
+  rake package
+  sudo gem install pkg/garlic-<code>*</code>.gem
+
+== Example
+
+To see garlic in action, download resources_controller_, a rails plugin that uses garlic for CI.
+
+  git clone git://github.com/ianwhite/resources_controller 
+
+
+run garlic
+ 
+  garlic all
+
+This will clone all the required git repos (done only once), set up the target railses (done once), then run the targets.
+
+=== Once you've committed some changes
+
+You can prepare and run all the targets again (without fetching remote repos) by doing
+
+  garlic
+ 
+This will prepare all the targets, using the current HEAD of the repos, and run the
+CI task again.
+
+=== Specifying particular targets
+
+If you just want to run against a particular target or targets, you can use the -t option,
+or if using Rake, the TARGET or TARGETS env var.
+
+  garlic -t edge
+
+== Running Shell commands across multiple targets
+
+Check dis out
+
+  garlic shell  # {Example output}[http://gist.github.com/28795]
+  
+You can pipe any thing into garlic shell and it will execute across all of your garlic targets
+
+== Rake tasks
+
+If you prefer to use garlic via rake tasks, then just require 'garlic/tasks' and you'll get a bunch of em.
+Once required, do rake -T to see descriptions.
+
+== garlic workflow shell commands
+
+If you add the following line to your .profile
+
+  source `garlic --path`/sh/garlic.sh
+  
+Then you'll get these 4 new shell commands:
+
+  gcd [target]    cds into the specified target working repo
+  gcdp [target]   cds into the specified target plugin in the working repo
+  gup             cds back up to the garlic'd repo from within a working path
+  gpush [branch]  from within a working repo, pushes changes back to the local garlic target, and resets
+                  local changes in that target to HEAD.
+                  
+This means you might have a workflow as follows (example is for a plugin):
+
+  # run garlic, see probs in '2-2-stable'
+  
+  gcdp 2-2  # => takes you into the working repo in the '2-2-stable' target
+  
+  # fix the changes, make some commits
+  
+  gpush     # => pushes the changes back to the enclosing garlic'd repo
+  gup       # => go back up there
+  garlic    # => rerun garlic to see how the changes affect the other targets
+
+== Lend a hand
+
+This is an early release, so there is plenty of scope for changes and improvement
+If you want to lend a hand, get in touch.
+
+(c) Ian White 2008-2009 - ian.w.white@gmail.com
+MIT Licence
+
+== Lent a hand
+
+Thanks very much to:
+
+* Pat Allan
+* Dr Nic Williams (API suggestions)

data/Rakefile

@@ -0,0 +1,57 @@
+require 'rubygems'
+require 'spec'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+require 'rake/gempackagetask'
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/lib'
+
+require 'garlic'
+
+begin
+  require 'jeweler'
+  
+  Jeweler::Tasks.new do |s|
+    s.name = "garlic"
+    s.version = Garlic::Version::String
+    s.summary = "Test your project across multiple versions of rails/dependencies"
+    s.description = "CI tool to test your project across multiple versions of rails/dependencies"
+    s.email = "ian.w.white@gmail.com"
+    s.homepage = "http://github.com/ianwhite/garlic"
+    s.authors = ["Ian White"]
+    s.rubyforge_project = 'garlic'
+  end
+  
+  Jeweler::GemcutterTasks.new
+
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "doc"
+  end
+  
+  namespace :release do
+    desc "Release current version to github, gemcutter and rubyforge"
+    task :all => ['release', 'gemcutter:release', 'rubyforge:release']
+  end
+  
+rescue LoadError
+  puts "Jeweler not available for gem tasks. Install it with: sudo gem install jeweler"
+end
+
+begin
+  require 'hanna/rdoctask'
+rescue LoadError
+end  
+
+Rake::RDocTask.new(:doc) do |d|
+  d.options << '--all'
+  d.rdoc_dir = 'doc'
+  d.main     = 'README.rdoc'
+  d.title    = "garlic API Docs"
+  d.rdoc_files.include('README.rdoc', 'History.txt', 'License.txt', 'Todo.txt', 'VERSION', 'lib/**/*.rb')
+end
+task :rdoc => :doc
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.warning = true
+end
+task :default => :spec

data/Todo.txt

@@ -0,0 +1,4 @@
+* add 'gem' command - should it freeze the gem in to vendor/gems?
+* BETTER OUTPUT - even less uninteresting cruft in the output please
+* specs!
+* cucumber features!

data/VERSION

@@ -0,0 +1 @@
+0.1.10

data/bin/garlic

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby
+
+require 'getoptlong'
+require 'rubygems'
+require 'rake'
+require 'garlic'
+
+include Garlic
+
+USAGE = "USAGE: garlic [options] [command] (try garlic --help)"
+
+HELP = <<-end_doc
+garlic - run a command in different versions of rails
+
+USAGE:  garlic [options] [command]
+
+COMMANDS:
+#{Garlic::Session.commands_with_description.map{|method, desc| "  %-17s %s" % [method, desc]}.join("\n")}
+  
+  The default command is "default"
+  
+OPTIONS:
+  --help             -h  You're reading it
+  --verbose          -v  Show work
+  --config CONFIG    -c  Specify a different location of garlic config
+  --backtrace            Show ruby backtrace on error
+  --targets TARGETS  -t  Specify subset of targets comma separated or
+                         regexp part e.g. -t 2-1,2-2
+
+You can generate a sample garlic.rb with
+  garlic generate [TEMPLATE [PLUGIN_NAME]] (Available templates: #{available_templates.join(', ')})
+  
+end_doc
+
+@verbose = false
+
+GetoptLong.new(
+  ['--help', '-h', GetoptLong::NO_ARGUMENT],
+  ['--verbose', '-v', GetoptLong::NO_ARGUMENT],
+  ['--targets', '-t', GetoptLong::REQUIRED_ARGUMENT],
+  ['--config', '-c', GetoptLong::REQUIRED_ARGUMENT],
+  ['--backtrace', GetoptLong::NO_ARGUMENT],
+  ['--path', GetoptLong::NO_ARGUMENT],
+  ['--version', GetoptLong::NO_ARGUMENT]
+  ).each do |opt, arg|
+  case opt
+  when '--help' then STDOUT << HELP; exit true
+  when '--path' then puts File.dirname(File.dirname(File.expand_path(__FILE__))); exit true
+  when '--version' then puts Garlic::Version::String; exit true
+  when '--verbose' then @verbose = true
+  when '--config' then @config_file = arg
+  when '--targets' then @run_targets = arg
+  when '--backtrace' then @backtrace = true
+  end
+end
+
+begin
+  if ARGV.first == 'generate'
+    generate_config(*ARGV[1..-1])
+  else
+    # run a garlic command
+    raise "Unknown command: #{ARGV.first}" unless ARGV.empty? || Garlic::Session.commands.include?(ARGV.first)
+  
+    verbose(@verbose)
+    
+    # configure the garlic runner
+    garlic(@config_file) # load up the garlic instance
+    garlic.verbose = @verbose
+    garlic.run_targets = @run_targets
+  
+    # run the command
+    ARGV << 'default' if ARGV.empty?
+    garlic.send *ARGV
+  end
+  
+rescue Exception => e
+  STDERR << "\n#{USAGE}\n\nError: #{e.message}\n\n"
+  raise e if @backtrace
+  exit false
+end

data/garlic.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{garlic}
+  s.version = "0.1.10"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ian White"]
+  s.date = %q{2009-10-05}
+  s.default_executable = %q{garlic}
+  s.description = %q{CI tool to test your project across multiple versions of rails/dependencies}
+  s.email = %q{ian.w.white@gmail.com}
+  s.executables = ["garlic"]
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "History.txt",
+     "License.txt",
+     "README.rdoc",
+     "Rakefile",
+     "Todo.txt",
+     "VERSION",
+     "bin/garlic",
+     "garlic.gemspec",
+     "lib/garlic.rb",
+     "lib/garlic/configurator.rb",
+     "lib/garlic/generator.rb",
+     "lib/garlic/repo.rb",
+     "lib/garlic/session.rb",
+     "lib/garlic/shell.rb",
+     "lib/garlic/target.rb",
+     "lib/garlic/tasks.rb",
+     "lib/tabtab_definitions/garlic.rb",
+     "sh/garlic.sh",
+     "spec/garlic/repo_spec.rb",
+     "spec/spec_helper.rb",
+     "templates/default.rb",
+     "templates/rspec.rb",
+     "templates/shoulda.rb"
+  ]
+  s.homepage = %q{http://github.com/ianwhite/garlic}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{garlic}
+  s.rubygems_version = %q{1.3.4}
+  s.summary = %q{Test your project across multiple versions of rails/dependencies}
+  s.test_files = [
+    "spec/garlic/repo_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/garlic.rb

@@ -0,0 +1,34 @@
+require "garlic/session"
+require "garlic/configurator"
+require "garlic/repo"
+require "garlic/target"
+require "garlic/generator"
+require "garlic/shell"
+
+module Garlic
+  include Generator
+  
+  module Version
+    String = File.read(File.dirname(File.dirname(__FILE__)) + '/VERSION').strip
+    Major, Minor, Patch = String.split('.').map{|i| i.to_i}
+  end
+  
+  # return the current garlic session
+  def garlic(config = nil, &block)
+    @garlic ||= Garlic::Session.new(self)
+    load_config(config)
+    @garlic.configure(&block) if block_given?
+    @garlic
+  end
+  
+  # load config from 
+  def load_config(config = nil)
+    unless @garlic_config_file
+      @garlic_config_file = config || "garlic.rb"
+      unless File.exists?(@garlic_config_file)
+        raise "garlic requries a configuration file (can't find #{@garlic_config_file}), try:\n  garlic generate [#{available_templates.join('|')}] > garlic.rb"
+      end
+      eval File.read(@garlic_config_file)
+    end
+  end
+end

data/lib/garlic/configurator.rb

@@ -0,0 +1,59 @@
+module Garlic
+  # Configures the garlic runner in a decalarative style
+  class Configurator
+    attr_reader :garlic
+
+    def initialize(garlic, &block)
+      @garlic = garlic
+      instance_eval(&block) if block_given?
+    end
+
+    def repo(name, options = {})
+      options[:name] = name
+      options[:path] ||= "#{garlic.repo_path}/#{name}"
+      garlic.repos << Repo.new(options)
+    end
+    
+    def target(name, options = {}, &block)
+      options[:name] = name
+      options[:path] = "#{garlic.work_path}/#{name_to_path(name)}"
+      BlockParser.new(options, [:prepare, :run], &block) if block_given?
+      garlic.targets << Target.new(garlic, options)
+    end
+
+    def respond_to?(method)
+      super || garlic.respond_to?("#{method}=")
+    end
+    
+  protected
+    def name_to_path(name)
+      name.gsub(/[^\w\d_.-]/,'_').downcase
+    end
+    
+    def method_missing(attribute, value)
+      if garlic.respond_to?("#{attribute}=")
+        garlic.send("#{attribute}=", value)
+      else
+        super
+      end
+    end
+  
+    class BlockParser
+      attr_reader :options, :whitelist
+
+      def initialize(options, whitelist = [], &block)
+        @options = options
+        @whitelist = whitelist
+        instance_eval(&block)
+      end
+
+      def method_missing(method, *args, &block)
+        if block_given? && args.empty? && (whitelist.empty? || whitelist.include?(method))
+          options[method.to_sym] = block
+        else
+          raise ArgumentError, "Don't know how to parse #{method} #{args.inspect unless args.empty?}"
+        end
+      end
+    end
+  end
+end

data/lib/garlic/generator.rb

@@ -0,0 +1,29 @@
+require 'fileutils'
+
+module Garlic
+  # generate a garlic config file
+  module Generator
+    include FileUtils
+    
+    TEMPLATES_PATH = File.expand_path("~/.garlic/templates")
+    
+    def generate_config(template = 'default', plugin = nil)
+      raise "unknown template: #{template}.\nUse one of #{available_templates.join(', ')} or create your own in #{TEMPLATES_PATH}" unless available_templates.include?(template)
+      plugin ||= File.basename(File.expand_path('.'))
+      puts eval("<<-EOD\n" + File.read(File.join(TEMPLATES_PATH, "#{template}.rb")) + "\nEOD")
+    end
+    
+    def available_templates
+      copy_templates unless File.exists?(TEMPLATES_PATH)
+      Dir[File.join(TEMPLATES_PATH, '*')].map {|f| File.basename(f.sub(/.rb$/,'')) }
+    end
+    
+  protected
+    def copy_templates
+      mkdir_p TEMPLATES_PATH, :verbose => false
+      Dir[File.join(File.dirname(__FILE__), '../../templates/*.rb')].each do |file|
+        cp file, File.join(TEMPLATES_PATH, File.basename(file)), :verbose => false
+      end
+    end
+  end
+end

data/lib/garlic/repo.rb

@@ -0,0 +1,121 @@
+module Garlic
+  # This class represents a local git repo
+  class Repo
+    attr_reader :url, :local, :path, :name
+
+    def initialize(options = {})
+      if @url = options[:url]
+        @url = File.expand_path(@url) unless options[:url] =~ /^\w+(:|@)/
+      end
+      
+      @path = options[:path] or raise ArgumentError, "Repo requires a :path"
+      @path = File.expand_path(@path)
+      
+      @local = options[:local]
+      @local = File.expand_path(@local) if @local
+      
+      @name = options[:name] || File.basename(@path)
+    end
+
+    class<<self
+      def path?(path)
+        File.directory?(File.join(path, '.git'))
+      end
+
+      def tree_ish(options)
+        [:tree_ish, :tree, :branch, :tag, :commit, :sha].each do |key|
+          return options[key] if options[key]
+        end
+        nil
+      end
+      
+      def head_sha(path)
+        `cd #{path}; git log HEAD -1 --pretty=format:\"%H\"`
+      end
+    end
+    
+    def install
+      if File.exists?(path)
+        puts "\nSkipping #{name}, as it exists"
+      else
+        puts "\nInstalling #{name}"
+        sh "git clone #{url}#{" --reference #{local}" if local} #{path}"
+      end
+    end
+
+    def update
+      puts "\nUpdating #{name}..."
+      if Repo.path?(path)
+        if url
+          begin
+            checkout 'master'
+            cd(path) do
+              sh "git fetch origin", :verbose => false
+              sh "git pull", :verbose => false
+            end
+          rescue Exception => e
+            puts "\n\nIt seems there was a problem.\nTry running rake garlic:reset_repos\n\n"
+            raise e
+          end
+        else
+          puts "No url for #{name} given, so not updating"
+        end
+      elsif File.exists?(path)
+        raise "\nRepo #{name} (#{path}) is not a git repo.\nRemove it and run rake garlic:install_repos\n\n"
+      else
+        raise "\nRepo #{name} missing from #{path}.\nPlease run rake garlic:install_repos\n\n"
+      end
+    end
+
+    def check
+      if !Repo.path?(path)
+        raise "#{name} is missing from #{path}, or is not a git repo"
+      elsif url && !same_url?(origin_url)
+        raise "#{name}'s url has changed from #{url} to #{origin_url}"
+      end
+    end
+
+    def reset
+      cd(path) { sh "git reset --hard master" }
+      checkout('master')
+    end
+
+    def checkout(tree_ish)
+      cd(path) { sh "git checkout -q #{tree_ish}", :verbose => false }
+    end
+    
+    def export_to(export_path)
+      rm_rf export_path; mkdir_p export_path
+      cd(path) do
+        sh "git archive --format=tar HEAD > #{File.join(export_path, "#{name}.tar")}", :verbose => false
+      end
+      cd(export_path) do
+        `tar -x -f #{name}.tar`
+        rm "#{name}.tar"
+      end
+    end
+    
+    def clone_to(clone_path)
+      mkdir_p File.dirname(clone_path)
+      cd (File.dirname(clone_path)) do
+        sh "git clone #{path} #{clone_path}"
+      end
+    end
+
+    def origin_url
+      unless @origin_url
+        match = `cd #{path}; git remote show -n origin`.match(/URL: (.*)\n/)
+        @origin_url = (match && match[1])
+      end
+      @origin_url
+    end
+
+    def same_url?(url)
+      self.url.sub(/\/?(\.git)?$/, '') == url.sub(/\/?(\.git)?$/, '')
+    end
+
+    def head_sha
+      Repo.head_sha(path)
+    end
+  end
+end

data/lib/garlic/session.rb

@@ -0,0 +1,145 @@
+module Garlic
+  # this class runs the top level garlic commands
+  class Session
+    attr_reader :actor, :run_targets
+    attr_accessor :repos, :targets, :repo_path, :work_path, :verbose
+
+    def initialize(actor = nil, &block)
+      @actor = actor
+      self.repos = []
+      self.targets = []
+      self.work_path = ".garlic"
+      self.repo_path = "~/.garlic/repos"
+      configure(&block) if block_given?
+    end
+    
+    def configure(&block)
+      Configurator.new(self, &block)
+    end
+
+    def repo(name)
+      repos.detect {|r| r.name == name.to_s} or raise "Can't find repo: #{name}"
+    end
+
+    # convert a possible string argument into an array
+    def run_targets=(targets)
+      targets = targets.split(',').map{|t| t.strip} if targets.is_a?(String)
+      @run_targets = targets
+    end
+    
+    ### garlic commands ###
+    
+    # meta data about command methods which can be used by both rake and the cli tool
+    @@commands, @@command_descriptions = [], {}
+    
+    class << self
+      def define_command(name, desc, &block)
+        @@commands << name
+        @@command_descriptions[name] = desc
+        define_method name, &block
+      end
+      
+      def commands_with_description
+        @@commands.map{|m| [m, @@command_descriptions[m]]}
+      end
+      
+      def command_description(name)
+        @@command_descriptions[name]
+      end
+      
+      def commands
+        @@command_descriptions.keys.map {|c| c.to_s}
+      end
+    end
+
+    define_command :default, "Check repos, prepare TARGETs, and run TARGETs" do
+      check_repos
+      prepare
+      run
+    end
+    
+    define_command :all, "Install and update all repos, prepare and run TARGETs" do
+      install_repos
+      update_repos
+      clean
+      prepare
+      run
+    end
+    
+    define_command :install_repos, "Install required repositories" do
+      repos.each {|repo| repo.install}
+    end
+
+    define_command :update_repos, "Update repositories" do
+      repos.each {|repo| repo.update}
+    end
+
+    define_command :check_repos, "Check that repos are what they are supposed to be" do
+      errors = []
+      repos.each do |repo|
+        begin
+          repo.check
+        rescue Exception => e
+          errors << "- #{e.message}"
+        end
+      end
+      errors.length == 0 or raise "\n#{errors.join("\n")}\n\nPlease remove these repos and run garlic install_repos\n"
+    end
+
+    define_command :reset_repos, "Reset all repos to their master branch" do
+      repos.each {|repo| repo.reset}
+    end
+
+    define_command :clean, "Remove the work done by garlic" do
+      rm_rf work_path
+    end
+    
+    define_command :prepare, "Prepare each garlic TARGET" do
+      determine_targets.each {|target| target.prepare }
+    end
+
+    define_command :shell, "Run shell commands from stdin across specified targets" do |*path|
+      shell = Shell.new(determine_targets)
+      shell.current_path = path.first if path.first
+      shell.run
+    end
+    
+    define_command :path, "return the work dir for the specified target" do |*path_target|
+      self.run_targets = path_target.first if path_target.any?
+      puts determine_targets.first.path
+    end
+    
+    define_command :run, "Run each garlic TARGET" do
+      these_targets = determine_targets
+      target_names, failed_names = these_targets.map{|t| t.name}, []
+
+      puts "\n#{'='*78}\nTargets: #{target_names.join(', ')}\n#{'='*78}\n"
+      these_targets.each do |target|
+        puts "\n#{'-'*78}\nTarget: #{target.name} (commit #{target.rails_sha[0..6]}, run at #{Time.now})\n#{'-'*78}\n"
+        begin
+          target.run
+          puts "\ntarget: #{target.name} PASS"
+        rescue
+          puts "\ntarget: #{target.name} FAIL"
+          failed_names << target.name
+        end
+      end
+      puts "\n#{'='*78}\n"
+      failed_names.length > 0 and raise "The following targets passed: #{(target_names - failed_names).join(', ')}.\n\nThe following targets FAILED: #{failed_names.join(', ')}.\n\n"
+      puts "All specified targets passed: #{target_names.join(', ')}.\n\n"
+    end
+
+    def respond_to?(method)
+      super(method) || (actor && actor.respond_to?(method))
+    end
+
+protected
+    def method_missing(method, *args, &block)
+      actor ? actor.send(method, *args, &block) : super
+    end
+
+    def determine_targets
+      run_targets ? targets.select{|t| t.name =~ /(?:#{run_targets.join("|")})/i} : targets
+    end
+  end
+end

data/lib/garlic/shell.rb

@@ -0,0 +1,67 @@
+require 'fileutils'
+begin
+  require 'term/ansicolor'
+rescue LoadError
+end
+
+module Garlic
+  class Shell
+    include FileUtils
+    
+    attr_reader :current_path
+    
+    def initialize(targets)
+      @current_path = '.'
+      @targets = targets
+      raise "Garlic::Shell requires at least one target" if @targets.empty?
+    end
+    
+    def current_path=(path)
+      if path =~ /^(\/|\~)/
+        STDOUT << red << "#{path}: only relative paths allowed\n" << clear
+      else
+        full_path = File.expand_path(File.join(@targets.first.path, current_path, path))
+        if File.exists?(full_path)
+          @current_path = full_path.include?(@targets.first.path) ? full_path.sub(@targets.first.path,'') : '.'
+        else
+          STDOUT << red << "#{path}: no such directory\n" << clear
+        end
+      end
+    end
+      
+    def run
+      STDOUT << green << "Garlic interactive session: type shell commands\n" << clear << prompt
+      while (command = STDIN.gets) do
+        command.strip!.empty? || process(command)
+        STDOUT << prompt
+      end
+    rescue Interrupt
+    ensure
+      STDOUT << green << "Garlic interactive session ended\n" << clear
+    end
+    
+    def process(command)
+      if command =~ /^cd (.*)$/
+        self.current_path = $1
+      else
+        @targets.each do |target|
+          cd File.join(target.path, current_path) do
+            STDOUT << magenta << target.name + ":\n" << clear
+            system(command) || STDOUT << red << "command failed\n" << clear
+          end
+        end
+      end
+    end
+    
+  private
+    [:red, :green, :magenta, :clear].each do |colour|
+      define_method colour do
+        Term::ANSIColor.send(colour) rescue ""
+      end
+    end
+    
+    def prompt
+      green + "garlic:#{@current_path.sub(/^\.|\//,'')}> " + clear
+    end
+  end
+end

data/lib/garlic/target.rb

@@ -0,0 +1,126 @@
+require 'shell'
+
+module Garlic
+  class Target
+    attr_reader :garlic, :path, :name, :rails_repo_name, :tree_ish
+
+    def initialize(garlic, options = {})
+      @garlic = garlic
+      @tree_ish = Repo.tree_ish(options) || 'origin/master'
+      @rails_repo_name = options[:rails] || 'rails'
+      @path = options[:path] or raise ArgumentError, "Target requires a :path"
+      @path = File.expand_path(@path)
+      @name = options[:name] || File.basename(@path)
+      @prepare = options[:prepare]
+      @run = options[:run]
+    end
+    
+    def prepare
+      puts "\nPreparing target #{name} (#{tree_ish})"
+      install_rails
+      runner.run(&@prepare) if @prepare
+    end
+    
+    def run
+      runner.run(&@run) if @run
+    end
+    
+    def rails_sha
+      read_sha('vendor/rails')
+    end
+    
+    def shell
+      unless @shell
+        @shell = Shell.new
+        @shell.verbose = false
+        @shell.cd path
+      end
+      @shell
+    end
+    
+  private
+    def runner
+      @runner ||= Target::Runner.new(self)
+    end
+    
+    def read_sha(install_path)
+      File.read(File.join(path, install_path, '.git_sha')) rescue nil
+    end
+    
+    def write_sha(install_path, sha)
+      File.open(File.join(path, install_path, '.git_sha'), 'w+') {|f| f << sha}
+    end
+
+    def install_rails
+      rails_repo = garlic.repo(rails_repo_name)
+      rails_repo.checkout(tree_ish)
+      if File.exists?(path)
+        puts "Rails app for #{name} exists"
+      else
+        puts "Creating rails app for #{name}..."
+        `ruby #{rails_repo.path}/railties/bin/rails #{path}`
+      end
+      install_dependency(rails_repo, 'vendor/rails') { `rake rails:update` }
+    end
+
+    def install_dependency(repo, install_path = ".", options = {}, &block)
+      repo = garlic.repo(repo) unless repo.is_a?(Repo)
+      tree_ish = Repo.tree_ish(options)
+      
+      if options[:clone]
+        if Repo.path?(install_path)
+          puts "#{install_path} exists, and is a repo"
+          cd(install_path) { `git fetch origin` }
+        else
+          puts "cloning #{repo.name} to #{install_path}"
+          repo.clone_to(File.join(path, install_path))
+        end
+        cd(install_path) { `git checkout #{tree_ish || repo.head_sha}` }
+      
+      else
+        old_tree_ish = repo.head_sha
+        repo.checkout(tree_ish) if tree_ish       
+        if read_sha(install_path) == repo.head_sha
+          puts "#{install_path} is up to date at #{tree_ish || repo.head_sha[0..6]}"
+        else
+          puts "#{install_path} needs update to #{tree_ish || repo.head_sha[0..6]}, exporting archive from #{repo.name}..."
+          repo.export_to(File.join(path, install_path))
+          cd(path) { garlic.instance_eval(&block) } if block_given?
+          write_sha(install_path, repo.head_sha)
+        end
+        repo.checkout(old_tree_ish) if tree_ish
+      end
+    end
+    
+    
+    class Runner
+      attr_reader :target
+
+      def initialize(target)
+        @target = target
+      end
+      
+      def run(&block)
+        cd target.path do
+          instance_eval(&block)
+        end
+      end
+      
+      def method_missing(method, *args, &block)
+        target.garlic.send(method, *args, &block)
+      end
+
+      def respond_to?(method)
+        super(method) || target.garlic.respond_to?(method)
+      end
+
+      def plugin(plugin, options = {}, &block)
+        target.send(:install_dependency, plugin, "vendor/plugins/#{options[:as] || plugin}", options, &block)
+      end
+
+      def dependency(repo, dest, options = {}, &block)
+        target.send(:install_dependency, repo, dest, options, &block)
+      end
+    end
+  end
+end

data/lib/garlic/tasks.rb

@@ -0,0 +1,23 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'garlic'))
+
+include Garlic
+
+# configure the garlic runner
+garlic ENV['CONFIG'] do
+  verbose ['true', 'yes', '1'].include?(ENV['VERBOSE'])
+  run_targets ENV['TARGETS'] || ENV['TARGET']
+end
+
+desc "Run garlic:default (CONFIG=path, TARGETS=list, VERBOSE=true)"
+task :garlic do
+  garlic.default
+end
+
+namespace :garlic do
+  Garlic::Session.commands_with_description.each do |command, description|
+    desc description
+    task command do
+      garlic.send command
+    end
+  end
+end

data/lib/tabtab_definitions/garlic.rb

@@ -0,0 +1,15 @@
+require "garlic/session"
+require "garlic/generator"
+
+TabTab::Definition.register('garlic', :import => '--help') do |g|
+  Garlic::Session.commands.each do |c|
+    g.command c
+  end
+  
+  g.command :generate do
+    class << self
+      include Garlic::Generator
+    end
+    available_templates
+  end
+end

data/sh/garlic.sh

@@ -0,0 +1,34 @@
+# garlic shell helpers
+
+# cd into the work path of a garlic target
+gcd ()
+{
+  cd `garlic path $1`
+}
+
+# cd into probable plugin dir of a garlic target
+gcdp ()
+{
+  here=`pwd | sed 's/.*\///'`
+  cd `garlic path $1`/vendor/plugins/$here
+}
+
+# cd back up to enclosing garlic project
+gup ()
+{
+  cd `pwd | sed 's/\.garlic.*//'`
+}
+
+# push changes back to local garlic origin, resetting the origin
+gpush ()
+{
+  if [ `pwd | sed 's/\.garlic//'` == `pwd` ]; then
+      echo "gpush can only be used in a garlic work repo";
+  else
+    git push origin $1 2>&1 | grep -v warning;
+    here=`pwd`;
+    gup;
+    git reset --hard;
+    cd $here;
+  fi
+}

data/spec/garlic/repo_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Garlic::Repo do
+  describe "new(:url => 'some/local/repo', :path => 'some/dest')" do
+    before { @repo = Garlic::Repo.new(:url => 'some/local/repo', :path => 'some/dest') }
+    
+    it "should expand the path" do
+      @repo.path.should == File.expand_path('some/dest')
+    end
+    
+    it "should expand the url" do
+      @repo.url.should == File.expand_path('some/local/repo')
+    end
+    
+    it "should have name == 'dest' (basename of path)" do
+      @repo.name.should == 'dest'
+    end
+    
+    describe '#install' do
+      before do
+        @repo.stub!(:puts) # silence!
+      end
+      
+      it "should 'git clone <repo> <dest>" do
+        @repo.should_receive(:sh).with("git clone #{@repo.url} #{@repo.path}")
+        @repo.install
+      end
+    end
+  end
+  
+  describe "new(:url => 'git://remote/repo', :path => 'some/dest')" do
+    before { @repo = Garlic::Repo.new(:url => 'git://remote/repo', :path => 'some/dest') }
+    
+    it "should NOT expand the url" do
+      @repo.url == 'git://remote/repo'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'garlic'

data/templates/default.rb

@@ -0,0 +1,26 @@
+# typical vanilla garlic configuration
+
+garlic do
+  # this plugin
+  repo "#{plugin}", :path => '.'
+  
+  # other repos
+  repo "rails", :url => "git://github.com/rails/rails"
+  
+  # target railses
+  ['master', '2-3-stable', '2-2-stable', '2-1-stable', '2-0-stable'].each do |rails|
+
+    # declare how to prepare, and run each CI target
+    target rails, :tree_ish => "origin/#{rails}" do
+      prepare do
+        plugin "#{plugin}", :clone => true # so we can work in targets
+      end
+    
+      run do
+        cd "vendor/plugins/#{plugin}" do
+          sh "rake"
+        end
+      end
+    end
+  end
+end

data/templates/rspec.rb

@@ -0,0 +1,32 @@
+# typical rspec garlic configuration
+
+garlic do
+  # this plugin
+  repo "#{plugin}", :path => '.'
+  
+  # other repos
+  repo "rails", :url => "git://github.com/rails/rails"
+  repo "rspec", :url => "git://github.com/dchelimsky/rspec"
+  repo "rspec-rails", :url => "git://github.com/dchelimsky/rspec-rails"
+  
+  # target railses
+  ['master', '2-3-stable', '2-2-stable', '2-1-stable', '2-0-stable'].each do |rails|
+
+    # declare how to prepare, and run each CI target
+    target rails, :tree_ish => "origin/#{rails}" do
+      prepare do
+        plugin "#{plugin}", :clone => true # so we can work in targets
+        plugin "rspec"
+        plugin "rspec-rails" do
+          `script/generate rspec -f`
+        end
+      end
+    
+      run do
+        cd "vendor/plugins/#{plugin}" do
+          sh "rake"
+        end
+      end
+    end
+  end
+end

data/templates/shoulda.rb

@@ -0,0 +1,28 @@
+# typical shoulda garlic configuration
+
+garlic do
+  # this plugin
+  repo "#{plugin}", :path => '.'
+  
+  # other repos
+  repo "rails", :url => "git://github.com/rails/rails"
+  repo "shoulda", :url => "git://github.com/thoughtbot/shoulda"
+  
+  # target railses
+  ['master', '2-3-stable', '2-2-stable', '2-1-stable', '2-0-stable'].each do |rails|
+
+    # declare how to prepare, and run each CI target
+    target rails, :tree_ish => "origin/#{rails}" do
+      prepare do
+        plugin "#{plugin}", :clone => true # so we can work in targets
+        plugin "shoulda"
+      end
+    
+      run do
+        cd "vendor/plugins/#{plugin}" do
+          sh "rake"
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: garlic
+version: !ruby/object:Gem::Version 
+  version: 0.1.10
+platform: ruby
+authors: 
+- Ian White
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-05 00:00:00 -04:00
+default_executable: garlic
+dependencies: []
+
+description: CI tool to test your project across multiple versions of rails/dependencies
+email: ian.w.white@gmail.com
+executables: 
+- garlic
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- History.txt
+- License.txt
+- README.rdoc
+- Rakefile
+- Todo.txt
+- VERSION
+- bin/garlic
+- garlic.gemspec
+- lib/garlic.rb
+- lib/garlic/configurator.rb
+- lib/garlic/generator.rb
+- lib/garlic/repo.rb
+- lib/garlic/session.rb
+- lib/garlic/shell.rb
+- lib/garlic/target.rb
+- lib/garlic/tasks.rb
+- lib/tabtab_definitions/garlic.rb
+- sh/garlic.sh
+- spec/garlic/repo_spec.rb
+- spec/spec_helper.rb
+- templates/default.rb
+- templates/rspec.rb
+- templates/shoulda.rb
+has_rdoc: true
+homepage: http://github.com/ianwhite/garlic
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: garlic
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 3
+summary: Test your project across multiple versions of rails/dependencies
+test_files: 
+- spec/garlic/repo_spec.rb
+- spec/spec_helper.rb