cap-util 0.1.0

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.log
+*.rbc
+.bundle
+.config
+.yardoc
+.rvmrc
+.rbenv-version
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+gemspec
+
+gem 'bundler', '~>1.1'
+gem 'rake',    '~>0.9.2'

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 <TODO: copyright holders>
+
+MIT License
+
+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.md

@@ -0,0 +1,92 @@
+# CapUtil
+
+A set of utilities for writing cap tasks.  Use these to help extract business logic from your tasks and test them.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cap-util'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cap-util
+
+## The Mixin
+
+The main `CapUtil` mixin can be used to make any class a cap utility.  All the cap util requires is that your class define a `cap` method that returns an instance of a cap invocations.
+
+```ruby
+# in some_great_util.rb
+require 'cap-util'
+
+class SomeGreatUtil
+  include CapUtil
+
+  def initialize(cap)
+    @cap = cap
+  end
+
+  def do_something
+    run "echo something"
+  end
+end
+
+# in Capfile
+require 'some_great_util.rb'
+
+desc "some great util"
+task :some_great_util do
+  SomeGreatUtil.new(self).do_something
+end
+```
+
+The goal here is to move all cap task business logic into neat little classes that can be unit tested.  In addition, the mixin provides a bunch of helpers for running commands, halting tasks, outputting info, and timing tasks.
+
+## FakeCap helper
+
+The `FakeCap` helper class is handy to use when testing your cap utils.  CapUtil uses it in its own test suite.  It fakes a common subset of cap functions so that they can be safely tested against.  Extend it to suit your own test suite's needs.
+
+## UnsetVar helper
+
+The `UnsetVar` helper class is handy for defining cap vars that need to have a value set in some other context.  Think of it as the equivalent of raising a `NotImplementedError` in a method.  If the variable used without being overridden first, the deploy is halted with a message.
+
+To use:
+
+```ruby
+# in your Capfile...
+
+# halt with the default msg ":application var not set."
+set :application, CapUtil::UnsetVar.new(:application)
+
+# halt with the custom msg ":stage var not set (no stage task used)."
+set :stage, CapUtil::UnsetVar(:stage, "no stage task used")
+```
+
+## RakeTask util
+
+This util is handy for running a rake task remotely using a cap task.  It constructs a command that cd's to the rakefile root dir and runs the specified task.  That constructed command that command can then be run using cap.
+
+By default, it expects the rakefile to be in the `:current_path` and uses bundler to run `rake`.  These defaults can be overriden by passing options to the constructor.
+
+To use, do something like:
+
+```ruby
+# in your Capfile...
+
+task :some_rake_task do
+  CapUtil::RakeTask.new(self, "a:task:to:run").run
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+
+require 'assert/rake_tasks'
+Assert::RakeTasks.install
+
+require 'bundler/gem_tasks'
+
+task :default => :build

data/cap-util.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/cap-util/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name        = "cap-util"
+  gem.version     = CapUtil::VERSION
+  gem.description = %q{A set of utilities for writing cap tasks.}
+  gem.summary     = %q{A set of utilities for writing cap tasks.}
+
+  gem.authors     = ["Kelly Redding"]
+  gem.email       = ["kelly@kellyredding.com"]
+  gem.homepage    = "http://github.com/redding/cap-util"
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency("assert")
+  gem.add_dependency("capistrano")
+  gem.add_dependency("scmd", ["~>1.1"])
+
+end

data/lib/cap-util.rb

@@ -0,0 +1,29 @@
+require 'cap-util/say'
+require 'cap-util/run'
+require 'cap-util/halt'
+require 'cap-util/time'
+
+require 'cap-util/unset_var'
+
+module CapUtil
+
+  def self.included(receiver)
+    receiver.send(:attr_accessor, :cap)
+
+    receiver.send(:include, CapUtil::Say)
+    receiver.send(:include, CapUtil::Halt)
+    receiver.send(:include, CapUtil::Run)
+    receiver.send(:include, CapUtil::Time)
+  end
+
+  def get(*args, &block)
+    cap.get(*args, &block)
+  end
+
+  def hostname
+    val = ""
+    run("hostname") {|ch, stream, out| val = out.strip}
+    val
+  end
+
+end

data/lib/cap-util/fake_cap.rb

@@ -0,0 +1,35 @@
+require 'ostruct'
+
+module CapUtil
+  class FakeCap
+
+    attr_reader :roles, :cmds_run
+
+    def initialize(*args)
+      @struct = OpenStruct.new
+      @roles = []
+      @cmds_run = []
+    end
+
+    def method_missing(method, *args, &block)
+      @struct.send(method, *args, &block)
+    end
+
+    def respond_to?(method)
+      @struct.respond_to?(method) ? true : super
+    end
+
+    def run(*args)
+      @cmds_run << args
+    end
+
+    def fetch(var_name)
+      self.send("fetch_#{var_name}")
+    end
+
+    def role(name, hostname, opts)
+      @roles << [name, hostname, opts]
+    end
+
+  end
+end

data/lib/cap-util/halt.rb

@@ -0,0 +1,23 @@
+module CapUtil
+
+  class DeployHalted < RuntimeError
+    def backtrace; []; end
+  end
+
+  def self.halt(msg='deploy halted')
+    raise CapUtil::DeployHalted, color(msg, :bold, :yellow)
+  end
+
+  module Halt
+
+    def self.included(receiver)
+      receiver.send(:extend,  HaltMethods)
+      receiver.send(:include, HaltMethods)
+    end
+
+    module HaltMethods
+      def halt(*args); CapUtil.halt(*args); end
+    end
+
+  end
+end

data/lib/cap-util/rake_task.rb

@@ -0,0 +1,30 @@
+require 'cap-util'
+
+module CapUtil
+
+  # This defines a base utiltiy for building tasks that run rake tasks.  Pass
+  # in the rake task name and this will make sure it is run with the appropriate
+  # settings and environment
+
+  class RakeTask
+    include CapUtil
+
+    attr_reader :cmd
+
+    def initialize(cap, task, opts=nil)
+      @cap = cap
+
+      opts        ||= {}
+      opts[:root] ||= :current_path
+      opts[:rake] ||= "bundle exec rake"
+      opts[:env]  ||= ""
+      rakefile_root = cap.send(opts[:root])
+
+      @cmd = "cd #{rakefile_root} && #{opts[:env]} #{opts[:rake]} #{task}"
+    end
+
+    def run; super(@cmd); end
+
+  end
+
+end

data/lib/cap-util/run.rb

@@ -0,0 +1,60 @@
+require 'scmd'
+
+module CapUtil
+
+  def self.run_locally(cmd_str)
+    cmd = Scmd.new(cmd_str)
+
+    log "running `#{cmd}'"
+    cmd.run
+    log_error(cmd.stderr) if !cmd.success?
+
+    cmd
+  end
+
+  def self.run_locally_with_stdin(cmd_str, input)
+    cmd = Scmd.new(cmd_str)
+
+    log "running `#{cmd}'"
+    cmd.run(input)
+    log_error(cmd.stderr) if !cmd.success?
+
+    cmd
+  end
+
+  module Run
+
+    def self.included(receiver)
+      receiver.send(:extend,  RunLocalMethods)
+      receiver.send(:include, RunLocalMethods)
+      receiver.send(:include, InstanceMethods)
+    end
+
+    module RunLocalMethods
+      def run_locally(*args); CapUtil.run_locally(*args); end
+      def run_locally_with_stdin(*args); CapUtil.run_locally_with_stdin(*args); end
+    end
+
+    module InstanceMethods
+
+      def run(*args, &block)
+        cap.run(*args, &block)
+      end
+
+      def run_with_stdin(cmd_str, input, opts={})
+        run(cmd_str, opts.merge(:pty => true)) {|ch, stream, out| ch.send_data(input + "\n")}
+      end
+
+      def run_as(user, cmd_str, opts={}, &block)
+        as_cmd_str = "su #{user} -lc '#{cmd_str.gsub("'", "\\'")}'"
+        run(as_cmd_str, opts, &block)
+      end
+
+      def run_as_with_stdin(user, cmd_str, input, opts={})
+        run_as(user, cmd_str, opts) {|ch, stream, out| ch.send_data(input + "\n")}
+      end
+
+    end
+
+  end
+end

