rockit-now 0.1.0

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+.idea
+.rockit

data/.rvmrc

@@ -0,0 +1 @@
+rvm --create ruby-1.9.2-p290@rockit

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode # JRuby in 1.8 mode
+  - jruby-19mode # JRuby in 1.9 mode

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in rockit.gemspec
+gemspec
+
+group :development do
+  # for travis-ci.org
+  gem "rake"
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2012 Ben Willis
+
+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,73 @@
+# Rockit [![Build Status](https://secure.travis-ci.org/bwillis/rockit.png?branch=master)](http://travis-ci.org/bwillis/rockit) [![Gem Status](https://gemnasium.com/bwillis/rockit.png?travis)](https://gemnasium.com/bwillis/rockit)
+
+Rockit is a dsl to help setup, detect changes and keep your environment up-to-date so you can start working as fast as possible.
+
+## Install - NOT AVAILABLE YET
+
+```gem install rockit-now```
+
+## How to use
+
+Rockit is run at the command line and can be followed by other commands to execute after.
+
+Command line :
+
+```rockit <any command>```
+
+Include in a ruby file :
+
+```ruby
+require 'rockit'
+Rockit::Application.run
+```
+
+## RockitFile Configuration
+
+Rockit requires a RockitFile for configuration. This is where you use ruby code and some helpful methods to define your environment. It is highly recommended that you commit your configuration to ensure quick and easy setup.
+
+### Commands and Services
+
+All applications require certain commands and services are available before you can get going. If you want to just require these print a message and exit you can use these shortcuts :
+
+```ruby
+command "convert"
+service "mysql"
+```
+
+For more control when the services or commands are missing you can use the following syntax :
+
+```ruby
+if_command_missing "convert" do
+  puts "required command 'convert' is not available."
+  exit
+end
+
+if_service_not_running "mysql" do
+  puts "required service 'mysql' is not running."
+  exit
+end
+```
+
+### Changes
+
+Applications environments are always changing and your local environment needs to react to them. For instance, when working in a rails team, migrations and gems are often changed and need to be updated. Add the following to your configurtion to detect changes and automatically keep stay up-to-date :
+
+```ruby
+if_directory_changed "db/migrate" do
+  run "rake db:migrate"
+end
+
+if_file_changed "Gemfile" do
+  run "bundle"
+end
+```
+
+### Documentation and Examples
+
+Documentation is available http://rubydoc.info/github/bwillis/rockit/master/frames
+
+You can find [example configurations](http://github.com/bwillis/rockit/blob/master/example/Rockitfile)
+
+# License
+
+Rockit is released under the MIT license: www.opensource.org/licenses/MIT

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/gem_tasks"
+
+require "bundler"
+Bundler.setup
+
+require "rspec"
+require "rspec/core/rake_task"
+
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+
+Bundler::GemHelper.install_tasks
+
+task :default => :spec
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end

data/bin/rockit

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'rockit/cli'
+
+Rockit::Cli.start

data/example/Rockitfile

@@ -0,0 +1,51 @@
+# Rockitfile
+
+###### Require Commands ######
+
+# command 'convert' is equivalent to
+if_command_missing "convert" do
+  puts "required command 'convert' is not available."
+  exit
+end
+
+###### Required Service ######
+
+# service 'mysql' is equivalent to
+if_service_not_running "mysql" do
+  puts "required service 'mysql' is not running."
+  exit
+end
+
+#service "redis" is equivalent to
+if_service_not_running "redis" do
+  puts "required service 'redis' is not running."
+  exit
+end
+
+#service 'memcache' is equivalent to
+if_service_not_running "memcache" do
+  puts "required service 'memcache' is not running."
+  exit
+end
+
+###### Rails Checks ######
+
+if_file_changed "Gemfile" do
+  run "bundle"
+end
+
+if_first_time do
+  run "rake db:create"
+end
+
+if_directory_changed "db/migrate" do
+  run "rake db:migrate"
+end
+
+if_file_changed "db/seeds.rb" do
+  puts "Seeds file has changed, press 'y' if you want to run rake db:reset:"
+  if gets.chomp == 'y'
+    run "rake db:reset"
+    run "rake db:seed"
+  end
+end

data/lib/rockit.rb

@@ -0,0 +1,4 @@
+require 'rockit/version'
+require 'rockit/application'
+require 'rockit/hash_store'
+require 'rockit/cli'

data/lib/rockit/application.rb

@@ -0,0 +1,164 @@
+require 'digest'
+require 'fileutils'
+
+require 'rockit/dsl'
+require 'rockit/hash_store'
+
+module Rockit
+
+  class Application
+
+    def initialize(store=nil)
+      @hash_store = store || HashStore.new
+    end
+
+    # Run a Rockit configuration file and Rails dependency checks
+    # unless turned off by configuration.
+    def run(rockit_file="Rockitfile")
+      raise ArgumentError unless File.exists?(rockit_file)
+      Dsl.new(self).instance_eval(File.read(rockit_file), rockit_file)
+    end
+
+    # Remove the cache directory
+    def clear_cache
+      @hash_store.clear
+    end
+
+    # Determine if the command exists on the current system (uses which). If it does
+    # not hard exit with a message to stdout.
+    #
+    # command - the string of the command to find
+    # options - see system_exit_on_error
+    #
+    # return only if it finishes successfully
+    def command(command, options)
+      options = {
+        'print_command' => false,
+        'failure_message' => "required command '#{command}' is not available."
+      }.merge(string_keys(options))
+      system_exit_on_error("which #{command}", options)
+    end
+
+    # Identify if a service is running on the system (uses ps). If it does not
+    # hard exit with a message to stdout.
+    #
+    # service_name - the name of the service to find in ps
+    # options - see system_exit_on_error
+    #
+    # return only if it finishes successfully
+    def service(service_name, options={})
+      options = {
+        'print_command' => false,
+        'failure_message' => "required service '#{service_name}' is not running."
+      }.merge(string_keys(options))
+      system_exit_on_error("ps ax | grep '#{service_name.gsub(/^(.)/, "[\\1]")}'", options)
+    end
+
+    # If the directly file listing changes, execute the block.
+    def if_directory_changed(directory, &block)
+      if_string_digest_changed(directory, Dir.glob("#{directory}/*").join(","), &block)
+    end
+
+    # First time executed call the block.
+    def if_first_time(&block)
+      if_string_changed("first_time", "done", &block)
+    end
+
+    # If the digest of the input is different from the stored key, execute the block.
+    def if_string_digest_changed(key, input, &block)
+      if_string_changed(key, Digest::SHA256.new.update(input.to_s).hexdigest.to_s, &block)
+    end
+
+    # If the digest of the file is different from the stored digest, execute the block.
+    def if_file_changed(file, &block)
+      if_string_changed(file, Digest::SHA256.file(file).hexdigest.to_s, &block)
+    end
+
+    # Execute the given block if the input is different from
+    # the output .
+    #
+    # key - the key to lookup the stored hash value
+    # new_value - the value to compare with the stored hash value
+    # block - block to execute if the hash value does not match the stored hash value
+    #
+    # return if the block was not executed, false, if it is executed, the return
+    #         status of the block
+    def if_string_changed(key, new_value, &block)
+      if new_value != @hash_store[key]
+        old_value = @hash_store[key]
+        @hash_store[key] = new_value
+        block.call(key, new_value, old_value) if block_given?
+      end
+    end
+
+    # Run system commands and if not successful exit and print out an error
+    # message. Default behavior is to print output of a command when it does
+    # not return success.
+    #
+    # command - the system command you want to execute
+    # options - 'error_message' - a message to print when command is not successful
+    #           'print_command' - displays the command being run
+    #           'failure_callback' - Proc to execute when the command fails
+    #           'on_success' - Proc to execute when the command is successful
+    #
+    # returns only true, will perform exit() when not successful
+    #
+    def system_exit_on_error(command, options={})
+      options = {'print_command' => true}.merge(string_keys(options))
+      output command if options['print_command']
+      command_output = system_command(command)
+      unless last_process.success?
+        options['on_failure'].call(command, options) if options['on_failure'].is_a?(Proc)
+        output options['failure_message'] || command_output
+        return exit(last_process.exitstatus)
+      end
+      options['on_success'].call(command, options) if options['on_success'].is_a?(Proc)
+      true
+    end
+
+    # Execute a system command and return the result. Guard against calls
+    # to `rm -rf`.
+    #
+    # command - the system command to execute
+    #
+    # returns the result of the command execution
+    #
+    # raises exception on calls to `rm -rf`
+    #
+    def system_command(command)
+      raise "No I'm not going to delete your hd" if command.strip == "rm -rf"
+      `#{command}`
+    end
+
+    # Pulling from ActiveSupport::CoreExtensions::Hash::Keys to avoid
+    # having to include the entire gem.
+    #
+    # hash - the hash to convert keys to strings
+    #
+    # returns a new hash with only string keys
+    def string_keys(hash={})
+      hash.inject({}) do |options, (key, value)|
+        options[key.to_s] = value
+        options
+      end
+    end
+
+    private
+
+    # Helper to the last process, mainly for testing.
+    def last_process
+      $?
+    end
+
+    # Helper to a hard exit, mainly for testing.
+    def exit(status)
+      Kernel.exit(status)
+    end
+
+    # Helper to output to stdout.
+    def output(s)
+      puts s
+    end
+
+  end
+end

data/lib/rockit/cli.rb

@@ -0,0 +1,22 @@
+require 'rockit/application'
+
+module Rockit
+  class Cli
+
+    # Run the cli. Additional commands supplied will be executed after
+    # the Rockit::Application finishes successfully.
+    #
+    # args - will look for -f as the first argument which will cause a
+    #       hard delete of the cache directory before running
+    #
+    def self.start(args=ARGV)
+      rockitapp = Rockit::Application.new
+      if args[0] == '-f'
+        args.shift
+        rockitapp.clear_cache
+      end
+      rockitapp.run
+      Kernel.exec(*args) unless args.size == 0
+    end
+  end
+end

data/lib/rockit/dsl.rb

@@ -0,0 +1,51 @@
+require 'fileutils'
+module Rockit
+
+  class Dsl
+    def initialize(app)
+      @app = app
+    end
+
+    def command(command, options={})
+      @app.command(command, options)
+    end
+
+    def if_command_missing(command, &block)
+      @app.command(command, {:on_failure => block})
+    end
+
+    def service(service_name, options={})
+      @app.service(service_name, options)
+    end
+
+    def if_service_not_running(service_name, &block)
+      @app.service(service_name, {:on_failure => block})
+    end
+
+    def if_directory_changed(directory, &block)
+      exit unless Dir.exists?(directory)
+      @app.if_directory_changed(directory, &block)
+    end
+
+    def if_file_changed(filename, &block)
+      exit unless File.exists?(filename)
+      @app.if_file_changed(filename, &block)
+    end
+
+    def if_first_time(&block)
+      @app.if_first_time(&block)
+    end
+
+    def if_string_changed(changeable, name, &block)
+      @app.if_string_changed(name, changeable, &block)
+    end
+
+    def if_string_digest_changed(name, changeable, &block)
+      @app.if_string_digest_changed(name, changeable, &block)
+    end
+
+    def run(command, options={})
+      @app.system_exit_on_error(command, options)
+    end
+  end
+end

data/lib/rockit/hash_store.rb

@@ -0,0 +1,43 @@
+module Rockit
+
+  class HashStore
+
+    DIR = '.rockit'
+    FILE = 'hash'
+
+    attr_accessor :dir, :filename
+
+    def initialize(dir=DIR, filename=FILE)
+      @dir = dir
+      @filename = filename
+    end
+
+    def clear
+      p = File.join(@dir,@filename)
+      File.delete(p) if File.exists?(p)
+      Dir.rmdir(@dir) if File.exists?(@dir)
+    end
+
+    def [](key)
+      if m = File.read(filepath).match(/^#{key}:(.*)$/)
+        m[1]
+      end
+    end
+
+    def []=(key, value)
+      contents = File.read(filepath)
+      contents << "#{key}:#{value}\n" unless contents.gsub!(/^#{key}:.*$/, "#{key}:#{value}")
+      File.open(filepath, 'w') {|f| f.write(contents) }
+    end
+
+    private
+
+    def filepath
+      Dir.mkdir(@dir) unless File.exists?(@dir)
+      file = File.join(@dir, @filename)
+      File.new(file,File::CREAT) unless File.exists?(file)
+      file
+    end
+  end
+
+end

data/lib/rockit/version.rb

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

data/rockit.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rockit/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rockit-now"
+  s.version     = Rockit::VERSION
+  s.authors     = ["Ben Willis"]
+  s.email       = ["benjamin.willis@gmail.com"]
+  s.homepage    = "https://github.com/bwillis/rockit"
+  s.summary     = %q{Rockit is a way to manage your external dependencies and keep your environment up to date.}
+  s.description = %q{Check and verify external project and rails specific project dependencies. The script will cache results to ensure quick script execution each time.}
+
+  s.rubyforge_project = "rockit"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "mocha"
+end

data/spec/rockit/application_spec.rb

@@ -0,0 +1,246 @@
+require 'spec_helper'
+
+describe Rockit::Application do
+  before do
+    @app = Rockit::Application.new({})
+  end
+
+  def block_should_execute
+    block = Proc.new {}
+    block.expects(:call).once
+    block
+  end
+
+  def block_should_not_execute
+    lambda { |*args| fail }
+  end
+
+  describe '#clear_cache' do
+    context 'when calling clear cache' do
+      before do
+        @app.if_first_time &block_should_execute
+        @app.if_first_time &block_should_not_execute
+        @app.clear_cache
+      end
+
+      it 'resets cache for first time' do
+        @app.if_first_time &block_should_execute
+      end
+    end
+  end
+
+  describe '#if_directory_changed' do
+    before do
+      Dir.stubs(:glob).returns(['file1', 'file2'])
+    end
+    context 'when not called before' do
+      it 'executes the block' do
+        @app.if_directory_changed('test', &block_should_execute)
+      end
+    end
+
+    context 'when called before' do
+      before do
+        @app.if_directory_changed('test')
+      end
+      context 'and the dir has not changed' do
+        it 'does not execute the block' do
+          @app.if_directory_changed('test', &block_should_not_execute)
+        end
+      end
+
+      context 'and the dir has changed' do
+        before do
+          Dir.unstub(:glob)
+          Dir.stubs(:glob).returns(['file1', 'file2', 'file3'])
+        end
+        it 'does execute the block' do
+          @app.if_directory_changed('test', &block_should_execute)
+        end
+      end
+    end
+  end
+
+  describe '#if_first_time' do
+    it 'runs the block the first time' do
+      @app.if_first_time &block_should_execute
+    end
+    it 'does not run the block the second time' do
+      @app.if_first_time {}
+      @app.if_first_time &block_should_not_execute
+    end
+  end
+
+  describe '#if_string_digest_changed' do
+    context 'called when no previous digest exists' do
+      it 'executes the block' do
+        @app.if_string_digest_changed('fake', 'fake_out', &block_should_execute)
+      end
+    end
+
+    context 'with a unchanged digest' do
+      before do
+        @app.if_string_digest_changed('fake', 'fake_out')
+      end
+
+      it 'does not executes the block' do
+        @app.if_string_digest_changed('fake', 'fake_out', &block_should_not_execute)
+      end
+    end
+
+    context 'with a changed digest' do
+      before do
+        @app.if_string_digest_changed('fake', 'old_digest')
+      end
+
+      it 'executes the block' do
+        @app.if_string_digest_changed('fake', 'new_digest', &block_should_execute)
+      end
+    end
+  end
+
+  describe '#if_file_changed' do
+    before do
+      @digest = mock()
+      @digest.stubs(:hexdigest).returns('abc')
+      Digest::SHA256.stubs(:file).with('test_file').returns(@digest)
+    end
+
+    context 'called when no previous digest exists' do
+      it 'executes the block' do
+        @app.if_file_changed 'test_file', &block_should_execute
+      end
+    end
+
+    context 'when an existing digest exists' do
+      before do
+        @app.if_file_changed 'test_file', &block_should_execute
+      end
+
+      it 'should not execute the block' do
+        @app.if_file_changed 'test_file', &block_should_not_execute
+      end
+
+      context 'that is different' do
+        before do
+          @digest.unstub(:hexdigest)
+          @digest.stubs(:hexdigest).returns('xyz')
+        end
+
+        it 'should execute the block' do
+          @app.if_file_changed 'test_file', &block_should_execute
+        end
+      end
+    end
+  end
+
+  describe '#if_string_changed' do
+    it 'runs the block when there is no previous value' do
+      block = lambda {}
+      block.expects(:call).once
+      @app.if_string_changed('new_value', 'new_key', &block)
+    end
+  end
+
+  describe '#system_exit_on_error' do
+    context 'with failing command' do
+      before do
+        @app.stubs('exit')
+        @app.stubs('system_command')
+        @app.stubs('output')
+        @last_process = mock()
+        @last_process.stubs(:success?).returns(false)
+        @last_process.stubs(:exitstatus).returns(1)
+        @app.stubs('last_process').returns(@last_process)
+      end
+
+      it 'calls exit' do
+        @app.unstub('exit')
+        lambda { @app.system_exit_on_error('failing command') }.should raise_error SystemExit
+      end
+
+      it 'calls exit with the same status code as the system command' do
+        @app.unstub('exit')
+        @app.expects('exit').with(@last_process.exitstatus)
+        @app.system_exit_on_error('failing command')
+      end
+
+      it 'prints out the output' do
+        message = 'failing output'
+        @app.stubs('system_command').returns(message)
+        @app.expects('output').with(message)
+        @app.system_exit_on_error('failing command')
+      end
+
+      it 'prints out a custom message' do
+        message = 'failing output'
+        new_message = 'different failing message'
+        @app.stubs('system_command').returns(message)
+        @app.expects('output').with(new_message)
+        @app.system_exit_on_error('failing command', :failure_message => new_message)
+      end
+
+      it 'calls the failure callback' do
+        block_called = false
+        @app.system_exit_on_error('failing command', :on_failure => lambda { |a, b| block_called = true })
+        block_called.should == true
+      end
+
+      it 'does not call the success callback' do
+        block_called = false
+        @app.system_exit_on_error('failing command', :on_success => lambda { |a, b| block_called = true })
+        block_called.should == false
+      end
+    end
+
+    context 'with successful command' do
+      before do
+        @app.stubs('system_command')
+        @app.stubs('output')
+        @last_process = mock()
+        @last_process.stubs(:success?).returns(true)
+      end
+
+      it 'does not exit' do
+        @app.system_exit_on_error('successful command')
+      end
+
+      it 'does not output anything' do
+        @app.stubs('output').returns(lambda { fail })
+        @app.system_exit_on_error('successful command', :failure_message => 'failure message')
+      end
+
+      it 'does not call the failure callback' do
+        block_called = false
+        @app.system_exit_on_error('successful command', :on_failure => lambda { |a, b| blocked_called = true })
+        block_called.should == false
+      end
+
+      it 'does call the success callback' do
+        block_called = false
+        @app.system_exit_on_error('successful command', :on_success => lambda { |a, b| block_called = true })
+        block_called.should == true
+      end
+    end
+  end
+
+  describe '#system_command' do
+    it 'executes the command' do
+      @app.system_command('echo "hi"').should match(/hi/)
+    end
+
+    it 'does not execute rm -rf - dedicated to swamy g' do
+      lambda { @app.system_command('rm -rf') }.should raise_error
+    end
+  end
+
+  describe '#string_keys' do
+    it 'converts the symbol based hash to string' do
+      @app.string_keys({:one => 1, :two => 2, 'three' => 3}).should == {'one' => 1, 'two' => 2, 'three' => 3}
+    end
+    it 'does not modify the string based hash' do
+      @app.string_keys({'a' => 1, 'b' => 2, 'c' => 3}).should == {'a' => 1, 'b' => 2, 'c' => 3}
+    end
+  end
+
+end

data/spec/rockit/cli_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Rockit::Cli do
+  before do
+    Kernel.stubs('exec')
+    Rockit::Application.any_instance.stubs('run')
+  end
+  describe '.start' do
+    context 'with no arguments' do
+      it 'calls the application run' do
+        Rockit::Application.any_instance.expects('run')
+        Rockit::Cli.start
+      end
+    end
+
+    context 'with the -f flag' do
+      it 'calls clears the cache' do
+        Rockit::Application.any_instance.expects('clear_cache')
+        Rockit::Cli.start(['-f'])
+      end
+    end
+
+    context 'with additional arguments' do
+      it 'clears the cache' do
+        args = ['rails', 'server']
+        Kernel.expects('exec').with(*args)
+        Rockit::Cli.start(args)
+      end
+    end
+
+  end
+
+end

data/spec/rockit/dsl_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Rockit::Dsl do
+
+  describe '' do
+
+  end
+
+end

data/spec/rockit/hash_store_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Rockit::HashStore do
+
+  before do
+    @hash_store = Rockit::HashStore.new
+  end
+
+
+  context '#filepath' do
+    it 'creates the hash store file' do
+      File.exists?(@hash_store.send(:filepath)).should == true
+    end
+  end
+
+  context '#get/#set' do
+    before do
+
+    end
+    context 'when getting an unsaved key' do
+      it 'returns nil' do
+        @hash_store['unsaved_key'].should be_nil
+      end
+    end
+
+    context 'when setting a new key' do
+      before do
+        @hash_store['saved_key'] = 'value'
+        @hash_store['saved_key_2'] = 'value2'
+      end
+      it 'can retrieve the saved value' do
+        @hash_store['saved_key'].should == 'value'
+      end
+    end
+
+    context 'when setting an existing key' do
+      before do
+        @hash_store['saved_key_1'] = 'value_1'
+        @hash_store['saved_key_1'] = 'value_2'
+      end
+      it 'can retrieve the latest saved value' do
+        @hash_store['saved_key_1'].should == 'value_2'
+      end
+    end
+  end
+
+  after do
+    @hash_store.clear
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler.require
+
+require 'rockit'
+require 'rspec'
+
+#require 'active_support/string_inquirer'
+Dir[File.expand_path(File.join(File.dirname(__FILE__), "support/**/*.rb"))].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: rockit-now
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Ben Willis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-18 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70136619827500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70136619827500
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &70136619827080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70136619827080
+description: Check and verify external project and rails specific project dependencies.
+  The script will cache results to ensure quick script execution each time.
+email:
+- benjamin.willis@gmail.com
+executables:
+- rockit
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- bin/rockit
+- example/Rockitfile
+- lib/rockit.rb
+- lib/rockit/application.rb
+- lib/rockit/cli.rb
+- lib/rockit/dsl.rb
+- lib/rockit/hash_store.rb
+- lib/rockit/version.rb
+- rockit.gemspec
+- spec/rockit/application_spec.rb
+- spec/rockit/cli_spec.rb
+- spec/rockit/dsl_spec.rb
+- spec/rockit/hash_store_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bwillis/rockit
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rockit
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Rockit is a way to manage your external dependencies and keep your environment
+  up to date.
+test_files:
+- spec/rockit/application_spec.rb
+- spec/rockit/cli_spec.rb
+- spec/rockit/dsl_spec.rb
+- spec/rockit/hash_store_spec.rb
+- spec/spec_helper.rb