two-step 1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bbcd87fc9e0ece6a20bedfe6664901250297a175
+  data.tar.gz: 2beecdace7f917e4773d529b0e96377c6d9ef938
+SHA512:
+  metadata.gz: 03775343f6f5fb263872e1cfcc2ae48e008e7693f0e3e4373eec8b41827ad4018bd51563a0adcb0cb90e09689aa491f8c877c8fa0259e39ae9d404be008ed3fa
+  data.tar.gz: cba2e257f83704719a484584f257e64df337dd2585aa93dcbbdbb3c62cfc5556ce699176db2950c6a68d3dbc183e7d02fc408cb52fa82aeda198542d80041b0c

data/doc/README

@@ -0,0 +1,116 @@
+# Two Step
+## ( or: why would I want to relearn how to write specs? )
+
+Two-Step allows you to chain examples into a series of steps that run
+in sequence and which stop when a step fails.  It's often incredibly
+useful to be able to aseemble a series of tests that should all pass,
+but where completely isolating them is less than sensible.
+
+( Two Step is the RSpec 2 compatible version of RSpec Steps - which can be
+found here: https://github.com/LRDesign/rspec-steps )
+
+One excellent example is web site integration tests.  With RSpec steps you can
+do:
+
+         steps "Login and change password" do
+           it "should show the login form" do
+             visit root
+             page.should have_text "Login"
+           end
+
+           it "should successfully log in" do
+             fill_in :name, "Johnny User"
+             click "Login"
+             page.should have_text "Welcome, Johnny!"
+           end
+
+           it "should load the password change form" do
+             click "My Settings"
+             click "Update Password"
+             page.should have_selector("form#update_password")
+           end
+
+           it "should change the user's password successfully" do
+             fill_in :password, "foobar"
+             fill_in :password_confirmation, "foobar"
+             click "Change Password"
+             page.should have_text "Password changed successfully!"
+             User.find_by_name("Johnny User").valid_password?("foobar").should be_true
+           end
+
+         end
+
+The examples above will be run in order.  State is preserved between examples
+inside a "steps" block: any DB transactions will not roll back until the entire
+sequence has been complete.
+
+If any example inside the "steps" block fails, all remaining steps will be marked
+pending and therefore skipped.
+
+## Rationale
+
+RSpec's philosophy is that all examples should be completely independent.  This
+is a great philosophy for most purposes, and we recommend you stick to it in
+almost all cases.  BUT, that complete separation of examples really sucks when
+you're trying to write long stories involving many requests.   You are usually
+stuck with three choices:
+
+1. Write a sequence of examples, each of which repeats the behavior of all previous examples. Downside: horrendously inefficient.
+2. Write a single huge example which performs the entire story.  Downside: only one description, no independent reporting of the steps of the story.
+3. Use Cucumber.  Downside: We agree totally with this guy: http://bit.ly/dmXqnY
+
+Two-Step intentionally breaks RSpec's "independent" philosophy to let us get the
+only thing we really want from Cucumber - the ability to execute some examples in sequence,
+and skip subsequent steps after a failure.
+
+## Caveats and cautions
+
+Don't call "describe" inside of "steps".  The behavior is undefined and probably bad.  It's
+hard to imagine what this should actually mean in any case.  Future versions of rspec-steps
+will consider this an error.
+
+Any call to "before" inside a steps block is treated like before(:all) and is run only
+once before the first step.  Or perhaps more accurately, any call to before() is treated
+like before(:each) ... but for these purposes the entire steps block is treated like a
+single example.
+
+## Advanced stuff:  shared steps
+
+If you have (for example) two user stories that share the same first N steps but then
+diverge, you can DRY your code out with shared_steps blocks, like so:
+
+       shared_steps "For a logged-in user" do
+         it "should have login form"
+           visit root
+           page.should have_selector "form#login"
+         end
+
+         it "should log the user in" do
+           fill_in :name, "Johnny User"
+           page.should have_text "Welcome, Johnny!"
+         end
+       end
+
+       steps "updating password" do
+         perform_steps "For a logged-in user"
+
+         it "should update the password" do
+           ...
+         end
+       end
+
+       steps "uploading a profile picture" do
+         perform_steps "For a logged-in user"
+
+         it "should upload a picture" do
+            ...
+         end
+       end
+
+## Versions and Dependencies
+
+The goal (sadly unfulfilled) is to try to be compatible with as many versions
+of RSpec 2.x as possible. Frankly, Two-Step is more than a little bit of a
+hack, and intrudes wholesale on RSpec's private interfaces. We make good use of
+Travis to check compatibility, however. You can check what versions of RSpec
+and Ruby Two-Step works with here: https://travis-ci.org/LRDesign/two-step

data/doc/Specifications

@@ -0,0 +1,17 @@
+
+RSpec::Core::ExampleGroup defined as stepwise
+  ::steps
+    should create an ExampleGroup that includes RSpec::Stepwise
+  with Stepwise included
+    should retain instance variables between steps
+    should mark later examples as pending if one fails
+    should allow nested steps
+    should not allow nested normal contexts (PENDING: A correct approach - in the meantime, this behavior is undefined)
+
+Pending:
+  RSpec::Core::ExampleGroup defined as stepwise with Stepwise included should not allow nested normal contexts
+    # A correct approach - in the meantime, this behavior is undefined
+    # ./spec/example_group.rb:63
+
+Finished in 0.10849 seconds
+5 examples, 0 failures, 1 pending

data/lib/two-step.rb

@@ -0,0 +1,3 @@
+require 'two-step/duckpunch/object-extensions'
+require 'two-step/duckpunch/example-group'
+require 'two-step/duckpunch/example'

data/lib/two-step/duckpunch/example-group.rb

@@ -0,0 +1,27 @@
+require 'rspec/core'
+require 'two-step/stepwise'
+
+module TwoStep
+  module DSL
+    def steps(*args, &block)
+      options =
+        if args.last.is_a?(Hash)
+          args.pop
+        else
+          {}
+        end
+      options[:stepwise] = true
+      options[:caller] ||= caller
+      args.push(options)
+
+      describe(*args, &block)
+    end
+  end
+end
+
+RSpec::Core::ExampleGroup.extend TwoStep::DSL
+
+extend TwoStep::DSL
+Module::send(:include, TwoStep::DSL)
+
+RSpec::configuration.include(RSpecStepwise, :stepwise => true)

data/lib/two-step/duckpunch/example.rb

@@ -0,0 +1,5 @@
+RSpec::Core::Example.class_eval do
+  def exception
+    @exception
+  end
+end

data/lib/two-step/duckpunch/object-extensions.rb

@@ -0,0 +1,8 @@
+require 'two-step/duckpunch/example-group'
+require 'two-step/stepwise'
+require 'rspec/core/shared_example_group'
+
+module RSpec::Core::SharedExampleGroup
+  alias :shared_steps :share_examples_for
+  alias :steps_shared_as :share_as
+end

data/lib/two-step/stepwise.rb

@@ -0,0 +1,219 @@
+module RSpecStepwise
+  class ApatheticReporter < ::RSpec::Core::Reporter
+    def notify(*args)
+      #noop
+    end
+  end
+
+  class WholeListExample < RSpec::Core::Example
+    def initialize(example_group_class, descriptions, metadata)
+      super
+      @reporter = ApatheticReporter.new
+      build_example_block
+    end
+
+    def start(reporter)
+      super(@reporter)
+    end
+
+    def finish(reporter)
+      super(@reporter)
+    end
+
+    def build_example_block
+      #variables of concern: reporter, instance
+      @example_block = proc do
+        begin
+          self.class.filtered_examples.inject(true) do |success, example|
+            break if RSpec.wants_to_quit
+            example.extend StepExample
+            unless success
+              example.metadata[:pending] = true
+              example.metadata[:execution_result][:pending_message] = "Previous step failed"
+            end
+            succeeded = with_indelible_ivars do
+              example.run(self, reporter)
+            end
+            RSpec.wants_to_quit = true if self.class.fail_fast? && !succeeded
+            success && succeeded
+          end
+        end
+      end
+    end
+  end
+
+  module StepExample
+    def run_before_each
+      @example_group_class.run_before_step(self)
+    rescue Object => ex
+      puts "\n#{__FILE__}:#{__LINE__} => #{[ex, ex.backtrace].pretty_inspect}"
+    end
+
+    def run_after_each
+      @example_group_class.run_after_step(self)
+    end
+
+    def with_around_hooks
+      yield
+    end
+  end
+
+  module ClassMethods
+    #This is hacky and needs a more general solution
+    #Something like cloning the current conf and having RSpec::Stepwise::config ?
+    def suspend_transactional_fixtures
+      if self.respond_to? :use_transactional_fixtures
+        begin
+          old_val = self.use_transactional_fixtures
+          self.use_transactional_fixtures = false
+
+          yield
+        ensure
+          self.use_transactional_fixtures = old_val
+        end
+      else
+        yield
+      end
+    end
+
+    def build_before_hook(options, &block)
+      if defined? RSpec::Core::Hooks::BeforeHookExtension
+        block.extend(RSpec::Core::Hooks::BeforeHookExtension).with(options)
+      else
+        RSpec::Core::Hooks::BeforeHook.new(block, options)
+      end
+    end
+
+    def build_after_hook(options, &block)
+      if defined? RSpec::Core::Hooks::AfterHookExtension
+        block.extend(RSpec::Core::Hooks::AfterHookExtension).with(options)
+      else
+        RSpec::Core::Hooks::AfterHook.new(block, options)
+      end
+    end
+
+
+    def before(*args, &block)
+      if args.first == :step
+        args.shift
+        options = build_metadata_hash_from(args)
+        return ((hooks[:before][:step] ||= []) << build_before_hook(options, &block))
+      end
+      if args.first == :each
+        puts "before blocks declared for steps are always treated as :all scope"
+      end
+      super
+    end
+
+    def after(*args, &block)
+      if args.first == :step
+        args.shift
+        options = build_metadata_hash_from(args)
+        hooks[:after][:step] ||= []
+        return (hooks[:after][:step].unshift build_after_hook(options, &block))
+      end
+      if args.first == :each
+        puts "after blocks declared for steps are always treated as :all scope"
+      end
+      super
+    end
+
+    def around(*args, &block)
+      if args.first == :each
+        puts "around :each blocks declared for steps are treated as :all scope"
+      end
+      super
+    end
+
+    def example_synonym(named, desc=nil, *args, &block)
+      unless desc.nil?
+        desc = [named, desc].join(" ")
+      end
+      it(desc, *args, &block)
+    end
+
+    def when(*args, &block); example_synonym("when", *args, &block); end
+    def then(*args, &block); example_synonym("then", *args, &block); end
+    def next(*args, &block); example_synonym("next", *args, &block); end
+    def step(*args, &block); example_synonym("step", *args, &block); end
+
+    def run_step(example, hook, &sorting)
+      groups = if respond_to?(:parent_groups)
+                        parent_groups
+                      else
+                        ancestors
+                      end
+
+      if block_given?
+        groups = yield groups
+      end
+
+      RSpec::Core::Hooks::HookCollection.new(groups.map {|a| a.hooks[hook][:step]}.flatten.compact).for(example).run
+    end
+
+    def run_before_step(example)
+      run_step(example, :before)
+    end
+
+    def run_after_step(example)
+      run_step(example, :after) do |groups|
+        groups.reverse
+      end
+    end
+
+    def perform_steps(name, *args, &customization_block)
+      shared_block = nil
+      if world.respond_to? :shared_example_groups
+        shared_block = world.shared_example_groups[name]
+      else
+        shared_block = shared_example_groups[name]
+      end
+      raise "Could not find shared example group named #{name.inspect}" unless shared_block
+
+      module_eval_with_args(*args, &shared_block)
+      module_eval(&customization_block) if customization_block
+    end
+
+    def run_examples(reporter)
+      whole_list_example = WholeListExample.new(self, "step list", {})
+
+      instance = new
+      set_ivars(instance, before_all_ivars)
+      instance.example = whole_list_example
+      instance.reporter = reporter
+
+      result = suspend_transactional_fixtures do
+        whole_list_example.run(instance, reporter)
+      end
+
+      unless whole_list_example.exception.nil?
+        RSpec.wants_to_quit = true if fail_fast?
+        fail_filtered_examples(whole_list_example.exception, reporter)
+      end
+
+      result
+    end
+  end
+
+  attr_accessor :reporter
+
+  def with_indelible_ivars
+    old_value, @ivars_indelible = @ivars_indelible, true
+    result = yield
+    @ivars_indelible = old_value
+    result
+  rescue Object
+    @ivars_indelible = old_value
+    raise
+  end
+
+  def instance_variable_set(name, value)
+    if !@ivars_indelible
+      super
+    end
+  end
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+end

data/spec/example_group_spec.rb

@@ -0,0 +1,164 @@
+require 'two-step'
+require 'rspec-sandbox'
+
+describe RSpec::Core::ExampleGroup do
+  describe "::steps" do
+    it "should create an ExampleGroup that includes RSpec::Stepwise" do
+      group = nil
+      sandboxed do
+        group = RSpec.steps "Test Steps" do
+        end
+      end
+      (class << group; self; end).included_modules.should include(RSpecStepwise::ClassMethods)
+    end
+  end
+
+  describe "with Stepwise included" do
+    it "should retain instance variables between steps" do
+      group = nil
+      sandboxed do
+        group = RSpec.steps "Test Steps" do
+          it("sets @a"){ @a = 1 }
+          it("reads @a"){ @a.should == 1}
+        end
+        group.run
+      end
+
+      group.examples.each do |example|
+        example.metadata[:execution_result][:status].should == 'passed'
+      end
+    end
+
+    it "should work with shared_steps/perform steps" do
+      group = nil
+      sandboxed do
+        group = RSpec.steps "Test Steps" do
+          shared_steps "add one" do
+            it("adds one to @a"){ @a += 1 }
+          end
+          it("sets @a"){ @a = 1 }
+          perform_steps "add one"
+          perform_steps "add one"
+          perform_steps "add one"
+          it("reads @a"){ @a.should == 4 }
+        end
+        group.run
+      end
+
+      group.examples.each do |example|
+        example.metadata[:execution_result][:status].should == 'passed'
+      end
+    end
+
+    it "should run each_step hooks" do
+      group = nil
+      afters = []
+      befores = []
+
+      sandboxed do
+        group = RSpec.steps "Test Each Step" do
+          before :each  do
+            befores << :each
+          end
+          after :each do
+            afters << :each
+          end
+
+          before :all  do
+            befores << :all
+          end
+          after :all do
+            afters << :all
+          end
+
+          before :step  do
+            befores << :step
+          end
+          after :step do
+            afters << :step
+          end
+
+          it "should 1" do
+            1.should == 1
+          end
+          it "should 2" do
+            2.should == 2
+          end
+          it "should 3" do
+            3.should == 3
+          end
+        end
+        group.run
+      end
+
+      befores.find_all{|item| item == :all}.length.should == 1
+      befores.find_all{|item| item == :each}.length.should == 1
+      befores.find_all{|item| item == :step}.length.should == 3
+      afters.find_all{|item| item == :all}.length.should == 1
+      afters.find_all{|item| item == :each}.length.should == 1
+      afters.find_all{|item| item == :step}.length.should == 3
+    end
+
+    it "should mark later examples as failed if a before hook fails" do
+      group = nil
+      exception = Exception.new "Testing Error"
+
+      sandboxed do
+        group = RSpec.steps "Test Steps" do
+          before { raise exception }
+          it { 1.should == 1 }
+          it { 1.should == 1 }
+        end
+        group.run
+      end
+
+      group.examples.each do |example|
+        example.metadata[:execution_result][:status].should == 'failed'
+        example.metadata[:execution_result][:exception].should == exception
+      end
+    end
+
+    it "should mark later examples as pending if one fails" do
+      group = nil
+      sandboxed do
+        group = RSpec.steps "Test Steps" do
+          it { fail "All others fail" }
+          it { 1.should == 1 }
+        end
+        group.run
+      end
+
+      group.examples[1].metadata[:pending].should == true
+    end
+
+    it "should allow nested steps", :pending => "Not really" do
+      group = nil
+      sandboxed do
+        group = RSpec.steps "Test Steps" do
+          steps "Nested" do
+            it { @a = 1 }
+            it { @a.should == 1}
+          end
+        end
+        group.run
+      end
+
+      group.children[0].examples.each do |example|
+        example.metadata[:execution_result][:status].should == 'passed'
+      end
+      group.children[0].should have(2).examples
+    end
+
+    it "should not allow nested normal contexts" do
+      pending "A correct approach - in the meantime, this behavior is undefined"
+      expect {
+        sandboxed do
+        RSpec.steps "Basic" do
+          describe "Not allowed" do
+          end
+        end
+        end
+      }.to raise_error
+    end
+  end
+end

data/spec_help/file-sandbox.rb

@@ -0,0 +1,164 @@
+require 'ftools'
+require 'fileutils'
+
+module FileSandbox
+  def self.included(spec)
+    return unless spec.respond_to? :before
+
+    spec.before do
+      setup_sandbox
+    end
+
+    spec.after do
+      teardown_sandbox
+    end
+  end
+
+  class HaveContents
+    def initialize(contents)
+      @contents = contents
+    end
+
+    def matches?(target)
+      case @contents
+      when Regexp
+	@contents =~ target.contents
+      when String
+	@contents == target.contents
+      end
+    end
+  end
+
+  def have_contents(expected)
+    HaveContents.new(expected)
+  end
+
+  attr_reader :sandbox
+  
+  def in_sandbox(&block)
+    raise "I expected to create a sandbox as you passed in a block to me" if !block_given?
+
+    setup_sandbox
+    original_error = nil
+
+    begin
+      yield @sandbox
+    rescue => e
+      original_error = e
+      raise
+    ensure
+      begin
+        teardown_sandbox
+      rescue
+        if original_error
+          STDERR.puts "ALERT: a test raised an error and failed to release some lock(s) in the sandbox directory"
+          raise(original_error)
+        else
+          raise
+        end
+      end
+    end
+  end
+
+  def setup_sandbox(path = '__sandbox')
+    unless @sandbox
+      @sandbox = Sandbox.new(path)
+      @__old_path_for_sandbox = Dir.pwd
+      Dir.chdir(@sandbox.root)
+    end
+  end
+
+  def teardown_sandbox
+    if @sandbox
+      Dir.chdir(@__old_path_for_sandbox)
+      @sandbox.clean_up
+      @sandbox = nil
+    end
+  end
+
+  class Sandbox
+    attr_reader :root
+
+    def initialize(path = '__sandbox')
+      @root = File.expand_path(path)
+      clean_up
+      FileUtils.mkdir_p @root
+    end
+    
+    def [](name)
+      SandboxFile.new(File.join(@root, name), name)
+    end
+
+    # usage new :file=>'my file.rb', :with_contents=>'some stuff'
+    def new(options)
+      if options.has_key? :directory
+        dir = self[options.delete(:directory)]
+        FileUtils.mkdir_p dir.path
+      else
+        file = self[options.delete(:file)]
+        if (binary_content = options.delete(:with_binary_content) || options.delete(:with_binary_contents))
+          file.binary_content = binary_content
+        else
+          file.content = (options.delete(:with_content) || options.delete(:with_contents) || '')
+        end
+      end
+      
+      raise "unexpected keys '#{options.keys.join(', ')}'" unless options.empty?
+      
+      dir || file
+    end
+    
+    def remove(options)
+      name = File.join(@root, options[:file])
+      FileUtils.remove_file name
+    end
+    
+    def clean_up
+      FileUtils.rm_rf @root
+      if File.exists? @root
+        raise "Could not remove directory #{@root.inspect}, something is probably still holding a lock on it"
+      end
+    end
+  end
+
+
+  class SandboxFile
+    attr_reader :path
+    
+    def initialize(path, sandbox_path)
+      @path = path
+      @sandbox_path = sandbox_path
+    end
+
+    def inspect
+      "SandboxFile: #@sandbox_path"
+    end
+
+    def exist?
+      File.exist? path
+    end
+
+    def content
+      File.read path
+    end
+    
+    def content=(content)
+      FileUtils.mkdir_p File.dirname(@path)
+      File.open(@path, "w") {|f| f << content}
+    end
+    
+    def binary_content=(content)
+      FileUtils.mkdir_p File.dirname(@path)
+      File.open(@path, "wb") {|f| f << content}
+    end
+
+    def create
+      self.content = ''
+    end
+
+    alias exists? exist?
+    alias contents content
+    alias contents= content=
+    alias binary_contents= binary_content=    
+  end
+end

data/spec_help/gem_test_suite.rb

@@ -0,0 +1,17 @@
+puts Dir::pwd
+require 'test/unit'
+begin
+  require 'spec'
+rescue LoadError
+  false
+end
+
+class RSpecTest < Test::Unit::TestCase
+  def test_that_rspec_is_available
+    assert_nothing_raised("\n\n *  RSpec isn't available - please run: gem install rspec  *\n\n"){ ::Spec }
+  end
+
+  def test_that_specs_pass
+    assert(system(*%w{spec -f e -p **/*.rb spec}),"\n\n *  Specs failed  *\n\n")
+  end
+end

data/spec_help/rspec-sandbox.rb

@@ -0,0 +1,46 @@
+require 'rspec/core'
+
+class NullObject
+  private
+  def method_missing(method, *args, &block)
+    # ignore
+  end
+end
+
+def sandboxed(&block)
+  @orig_config = RSpec.configuration
+  @orig_world  = RSpec.world
+  new_config = RSpec::Core::Configuration.new
+  new_world  = RSpec::Core::World.new(new_config)
+  RSpec.instance_variable_set(:@configuration, new_config)
+  RSpec.instance_variable_set(:@world, new_world)
+
+  load 'two-step/duckpunch/example-group.rb'
+
+  object = Object.new
+  object.extend(RSpec::Core::SharedExampleGroup)
+  object.extend(TwoStep::DSL)
+  object.extend(RSpec::Core::DSL)
+
+  (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+    alias_method :orig_run, :run
+    def run(reporter=nil)
+      @orig_mock_space = RSpec::Mocks::space
+      RSpec::Mocks::space = RSpec::Mocks::Space.new
+      orig_run(reporter || NullObject.new)
+    ensure
+      RSpec::Mocks::space = @orig_mock_space
+    end
+  end
+
+  object.instance_eval(&block)
+ensure
+  (class << RSpec::Core::ExampleGroup; self; end).class_eval do
+    remove_method :run
+    alias_method :run, :orig_run
+    remove_method :orig_run
+  end
+
+  RSpec.instance_variable_set(:@configuration, @orig_config)
+  RSpec.instance_variable_set(:@world, @orig_world)
+end

data/spec_help/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'rspec'
+
+#Ungemmer::ungem_gemspec

data/spec_help/ungemmer.rb

@@ -0,0 +1,36 @@
+class Ungemmer
+  def self.ungem(*names)
+    deps = names.map do |name|
+      Gem::Dependency.new(name, nil)
+    end
+
+    deps.each do |dep|
+      Gem.source_index.search(dep).each do |gemspec|
+	puts " ** Ungemming #{gemspec.full_name}  **"
+	Gem.source_index.remove_spec(gemspec.full_name)
+      end
+    end
+
+    Gem.instance_eval do
+      if defined? Gem::MUTEX
+      Gem::MUTEX.synchronize do
+          @searcher = nil
+        end
+      else
+	@searcher = nil
+      end
+    end
+  end
+
+  def self.ungem_gemspec
+    Dir[File::expand_path(__FILE__ + "../../../*.gemspec")].each do |gemspec_path|
+      puts "Ungemming based on #{gemspec_path}"
+      begin
+        spec = Gem::Specification::load(gemspec_path)
+        Ungemmer::ungem(spec)
+      rescue LoadError
+        puts "Couldn't load #{gemspec_path}"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: two-step
+version: !ruby/object:Gem::Version
+  version: '1.0'
+platform: ruby
+authors:
+- Judson Lester
+- Evan Dorn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: corundum
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+- !ruby/object:Gem::Dependency
+  name: metric_fu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.11.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.11.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.6'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.6'
+    - - <
+      - !ruby/object:Gem::Version
+        version: '3'
+description: |2
+    I don't like Cucumber.  I don't need plain text stories.  My clients either
+    read code or don't read any test documents, so Cucumber is mostly useless to me.
+    But often, especially in full integration tests, it would be nice to have
+    steps in a test.
+email:
+- judson@lrdesign.com
+- evan@lrdesign.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- doc/README
+- doc/Specifications
+files:
+- lib/two-step.rb
+- lib/two-step/stepwise.rb
+- lib/two-step/duckpunch/example-group.rb
+- lib/two-step/duckpunch/example.rb
+- lib/two-step/duckpunch/object-extensions.rb
+- doc/README
+- doc/Specifications
+- spec/example_group_spec.rb
+- spec_help/spec_helper.rb
+- spec_help/gem_test_suite.rb
+- spec_help/rspec-sandbox.rb
+- spec_help/ungemmer.rb
+- spec_help/file-sandbox.rb
+homepage: https://github.com/LRDesign/two-step
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --inline-source
+- --main
+- doc/README
+- --title
+- two-step-1.0 RDoc
+require_paths:
+- lib/
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: two-step
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 3
+summary: I want steps in RSpec 2.x
+test_files:
+- spec_help/gem_test_suite.rb