scrab 0.0.1

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp
+*.swo
+logs

data/.rally.sample

@@ -0,0 +1,3 @@
+:username: YOUR_USERNAME
+:password: YOUR_PASSWORD
+:project:  THE_NAME_OF_YOUR_PROJECT

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in scrab.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,22 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec', :version => 2 do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+
+  # Rails example
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
+  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
+  watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
+  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch('spec/spec_helper.rb')                        { "spec" }
+  watch('config/routes.rb')                           { "spec/routing" }
+  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
+  # Capybara request specs
+  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+end
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/scrab

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+
+require "scrab"
+require 'optparse'
+
+options = {}
+
+opt_parser = OptionParser.new do |o|
+  o.banner = "Usage: scrab <command> [options*]"
+  o.separator ""
+
+  o.separator "Available commands:"
+  o.separator "    push"
+  o.separator ""
+
+  o.separator "Global options:"
+
+  o.on("-h", "--help", "Show this message") do
+    puts opt_parser
+    exit
+  end
+end
+
+opt_parser.parse!
+
+command_name = ARGV.shift
+
+begin
+  command = Scrab::CommandFactory.get(command_name, STDOUT)
+  command.run(options, *ARGV)
+rescue Scrab::StandardError => e
+  puts e.message
+  puts opt_parser
+end

data/custom_formatter.rb

@@ -0,0 +1,84 @@
+require "rubygems"
+require "gherkin"
+
+class CustomFormatter
+  def uri(uri)
+    @uri = uri
+  end
+
+  def feature(feature)
+    @feature = feature
+  end
+
+  def background(background)
+    @background = background
+  end
+
+  def step(step)
+    @step = step
+  end
+
+  def scenario(scenario)
+    @scenario = scenario
+  end
+
+  def scenario_outline(outline)
+    @outline = outline
+  end
+
+  def examples(examples)
+    @examples = examples
+  end
+
+  def eof
+    @feature
+  end
+end
+
+fmt = CustomFormatter.new
+prs = Gherkin::Parser::Parser.new(fmt)
+p prs.parse(File.read(ARGV[0]), nil, 0)
+
+#require "cucumber/formatter/io"
+#
+#
+#class CustomFormatter
+#   include Cucumber::Formatter::Io
+#
+#  def initialize(step_mother, path_or_io, options)
+#    @step_mother, @io, @options = step_mother, ensure_io(path_or_io, "fuubar"), options
+#  end
+#
+#  def after_features(features)
+#    puts "==== AFTER FEATURES"
+#    p features
+#  end
+#
+#  def before_features(features)
+#    puts "==== BEFORE FEATURES"
+#    p features
+#  end
+#
+#  def before_background(background)
+#  end
+#
+#  def after_background(background)
+#  end
+#
+#  def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+#    puts "==== STEP RESULT"
+#    p [keyword, step_match, multiline_arg, status, exception, source_indent, background]
+#  end
+#
+#  def before_examples(examples)
+#  end
+#
+#  def after_examples(examples)
+#  end
+#
+#  def before_table_row(table_row)
+#  end
+#
+#  def after_table_row(table_row)
+#  end
+#end

data/lib/scrab.rb

@@ -0,0 +1,38 @@
+require "bundler"
+Bundler.setup(:default)
+
+require "rally_rest_api"
+require "gherkin"
+require "scrab/version"
+require "scrab/command_set"
+require "scrab/rally"
+require "scrab/story"
+require "scrab/scenario"
+require "scrab/step"
+require "scrab/feature_parser"
+
+module Scrab
+  class StandardError < ::StandardError; end
+
+  LibPath        = Pathname.new(File.dirname(__FILE__) + "/scrab")
+  CommandsPath   = LibPath.join('commands')
+  Commands       = Module.new
+  CommandFactory = CommandSet.new(Commands, CommandsPath)
+
+  def self.rally_config_path
+    "#{ENV['HOME']}/.rally"
+  end
+
+  def self.rally_config
+    raise "Please configure rally at #{rally_config_path}, check .rally.sample for an example" unless File.exist?(rally_config_path)
+    @rally_config ||= YAML.load(File.read(rally_config_path))
+  end
+
+  def self.rally
+    @rally ||= Rally.new(rally_config.merge(:logger => logger))
+  end
+
+  def self.logger
+    @logger ||= Logger.new(File.dirname(__FILE__) + "/../logs/rally.log")
+  end
+end