data/lib/cap-util/say.rb

@@ -0,0 +1,41 @@
+require 'capistrano/cli'
+
+module CapUtil
+
+  def self.color(*args)
+    Capistrano::CLI.ui.color(*args)
+  end
+
+  def self.say(msg, *args)
+    Capistrano::CLI.ui.say("  #{msg}", *args)
+  end
+
+  def self.log(msg, *args)
+    say("* #{msg}", *args)
+  end
+
+  def self.log_error(msg, *args)
+    say("  #{color "[ERROR]", :bold, :red} #{msg}", *args)
+  end
+
+  def self.log_warning(msg, *args)
+    say("  #{color "[WARN]", :bold, :yellow} #{msg}", *args)
+  end
+
+  module Say
+
+    def self.included(receiver)
+      receiver.send(:extend,  SayMethods)
+      receiver.send(:include, SayMethods)
+    end
+
+    module SayMethods
+      def color(*args);       CapUtil.color(*args);       end
+      def say(*args);         CapUtil.say(*args);         end
+      def log(*args);         CapUtil.log(*args);         end
+      def log_error(*args);   CapUtil.log_error(*args);   end
+      def log_warning(*args); CapUtil.log_warning(*args); end
+    end
+
+  end
+end

data/lib/cap-util/time.rb

