ianwhite-garlic 0.1.2

data/CHANGELOG

@@ -0,0 +1,5 @@
+* 0.1.2
+  * making use of garlic as a gem
+  * changed paths, repos are now stored in ~/.garlic/repos (and this shared across multiple garlic sessions), work is in .garlic_work
+
+* 0.1.1 freelancing-god added gem goodness

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 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.textile

@@ -0,0 +1,206 @@
+h1. garlic: lightweight continuous integration for rails using git
+
+This is not a CI server, use cruisecontrol.rb for that.  This is a simple set
+of 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.
+
+h2. Get up and running quickly
+
+You have a plugin and you want it tested against different versions of rails?
+
+* install garlic as a gem (see below)
+* cd into your (say, rspec tested) plugin directory
+
+<pre>
+  garlic generate rspec > garlic.rb
+  garlic install_repos
+  garlic
+</pre>
+
+* See what happens, edit garlic.rb to change rails versions and other stuff.
+
+<pre>
+  garlic --help # will probably help
+</pre>
+
+h2. Installing
+
+Install the garlic gem
+
+  sudo gem install ianwhite-garlic --source=http://gems.github.com
+
+(if it's not installing as a gem from github)
+
+  git clone git://github.com/ianwhite/garlic
+  cd garlic
+  rake package
+  sudo gem install pkg/*.gem
+
+h2. Example
+
+To see garlic in action, download response_for, a rails plugin that uses
+garlic for CI.
+
+  git clone git://github.com/ianwhite/response_for 
+
+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.
+
+h3. Once you've made 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.
+
+h3. Specifying particular targets
+
+If you just want to run against a particular target or targets, you can use the TARGET or TARGETS
+env var.
+
+  garlic -t edge
+
+h2. Running Shell commands across multiple targets
+
+Check dis out
+
+  garlic shell  # "Example output":http://gist.github.com/21496
+  
+---
+
+The following still needs to be updated for the new gem/cmd-line version
+
+h2. Example workflow
+
+Let's say I'm patching resources_controller.
+
+First I grab it, and set up garlic
+  
+  git clone git://github.com/ianwhite/resources_controller.git
+  cd resources_controller
+  rake get_garlic
+  cp garlic_example.rb garlic.rb
+  # I could now edit garlic.rb to point the repos at my local copies, for speed
+  
+Now, I download and run the CI suite
+  
+  rake garlic:all
+
+Now, I make some changes
+
+  git checkout -b my_change
+  # ... commit some changes into 'my_change'
+  rake garlic
+  # ... everything is fine, so I can merge these into master, or send a pull request
+
+h3. How do I run the specs on uncommitted code?
+
+The best way is to make the changes in one of the 'work' targets.  For example:
+
+  # after running rake garlic:all
+  cd garlic/work/edge/vendor/plugins/resources_controller
+  # ... make changes without committing
+  rake spec
+  # ... it passes, so commit
+  git commit -m "My great change"
+  
+Now you can push these changes back upstream to your local 'master' repo
+
+  git push origin my_changes # or you could push to master branch or whatever
+  
+Then cd back up there, and run rake garlic to verify your changes against the other
+targets.  If these all pass, you can push, or send a pull request
+
+h2.How to add garlic to your repo (example: rails plugin)
+
+h4. 1. require the garlic tasks into your own Rakefile
+
+  # rescue this just in case the plugin user doesn't have garlic
+  begin
+    require 'garlic'
+  rescue LoadError
+  end
+
+h4. 2. add a garlic.rb
+
+An example garlic.rb:
+
+  garlic do
+    # 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'
+    repo 'resources_controller', :path => '.'
+
+    # targets
+    target 'edge'
+    target '2.0-stable', :branch => 'origin/2-0-stable'
+    target '2.0.2', :tag => 'v2.0.2'
+
+    all_targets do
+      prepare do
+        plugin 'resources_controller', :clone => true
+        plugin 'rspec'
+        plugin 'rspec-rails' do
+          sh "script/generate rspec -f"
+        end
+      end
+
+      run do
+        cd "vendor/plugins/resources_controller"
+          sh "rake spec:rcov:verify"
+        end
+      end
+    end
+  end
+  
+h4. 3. ignore the garlic artefacts
+
+Example .gitignore
+
+  .garlic_work
+  
+h4. 4. Run it
+
+  rake garlic:all
+  
+And to run it again, once you've made changes
+
+  rake garlic
+  
+To make sure you're running against the latest repos:
+
+  rake garlic:update_repos
+  
+h2. 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 - ian.w.white@gmail.com
+MIT Licence
+
+h2. Lent a hand
+
+Thanks very much to:
+
+* Pat Allan
+
+

data/TODO

@@ -0,0 +1,2 @@
+* specs
+* rewrite using grit? (research: is grit the defacto standard for ruby controlling git?)

data/bin/garlic

@@ -0,0 +1,74 @@
+#!/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::Runner.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
+  --targets TARGETS  -t  Specify subset of targets, e.g. edge,2.1.0 (default all)
+  --backtrace            Show ruby bakctrace on error
+
+You can generate a sample garlic.rb with
+  garlic generate [TEMPLATE [PLUGIN_NAME]] (Available templates: #{available_templates.join(', ')})
+  
+end_doc
+
+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]
+  ).each do |opt, arg|
+  case opt
+  when '--help' then STDOUT << HELP; 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
+  # generate a config file
+  if ARGV.first == 'generate'
+    generate_config(*ARGV[1..-1])
+    
+  # run a garlic command
+  else
+    raise "Unknown command: #{ARGV.first}" unless ARGV.empty? || Garlic::Runner.commands.include?(ARGV.first)
+  
+    # configure the garlic runner
+    garlic @config_file do
+      verbose @verbose
+      run_targets @run_targets
+    end
+  
+    # 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/lib/garlic/configurator.rb

@@ -0,0 +1,60 @@
+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 all_targets(options = {}, &block)
+      BlockParser.new(options, [:prepare, :run], &block) if block_given?
+      garlic.all_targets = options
+    end
+    
+    def target(name, options = {}, &block)
+      options[:name] = name
+      options[:path] = "#{garlic.work_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 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,27 @@
+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
+      Dir[File.join(File.dirname(__FILE__), '../../templates/*.rb')].each do |file|
+        cp file, File.join(TEMPLATES_PATH, File.basename(file))
+      end
+    end
+  end
+end

data/lib/garlic/repo.rb

@@ -0,0 +1,118 @@
+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) { sh "git pull origin master", :verbose => false }
+          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/runner.rb

@@ -0,0 +1,144 @@
+module Garlic
+  # this class runs the top level garlic commands
+  class Runner
+    attr_reader :actor, :run_targets
+    attr_accessor :repos, :targets, :all_targets, :repo_path, :work_path, :verbose
+
+    def initialize(actor = nil, &block)
+      @actor = actor
+      self.repos = []
+      self.targets = []
+      self.all_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
+      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
+      begin
+        determine_targets.each {|target| target.prepare }
+      ensure
+        repo('rails').checkout('master') # we get rails back to master if something goes wrong
+      end
+    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 :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| run_targets.include?(t.name)} : 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,138 @@
+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) || '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(&garlic.all_targets[:prepare]) if garlic.all_targets[:prepare]
+      runner.run(&@prepare) if @prepare
+    end
+    
+    def run(command = nil)
+      runner.run(&garlic.all_targets[:run]) if garlic.all_targets[: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}..."
+        sh "ruby #{rails_repo.path}/railties/bin/rails #{path}", :verbose => false
+      end
+      install_dependency(rails_repo, 'vendor/rails') { sh "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)
+      
+      puts tree_ish
+      
+      if options[:clone]
+        if Repo.path?(install_path)
+          puts "#{install_path} exists, and is a repo"
+          cd(install_path) { sh "git fetch origin" }
+        else
+          puts "cloning #{repo.name} to #{install_path}"
+          repo.clone_to(File.join(path, install_path))
+        end
+        cd(install_path) { sh "git checkout #{tree_ish || repo.head_sha}" }
+      
+      else
+        if read_sha(install_path) == repo.head_sha
+          puts "#{install_path} is up to date"
+        else
+          puts "#{install_path} needs update, exporting archive from #{repo.name}..."
+          if tree_ish
+            puts "Checking out #{tree_ish} of #{repo.name}"
+            old_tree_ish = repo.head_sha
+            repo.checkout(tree_ish) if tree_ish
+          end
+          
+          repo.export_to(File.join(path, install_path))
+          cd(path) { garlic.instance_eval(&block) } if block_given?
+          write_sha(install_path, repo.head_sha)
+          
+          if tree_ish
+            puts "Checking #{repo.name} back to where it was (#{old_tree_ish})"
+            repo.checkout(old_tree_ish)
+          end
+        end
+      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::Runner.commands_with_description.each do |command, description|
+    desc description
+    task command do
+      garlic.send command
+    end
+  end
+end

data/lib/garlic.rb

@@ -0,0 +1,37 @@
+require "garlic/runner"
+require "garlic/configurator"
+require "garlic/repo"
+require "garlic/target"
+require "garlic/generator"
+require "garlic/shell"
+
+module Garlic
+  include Generator
+  
+  module Version
+    Major = 0
+    Minor = 1
+    Tiny  = 2
+    
+    String = [Major, Minor, Tiny].join('.')
+  end
+  
+  # return the current garlic runner
+  def garlic(config = nil, &block)
+    @garlic ||= Garlic::Runner.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/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/templates/default.rb

@@ -0,0 +1,28 @@
+# typical vanilla garlic configuration
+
+garlic do
+  # this plugin
+  repo "#{plugin}", :path => '.'
+  
+  # other repos
+  repo "rails", :url => "git://github.com/rails/rails"
+  
+  # targets
+  target "edge", :branch => 'origin/master'
+  target "2.1", :branch => "origin/2-1-stable"
+  target "2.0", :branch => "origin/2-0-stable"
+  target "1.2", :branch => "origin/1-2-stable"
+  
+  # all targets
+  all_targets 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

data/templates/rspec.rb

@@ -0,0 +1,34 @@
+# 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"
+  
+  # targets
+  target "edge", :branch => 'origin/master'
+  target "2.1", :branch => "origin/2-1-stable"
+  target "2.0", :branch => "origin/2-0-stable"
+  target "1.2", :branch => "origin/1-2-stable"
+  
+  # all targets
+  all_targets do
+    prepare do
+      plugin "#{plugin}", :clone => true # so we can work in targets
+      plugin "rspec"
+      plugin "rspec-rails" do
+        sh "script/generate rspec -f"
+      end
+    end
+      
+    run do
+      cd "vendor/plugins/#{plugin}" do
+        sh "rake"
+      end
+    end
+  end
+end

data/templates/shoulda.rb

@@ -0,0 +1,30 @@
+# 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"
+  
+  # targets
+  target "edge", :branch => 'origin/master'
+  target "2.1", :branch => "origin/2-1-stable"
+  target "2.0", :branch => "origin/2-0-stable"
+  target "1.2", :branch => "origin/1-2-stable"
+  
+  # all targets
+  all_targets 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

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: ianwhite-garlic
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Ian White
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-11-02 00:00:00 -07:00
+default_executable: garlic
+dependencies: []
+
+description: Lightweight set of rake tasks to help with CI.
+email: ian.w.white@gmail.com
+executables: 
+- garlic
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/garlic/configurator.rb
+- lib/garlic/generator.rb
+- lib/garlic/repo.rb
+- lib/garlic/runner.rb
+- lib/garlic/shell.rb
+- lib/garlic/target.rb
+- lib/garlic/tasks.rb
+- lib/garlic.rb
+- templates/default.rb
+- templates/rspec.rb
+- templates/shoulda.rb
+- MIT-LICENSE
+- README.textile
+- TODO
+- CHANGELOG
+- spec/garlic/repo_spec.rb
+- bin/garlic
+has_rdoc: true
+homepage: http://github.com/ianwhite/garlic/tree
+post_install_message: 
+rdoc_options: 
+- --title
+- Garlic
+- --line-numbers
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Lightweight set of rake tasks to help with CI.
+test_files: 
+- spec/garlic/repo_spec.rb