data/lib/scrab/command_set.rb

@@ -0,0 +1,29 @@
+class Scrab::CommandSet
+  class CommandNotFoundError < StandardError
+    def initialize(command_name)
+      super "Command not found: #{command_name}"
+    end
+  end
+
+  def initialize(namespace, commands_path)
+    @namespace     = namespace
+    @commands_path = Pathname.new(commands_path)
+  end
+
+  def get(command_name, out)
+    begin
+      Kernel.load(@commands_path.join("#{command_name}.rb").to_s)
+    rescue LoadError => e
+      raise CommandNotFoundError.new(command_name)
+    end
+
+    const = @namespace
+
+    command_name.split("/").each do |command_part|
+      const_name = command_part.capitalize.gsub(/_(.)/) { $1.upcase }
+      const      = const.const_get(const_name)
+    end
+
+    const.new(out)
+  end
+end

data/lib/scrab/commands/push.rb

@@ -0,0 +1,36 @@
+class Scrab::Commands::Push
+  def initialize(out, parser = nil)
+    @out    = out
+    @parser = parser || Scrab::FeatureParser.new(Scrab::Story)
+  end
+
+  def run(options, *features)
+    determine_feature_paths(features).each do |feature|
+      begin
+        story = @parser.parse(feature)
+      
+        @out.print "Pushing '[#{story.id}] #{story.name}' to Rally... "
+
+        if Scrab.rally.update(story)
+          @out.puts "OK."
+        else
+          @out.puts "FAILED."
+        end
+      rescue Scrab::FeatureParser::ParsingError => e
+        @out.puts "Failed to parse '#{feature}':\n\t#{e.message}"
+      end
+    end
+  end
+
+  def determine_feature_paths(features)
+    features = ['features/'] if features.empty?
+
+    features.map do |feature_path|
+      if File.directory?(feature_path)
+        `find #{feature_path} -type f -name '*.feature'`.split(/\n/)
+      else
+        feature_path
+      end
+    end.flatten
+  end
+end

data/lib/scrab/feature_parser.rb

@@ -0,0 +1,67 @@
+class Scrab::FeatureParser
+  class ParsingError < StandardError
+    def initialize(line, desc)
+      super "Couldn't parse '#{line}': #{desc}"
+    end
+  end
+
+  class GherkinFormatter
+    def initialize(story)
+      @story = story
+    end
+
+    def feature(feature)
+      if feature.name.strip =~ /^\[(US\d+)\]\s+(.*)$/
+        @story.id   = $1
+        @story.name = $2
+      else
+        raise ParsingError.new(feature.name, "expect feature title to be in '[US0000] Story name' format")
+      end
+
+      @story.narrative = feature.description
+    end
+
+    def background(background)
+    end
+
+    def scenario(scenario)
+      @scenario  = Scrab::Scenario.new
+      @scenario.name = scenario.name
+      @scenario.description = scenario.description
+      @story.scenarios << @scenario
+    end
+    
+    def step(step)
+      @step = Scrab::Step.new
+      @step.keyword = step.keyword
+      @step.name    = step.name
+      @scenario.steps << @step
+    end
+
+    def scenario_outline(outline)
+    end
+
+    def examples(examples)
+    end
+
+    def uri(uri)
+      # no-op
+    end
+
+    def eof
+      # no-op
+    end
+  end
+
+  # TODO: Pass story instance to parse instead of the class here
+  def initialize(story_klass)
+    @story_klass = story_klass
+  end
+
+  def parse(feature_path)
+    story  = @story_klass.new
+    parser = Gherkin::Parser::Parser.new(GherkinFormatter.new(story))
+    parser.parse(File.read(feature_path), nil, 0)
+    story
+  end
+end

data/lib/scrab/rally.rb