@@ -0,0 +1,30 @@
+require 'cap-util/timer'
+
+module CapUtil
+
+  def self.time(timer_set, name, &block)
+    timer_set[name] = CapUtil::Timer.new(name)
+    if !block.nil?
+      begin
+        timer_set[name].start
+        block.call
+      ensure
+        timer_set[name].end
+      end
+    end
+    timer_set[name]
+  end
+
+  module Time
+
+    def self.included(receiver)
+      receiver.send(:extend,  TimeMethods)
+      receiver.send(:include, TimeMethods)
+    end
+
+    module TimeMethods
+      def time(*args, &block); CapUtil.time(*args, &block); end
+    end
+
+  end
+end

data/lib/cap-util/timer.rb

@@ -0,0 +1,32 @@
+module CapUtil
+  class Timer
+
+    def self.pretty_time(elapsed)
+      "#{elapsed / 60}:#{(elapsed % 60).to_s.rjust(2, '0')}"
+    end
+
+    attr_reader :name, :start_time, :end_time, :elapsed_time
+
+    def initialize(name, quiet=nil)
+      @name, @start_time, @end_time, @elapsed_time = name, 0, 0, 0
+      @quiet = !!(quiet == :quiet)
+    end
+
+    def start(time=nil)
+      say "  Starting #{CapUtil.color @name, :cyan}." if !@quiet
+      @start_time = (time || Time.now)
+    end
+
+    def end(time=nil)
+      @end_time = (time || Time.now)
+      @elapsed_time = @end_time - @start_time
+      if !@quiet
+        elapsed = self.class.pretty_time(@elapsed_time.to_i)
+        say "  #{CapUtil.color @name, :bold, :yellow} completed in"\
+            " #{CapUtil.color elapsed, :underline, :yellow}."
+      end
+      @end_time
+    end
+
+  end
+end

data/lib/cap-util/unset_var.rb

@@ -0,0 +1,10 @@
+module CapUtil
+  module UnsetVar
+
+    def self.new(name, msg=nil)
+      halt_msg = msg ? ":#{name} var not set (#{msg})." : ":#{name} var not set."
+      Proc.new { CapUtil.halt(halt_msg) }
+    end
+
+  end
+end

data/lib/cap-util/version.rb

@@ -0,0 +1,3 @@
+module CapUtil
+  VERSION = "0.1.0"
+end

data/test/cap_util_tests.rb