@@ -0,0 +1,60 @@
+class Scrab::Rally
+  class ProjectNotFoundError < StandardError
+    def initialize(project)
+      super "Project '#{project}' not found"
+    end
+  end
+
+  def initialize(options)
+    @conn    = RallyRestAPI.new(options)
+    @project = @conn.find(:project, :pagesize => 1) { equal :name, options[:project] }.first
+    raise ProjectNotFoundError.new(@project) if @project.nil?
+  end
+
+  def update(story)
+    update_story(story)
+  end
+
+private
+  def update_story(story)
+    rest_object = @conn.find(:hierarchical_requirement, :pagesize => 1, :project => @project) { equal :formatted_i_d, story.id }.first
+    @conn.update(rest_object, :name => story.name, :description => story.narrative)
+    update_story_scenarios(rest_object, story.scenarios)
+  end
+
+  def update_story_scenarios(story_rest, scenarios)
+    scenarios.each do |scenario|
+      description = scenario.description
+      description = description && !description.empty? ? description : scenario.name
+
+      values = {
+        :project => @project, 
+        :work_product => story_rest, 
+        :name => scenario.name, 
+        :description => description,
+        :priority => 'Important',
+        :type => 'Acceptance',
+        :method => 'Automated',
+        :risk => 'Medium',
+        :pre_conditions => "N/A",
+        :post_conditions => "N/A"
+      }
+
+      if rest_object = @conn.find(:test_case, :pagesize => 1, :project => @project) { equal :name, scenario.name.strip }.first
+        @conn.update(rest_object, values)
+      else
+        rest_object = @conn.create(:test_case, values)
+      end
+
+      update_scenario_steps(rest_object, scenario.steps)
+    end
+  end
+
+  def update_scenario_steps(scenario_rest, steps)
+    Array(scenario_rest.steps).each { |step_rest| step_rest.delete }
+
+    steps.each_with_index do |step, idx|
+      @conn.create(:test_case_step, :test_case => scenario_rest, :project => @project, :step_index => idx, :input => step.full_name)
+    end
+  end
+end

data/lib/scrab/scenario.rb

@@ -0,0 +1,8 @@
+class Scrab::Scenario
+  attr_accessor :name, :description
+  attr_reader :steps
+
+  def initialize
+    @steps = []
+  end
+end

data/lib/scrab/step.rb

@@ -0,0 +1,7 @@
+class Scrab::Step
+  attr_accessor :keyword, :name
+
+  def full_name
+    "#{keyword} #{name}"
+  end
+end

data/lib/scrab/story.rb

@@ -0,0 +1,8 @@
+class Scrab::Story
+  attr_accessor :id, :name, :narrative
+  attr_reader :scenarios
+
+  def initialize
+    @scenarios = []
+  end
+end

data/lib/scrab/version.rb

@@ -0,0 +1,3 @@
+module Scrab
+  VERSION = "0.0.1"
+end

data/scrab.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "scrab/version"
+
+Gem::Specification.new do |s|
+  s.name        = "scrab"
+  s.version     = Scrab::VERSION
+  s.authors     = ["Rodrigo Kochenburger"]
+  s.email       = ["divoxx@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Simple tool for pushing cucumber features into Rally testcases}
+  s.description = %q{Simple tool for pushing cucumber features into Rally testcases}
+
+  s.rubyforge_project = "scrab"
+
+  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_runtime_dependency      'builder' # RallyRestAPI dep
+  s.add_runtime_dependency      'rally_rest_api'
+  s.add_runtime_dependency      'gherkin'
+
+  s.add_development_dependency  'rspec'
+  s.add_development_dependency  'guard'
+  s.add_development_dependency  'guard-rspec'
+  s.add_development_dependency  'rb-fsevent'
+  s.add_development_dependency  'growl_notify'
+  s.add_development_dependency  'fakeweb'
+end

data/spec/acceptance/pushing_story_spec.rb

@@ -0,0 +1,7 @@
+require "spec_helper"
+
+describe "Pushing a story to rally" do
+  it "push stories to rally" do
+    scrab("push #{fixture_path('story.feature')}").should output("Pushing '[US5836] Story name' to Rally... OK.")
+  end
+end

data/spec/fixtures/invalid-name.feature

@@ -0,0 +1,4 @@
+Feature: Invalid story title
+  As a user
+  I want to do something
+  So that that something is done

data/spec/fixtures/story.feature

@@ -0,0 +1,9 @@
+Feature: [US5836] Story name
+  As a user
+  I want to do something
+  So that that something is done
+
+  Scenario: User does something
+    Given the user exists
+    When he does something
+    Then something is done

data/spec/objects/command_set_spec.rb

@@ -0,0 +1,26 @@
+require "spec_helper"
+require "scrab/command_set"
+
+describe CommandSet do
+  let(:command)       { mock(:command) }
+  let(:command_klass) { mock(:command_klass) }
+  let(:out)           { mock(:out) }
+  let(:namespace)     { Module.new }
+  let(:commands_path) { "some/path/for/commands" }
+
+  subject { CommandSet.new(namespace, commands_path) }
+
+  before do
+    namespace.const_set(:Command, command_klass)
+  end
+
+  it "loads commands dynamically" do
+    Kernel.should_receive(:load).with("#{commands_path}/command.rb").and_return
+    command_klass.should_receive(:new).with(out).and_return(command)
+    subject.get('command', out).should == command
+  end
+
+  it "raises a CommandNotFoundError when asking for a non-existing command" do
+    expect { subject.get('invalid-command', out) }.to raise_error(CommandSet::CommandNotFoundError)
+  end
+end

data/spec/objects/commands/push_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper" 
+require "scrab/commands/push"
+
+describe Commands::Push do
+  let(:rally)   { mock(:rally, :update => true) }
+  let(:story)   { mock(:story, :id => "US0000", :name => "Story name") }
+  let(:parser)  { mock(:parser, :parse => story) }
+  let(:out)     { StringIO.new }
+  let(:path)    { "some/path.feature" }
+  subject       { Commands::Push.new(out, parser) }
+  before        { Scrab.stub(:rally => rally) }
+
+  it "outputs message for success" do
+    subject.run({}, path)
+    out.rewind
+    out.read.should =~ /OK/
+  end
+
+  it "outputs parsing error message" do
+    parser.should_receive(:parse).and_raise(Scrab::FeatureParser::ParsingError.new('foo', 'bar'))
+    subject.run({}, path)
+    out.rewind
+    out.read.should =~ /Couldn't parse/
+  end
+
+  it "parses and update the story" do
+    parser.should_receive(:parse).with(path).and_return(story)
+    rally.should_receive(:update).with(story).and_return(true)
+    subject.run({}, path)
+  end
+
+  it "outputs a failed message when fail to push story" do
+    rally.should_receive(:update).with(story).and_return(false)
+    subject.run({}, path)
+    out.rewind
+    out.read.should =~ /FAILED/
+  end
+end

data/spec/objects/feature_parse_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "scrab/feature_parser"
+
+describe FeatureParser do
+  subject { FeatureParser.new(Story) }
+
+  def do_parse
+    subject.parse(fixture_path('story.feature'))
+  end
+
+  it "parses a feature and return a story" do
+    do_parse.should be_a(Story)
+  end
+
+  it "sets the id" do
+    story = do_parse
+    story.id.should == "US5836"
+  end
+
+  it "sets the story name" do
+    story = do_parse 
+    story.name.should == "Story name"
+  end
+
+  it "sets the story narrative" do
+    story = do_parse
+    story.narrative.should == <<-EOS.strip
+As a user
+I want to do something
+So that that something is done
+    EOS
+  end
+
+  it "raises an parsing error if cant parse the id and story name" do
+    expect { subject.parse(fixture_path('invalid-name.feature')) }.to raise_error(FeatureParser::ParsingError)
+  end
+
+  it "sets the scenarios" do
+    story = do_parse
+    story.should have(1).scenarios
+  end
+
+  it "sets the steps" do
+    story = do_parse
+    story.scenarios.first.should have(3).steps
+  end
+end

data/spec/objects/rally_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+require "scrab/rally"
+
+describe Scrab::Rally do
+  let(:conn)      { mock(:conn) }
+  let(:project)   { mock(:project) }
+  let(:scenario)  { mock(:scenario, :name => "Scenario name", :description => "scenario desc", :steps => []) }
+  let(:story)     { mock(:story, :name => "Story name", :narrative => "Story narrative", :scenarios => []) }
+  let(:rest_obj)  { mock(:rest_obj) } 
+  subject         { Scrab::Rally.new(:username => 'username', :password => 'password', :project => "project") }
+  
+  before do
+    RallyRestAPI.stub(:new => conn)
+    conn.stub(:find).with(:project, anything).and_return(mock(:first => project))
+    conn.stub(:find).with(:hierarchical_requirement, anything).and_return(mock(:first => rest_obj))
+    conn.stub(:update).with(rest_obj, anything)
+  end
+
+  it "establishes a rally connection" do
+    RallyRestAPI.should_receive(:new).with(hash_including(:username => 'username', :password => 'password'))
+    Scrab::Rally.new(:username => 'username', :password => 'password')
+  end
+
+  it "updates a given story" do
+    # FIXME: No idea how to test the yielded block (conditions) because its called with instance_eval
+    story.stub(:scenarios => [])
+    conn.should_receive(:find).with(:hierarchical_requirement, :pagesize => 1, :project => project).and_return(mock(:first => rest_obj))
+    conn.should_receive(:update).with(rest_obj, :name => story.name, :description => story.narrative)
+    subject.update(story)
+  end
+
+  it "creates new testcases" do
+    story.stub(:scenarios => [scenario])
+
+    conn.should_receive(:find).with(:test_case, :pagesize => 1, :project => project).and_return(mock(:first => nil))
+    conn.should_receive(:create).with(:test_case, 
+      :project => project, 
+      :work_product => rest_obj, 
+      :name => scenario.name, 
+      :description => scenario.description,
+      :priority => 'Important',
+      :type => 'Acceptance',
+      :method => "Automated",
+      :risk => 'Medium',
+      :pre_conditions => "N/A",
+      :post_conditions => "N/A"
+    ).and_return(rest_obj)
+
+    rest_obj.stub(:steps).and_return([])
+
+    subject.update(story)
+  end
+end

data/spec/objects/scenario_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+require "scrab/scenario"
+
+describe Scenario do
+  let(:name)        { "Scenario name" }
+  let(:description) { "Scenario desc" }
+
+  it "has a name" do
+    subject.name = name
+    subject.name.should == name
+  end
+
+  it "has a description" do
+    subject.description = description
+    subject.description.should == description
+  end
+
+  it "has steps" do
+    subject.steps.should be_a(Enumerable)
+  end
+end

data/spec/objects/step_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+require "scrab/step"
+
+describe Step do
+  it "has a keyword" do
+    subject.keyword = "Given"
+    subject.keyword.should == "Given"
+  end
+
+  it "has a name" do
+    subject.name = "name"
+    subject.name.should == "name"
+  end
+
+  it "has a full_name" do
+    subject.keyword = "Given"
+    subject.name    = "I am on that page"
+    subject.full_name.should == "Given I am on that page"
+  end
+end

data/spec/objects/story_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "scrab/story"
+
+describe Story do
+  let(:id)        { "US0000" }
+  let(:name)      { "Story name" }
+  let(:narrative) { <<-EOS }
+As a user
+I want to do something
+So that a get that value
+  EOS
+
+  let(:scenario) { mock(:scenario) }
+
+  it "has an id" do
+    subject.id = id
+    subject.id.should == id
+  end
+
+  it "has a name" do
+    subject.name = name
+    subject.name.should == name
+  end
+
+  it "has a narrative" do
+    subject.narrative = narrative
+    subject.narrative.should == narrative
+  end
+
+  it "has scenarios" do
+    subject.scenarios << scenario
+    subject.scenarios.should == [scenario]
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require "scrab"
+Bundler.setup(:development)
+include Scrab
+
+require "rspec"
+require "fakeweb"
+
+require "support/fixtures"
+require "support/commands"
+
+RSpec.configure do |c|
+  c.include(Support::Fixtures)
+  c.include(Support::Commands)
+end
+

data/spec/support/commands.rb

@@ -0,0 +1,40 @@
+module Support
+  module Commands
+    def scrab(cmd)
+      ScrabProcess.new("ruby -Ilib bin/scrab #{cmd}")
+    end
+
+    class ScrabProcess
+      attr_reader :cmd, :out
+
+      def initialize(cmd)
+        @cmd = cmd
+
+        IO.popen(cmd) do |io|
+          @out = io.read.freeze
+        end
+      end
+    end
+  end
+end
+
+RSpec::Matchers.define :output do |expected_out|
+  match do |process|
+    process.out.strip == expected_out.strip
+  end
+
+  failure_message_for_should do |process|
+    fmt_expected_out = expected_out.split(/\n/).join("\n\t\t")
+    fmt_actual_out   = process.out.split(/\n/).join("\n\t\t")
+
+    msg = <<-EOS
+\tExpected command '#{process.cmd}' output to match:
+\t\t#{fmt_expected_out}
+
+\tBut got:
+\t\t#{fmt_actual_out}
+    EOS
+
+    msg
+  end
+end

data/spec/support/fixtures.rb

@@ -0,0 +1,13 @@
+module Support
+  module Fixtures
+    Path = Pathname.new(File.dirname(__FILE__) + "/../fixtures")
+
+    def fixture_path(name)
+      Path.join(name.to_s)
+    end
+
+    def fixture_content(name)
+      File.read fixture_path(name)
+    end
+  end
+end

metadata

@@ -0,0 +1,188 @@
+--- !ruby/object:Gem::Specification
+name: scrab
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Rodrigo Kochenburger
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: builder
+  requirement: &70203933972840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70203933972840
+- !ruby/object:Gem::Dependency
+  name: rally_rest_api
+  requirement: &70203933972400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70203933972400
+- !ruby/object:Gem::Dependency
+  name: gherkin
+  requirement: &70203933971880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70203933971880
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70203933971420 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70203933971420
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: &70203933970880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70203933970880
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70203933970320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70203933970320
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: &70203933969740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70203933969740
+- !ruby/object:Gem::Dependency
+  name: growl_notify
+  requirement: &70203933968800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70203933968800
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: &70203933968320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70203933968320
+description: Simple tool for pushing cucumber features into Rally testcases
+email:
+- divoxx@gmail.com
+executables:
+- scrab
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rally.sample
+- Gemfile
+- Guardfile
+- Rakefile
+- bin/scrab
+- custom_formatter.rb
+- lib/scrab.rb
+- lib/scrab/command_set.rb
+- lib/scrab/commands/push.rb
+- lib/scrab/feature_parser.rb
+- lib/scrab/rally.rb
+- lib/scrab/scenario.rb
+- lib/scrab/step.rb
+- lib/scrab/story.rb
+- lib/scrab/version.rb
+- scrab.gemspec
+- spec/acceptance/pushing_story_spec.rb
+- spec/fixtures/invalid-name.feature
+- spec/fixtures/story.feature
+- spec/objects/command_set_spec.rb
+- spec/objects/commands/push_spec.rb
+- spec/objects/feature_parse_spec.rb
+- spec/objects/rally_spec.rb
+- spec/objects/scenario_spec.rb
+- spec/objects/step_spec.rb
+- spec/objects/story_spec.rb
+- spec/spec_helper.rb
+- spec/support/commands.rb
+- spec/support/fixtures.rb
+homepage: ''
+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: scrab
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Simple tool for pushing cucumber features into Rally testcases
+test_files:
+- spec/acceptance/pushing_story_spec.rb
+- spec/fixtures/invalid-name.feature
+- spec/fixtures/story.feature
+- spec/objects/command_set_spec.rb
+- spec/objects/commands/push_spec.rb
+- spec/objects/feature_parse_spec.rb
+- spec/objects/rally_spec.rb
+- spec/objects/scenario_spec.rb
+- spec/objects/step_spec.rb
+- spec/objects/story_spec.rb
+- spec/spec_helper.rb
+- spec/support/commands.rb
+- spec/support/fixtures.rb