@@ -0,0 +1,69 @@
+require 'assert'
+
+module CapUtil
+
+  class CapUtilTests < Assert::Context
+    desc "the CapUtil module"
+    setup do
+      @mod = CapUtil
+    end
+    subject { @mod }
+
+    should have_imeth :halt, :time
+    should have_imeths :color, :say, :log, :log_error, :log_warning
+    should have_imeths :run_locally, :run_locally_with_stdin
+
+  end
+
+  class HaltTests < CapUtilTests
+    desc "`halt` util methods"
+
+    should "raise a `DeployHalted` custom exception" do
+      assert_raises(CapUtil::DeployHalted) { subject.halt }
+    end
+  end
+
+  class CapUtilMixinTests < Assert::Context
+    desc "the CapUtil mixin"
+    setup do
+      @cap_util = TestHelpers::AnCapUtil.new(FakeCap.new)
+    end
+    subject { @cap_util }
+
+    should have_accessor :cap
+
+    should have_cmeth :halt
+    should have_imeth :halt
+
+    should have_cmeths :color, :say, :log, :log_error, :log_warning
+    should have_imeths :color, :say, :log, :log_error, :log_warning
+
+    should have_cmeths :run_locally, :run_locally_with_stdin
+    should have_imeths :run_locally, :run_locally_with_stdin
+    should have_imeths :run, :run_with_stdin, :run_as, :run_as_with_stdin
+
+    should have_cmeth :time
+    should have_imeth :time
+
+    should have_imeths :get, :hostname
+
+  end
+
+  class DeployHaltedTests < Assert::Context
+    desc "the CapUtility DeployHalted custome exception"
+    setup do
+      @err = CapUtil::DeployHalted.new
+    end
+    subject { @err }
+
+    should "be a `RuntimeError`" do
+      assert_kind_of RuntimeError, subject
+    end
+
+    should "have no backtrace" do
+      assert_empty subject.backtrace
+    end
+
+  end
+
+end

data/test/fake_cap_tests.rb

@@ -0,0 +1,30 @@
+require 'assert'
+
+require 'cap-util/fake_cap'
+
+module CapUtil
+
+  class FakeCapTests < Assert::Context
+    desc "the fake cap helper"
+    setup do
+      @fc = FakeCap.new
+    end
+    subject { @fc }
+
+    should have_imeths :method_missing, :respond_to?
+    should have_imeths :run, :fetch, :role
+    should have_readers :roles, :cmds_run
+
+    should "store off args to run cmd calls" do
+      assert_empty subject.cmds_run
+
+      subject.run(:a, 1)
+      assert_equal [:a, 1], subject.cmds_run.last
+
+      subject.run
+      assert_equal [], subject.cmds_run.last
+    end
+
+  end
+
+end

data/test/helper.rb

@@ -0,0 +1,21 @@
+# this file is automatically required in when you require 'assert' in your tests
+# put test helpers here
+
+# add root dir to the load path
+$LOAD_PATH.unshift(File.expand_path("../..", __FILE__))
+
+require 'cap-util'
+require 'cap-util/fake_cap'
+
+module TestHelpers
+
+  class AnCapUtil
+    include CapUtil
+
+    def initialize(cap)
+      @cap = cap
+    end
+
+  end
+
+end

data/test/irb.rb

@@ -0,0 +1,9 @@
+require 'assert/setup'
+
+# this file is required in when the 'irb' rake test is run.
+# b/c 'assert/setup' is required above, the test helper will be
+# required in as well.
+
+# put any IRB setup code here
+
+require 'cap-util'

data/test/rake_task_tests.rb

@@ -0,0 +1,57 @@
+require 'assert'
+
+require 'cap-util/rake_task'
+
+module CapUtil
+
+  class RakeTaskTests < Assert::Context
+    desc "the rake task util"
+    setup do
+      @fake_cap = FakeCap.new
+      @fake_cap.fetch_rake = "bundle exec rake"
+      @fake_cap.current_path = "/a/current/path"
+      @fake_cap.release_path = "/dat/release/path"
+      @rake_task_util = RakeTask.new(@fake_cap, 'a:task:to:run')
+    end
+    subject { @rake_task_util }
+
+    should have_imeths :run
+
+    should "build a rake task to run" do
+      assert_match 'rake ', subject.cmd
+      assert_match ' a:task:to:run', subject.cmd
+    end
+
+    should "run the task with bundler by default" do
+      assert_match 'bundle exec rake', subject.cmd
+    end
+
+    should "run the task with a custom rake if given" do
+      task = RakeTask.new(@fake_cap, '', :rake => '/path/to/rake')
+      assert_match '/path/to/rake', task.cmd
+    end
+
+    should "use cap's current path by default" do
+      assert_match "cd #{@fake_cap.current_path} &&", subject.cmd
+    end
+
+    should "use a custom cap path if given" do
+      task = RakeTask.new(@fake_cap, '', :root => :release_path)
+      assert_match "cd #{@fake_cap.release_path} &&", task.cmd
+    end
+
+    should "use a custom env var string if given" do
+      task = RakeTask.new(@fake_cap, '', :env => "FOO=bar")
+      assert_match "FOO=bar bundle", task.cmd
+    end
+
+    should "run its rake cmd" do
+      exp_cmd = "cd /a/current/path &&  bundle exec rake a:task:to:run"
+      subject.run
+
+      assert_equal [exp_cmd], @fake_cap.cmds_run.last
+    end
+
+  end
+
+end

data/test/timer_tests.rb

@@ -0,0 +1,49 @@
+require 'assert'
+
+require 'cap-util/timer'
+
+module CapUtil
+
+  class TimerTests < Assert::Context
+    desc "the Timer helper class"
+    setup do
+      @timer_util = Timer.new('a timer', :quiet)
+    end
+    subject { @timer_util }
+
+    should have_readers :name, :start_time, :end_time, :elapsed_time
+    should have_imeths  :start, :end
+    should have_cmeth   :pretty_time
+
+    should "know its name" do
+      assert_equal 'a timer', subject.name
+    end
+
+    should "default its start, end, and elapsed times" do
+      assert_equal 0, subject.start_time
+      assert_equal 0, subject.end_time
+      assert_equal 0, subject.elapsed_time
+    end
+
+    should "record its start time on `start`" do
+      exp_start_time = ::Time.now
+      subject.start(exp_start_time)
+
+      assert_equal exp_start_time, subject.start_time
+    end
+
+    should "record its end and elapsed time on `end`" do
+      exp_start_time = ::Time.now
+      subject.start(exp_start_time)
+      sleep 1
+      exp_end_time = ::Time.now
+      subject.end(exp_end_time)
+
+      assert_equal exp_end_time, subject.end_time
+      assert_equal (exp_end_time - exp_start_time), subject.elapsed_time
+      assert_equal "0:01", Timer.pretty_time(subject.elapsed_time.to_i)
+    end
+
+  end
+
+end

data/test/unset_var_tests.rb

@@ -0,0 +1,44 @@
+require 'assert'
+
+require 'cap-util/unset_var'
+
+module CapUtil
+
+  class UnsetVarTests < Assert::Context
+    desc "the unset var helper"
+    setup do
+      @var_name = 'test'
+      @unset = UnsetVar.new(@var_name)
+    end
+    subject { @unset }
+
+    should "be a proc" do
+      assert_kind_of ::Proc, subject
+    end
+
+    should "raise `DeployHalted` when called" do
+      assert_raises(CapUtil::DeployHalted) { subject.call }
+    end
+
+    should "raise with a default msg based on the variable name" do
+      exp_msg = ":#{@var_name} var not set."
+      begin
+        subject.call
+      rescue CapUtil::DeployHalted => err
+        assert_match exp_msg, err.message
+      end
+    end
+
+    should "accept a custom msg to raise with" do
+      exp_msg = ":#{@var_name} var not set (a custom err msg)."
+      unset = CapUtil::UnsetVar.new(@var_name, exp_msg)
+      begin
+        unset.call
+      rescue CapUtil::DeployHalted => err
+        assert_match exp_msg, err.message
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,136 @@
+--- !ruby/object:Gem::Specification 
+name: cap-util
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Kelly Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-10-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: assert
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id001
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: capistrano
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  requirement: *id002
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  name: scmd
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 13
+        segments: 
+        - 1
+        - 1
+        version: "1.1"
+  type: :runtime
+  requirement: *id003
+  prerelease: false
+description: A set of utilities for writing cap tasks.
+email: 
+- kelly@kellyredding.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- cap-util.gemspec
+- lib/cap-util.rb
+- lib/cap-util/fake_cap.rb
+- lib/cap-util/halt.rb
+- lib/cap-util/rake_task.rb
+- lib/cap-util/run.rb
+- lib/cap-util/say.rb
+- lib/cap-util/time.rb
+- lib/cap-util/timer.rb
+- lib/cap-util/unset_var.rb
+- lib/cap-util/version.rb
+- test/cap_util_tests.rb
+- test/fake_cap_tests.rb
+- test/helper.rb
+- test/irb.rb
+- test/rake_task_tests.rb
+- test/timer_tests.rb
+- test/unset_var_tests.rb
+homepage: http://github.com/redding/cap-util
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A set of utilities for writing cap tasks.
+test_files: 
+- test/cap_util_tests.rb
+- test/fake_cap_tests.rb
+- test/helper.rb
+- test/irb.rb
+- test/rake_task_tests.rb
+- test/timer_tests.rb
+- test/unset_var_tests.rb