cuke_writer 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+# Aruba artifacts
+tmp
+
+# Editors and tools and such
+.idea
+.redcar
+.project
+*~
+*.swp
+
+# Testing settings
+cucumber.yml
+.rspec
+
+# Added by bundler for the gem
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+

data/Gemfile

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

data/README.md

@@ -0,0 +1,222 @@
+CukeWriter
+==========
+
+[![Build Status](http://Travis-ci.org/joelhelbling/cuke_writer.png)](http://Travis-ci.org/joelhelbling/cuke_writer)
+
+
+What is it?
+-----------
+
+CukeWriter is a custom Cucumber formatter which collects steps and generates
+serialized sets of Cucumber features.
+
+To use it:
+
+    cucumber --format CukeWriter::Formatter features
+
+CukeWriter basically creates features and scenarios which correspond directly
+to the features and scenarios that generated them.  You'll need to instantiate
+a step collector:
+
+    @step_collector = StepCollector.new
+
+Now suppose we have a feature called features/awesome.feature:
+
+    Feature: Let's write some cukes
+    
+      Scenario: Just one step, but boy, what a step
+        Given I put all my eggs in one basket
+
+Then, in any of your step definitions, you do summa this:
+
+    Given /^I put all my eggs in one basket$/ do
+      @step_collector.add "Given I have hadoop report \"R#{SerialNumber}.html.gz\""
+      @step_collector.add "When I uncompress the hadoop report"
+      @step_collector.add "Then I should see \"All files processed\""
+    end
+
+Each collected step is added to a scenario/feature which has the same name as the scenario
+which had the step which collected that step.  So in this example, CukeWriter would create
+a feature called features/generated_features/20101122131415/awesome.cw.feature (where the
+serial number for this run was 20101122131415):
+
+    Feature: Let's write some cukes
+      [generated from features/awesome.feature]
+    
+      Scenario: Just one step, but boy, what a step
+        [from features/awesome.feature:3]
+        Given I have hadoop report "R20101122131415.html.gz"
+        When I uncompress the hadoop report
+        Then I should see "All files processed"
+
+If a scenario did not have any collected steps, it will not be added to its corresponding
+generated feature.  If a feature did not have any generated scenarios, it will not generate
+a CukeWriter feature.
+
+_This just in!  If your *generating* feature has a Background section which has steps which
+generate steps, then the *generated* feature will also have a Background section which 
+contains those generated background steps._
+
+Why Would You Want This?
+------------------------
+
+Suppose you are using Cucumber to test an asynchronous system which generates artifacts which won't
+be available for some time after your Cucumber tests run.  CukeWriter allows you to generate a
+serial-number-tagged set of Cucumber features which can be run at some later time.
+
+For example, suppose you wish to test an email messaging system which uses a third-party email
+service provider which takes its sweet ole time getting those messages into an actual email inbox.
+Each time you run your main features, you send a new batch of emails out.  You could tag each email
+with the serial number of that particular run, so that when you run the generated features, they
+will test the specific set of emails which were generated in the corresponding execution of the
+main features.
+
+Wait, What About Scenario Outlines?
+-----------------------------
+
+So glad you asked.  When CukeWriter encounters a scenario outline/example table in your 
+feature, it generates a separate regular ole Scenario:™ for each row in your examples
+table, and references the line number of the corresponding example table row.
+
+Early on, I figured I'd have CukeWriter just output a corresponding Scenario Outline:™,
+but as I thought about it, I realized that to assume the steps you generate from one example
+row could very well be different from the steps generated from another example row.  For
+example:
+
+    Feature: As a music fan,
+      In order to make the most of a rock star spotting,
+      I want to adapt to each rock star differently
+      So that I can get an autograph
+
+      Scenario Outline: This is it
+        Given I see "<rock_star>"
+
+      Examples:
+        | rock_star  |
+        | Ringo      |
+        | Sting      |
+        | Ted Nugent |
+
+And suppose you wanted this to generate different steps for different stars?  Here's an
+example of what we _can_ do:
+
+    Feature: As a music fan,
+      In order to make the most of a rock star spotting,
+      I want to adapt to each rock star differently
+      So that I can get an autograph
+      [generated from features/rock_star_recognition.feature]
+      
+      Scenario: This is it
+        [from features/rock_star_recognition.feature:8]
+        Given "Ringo" sees me
+        Then I say "Cheers!"
+      
+      Scenario: This is it
+        [from features/rock_star_recognition.feature:9]
+        Given Sting is in an elevator
+        When I say "De do do do, de da da da!"
+        Then Sting says "I just remembered, I've got some business on 85."
+      
+      Scenario: This is it
+        [from features/rock_star_recognition.feature:10]
+        Given Ted Nugent sees me
+        Then I run the other way
+
+All this unique handling of each brush with greatness becomes impossible if we just generate
+a single scenario outline.
+
+Step Tables
+-----------
+
+Sometimes you just want to have CukeWriter generate a step which has a table attached to it.  And
+that's ok.  `StepCollector#add` now accepts a hash as an optional second parameter, and in that
+hash you can send over a `:table` (in the form of a `Cucumber::Ast::Table`).  Behold:
+
+    Given I have a step with the following table:
+      | THAT  | THOSE     |
+      | thing | things    |
+      | there | overthere |
+
+...and supposing your step defintion did this:
+
+    Given /^I have a step with the following table:$/ |table|
+      @step_collector.add "Then this table goes here:", {:table => table}
+    end
+
+...then your generated cuke would have this step (and attendant table):
+
+    Then this table goes here:
+      | THAT  | THOSE     |
+      | thing | things    |
+      | there | overthere |
+
+Of course, you don't have to just pass a table straight through.  You can certainly just generate
+your own table, e.g.
+
+    table = Cucumber::Ast::Table.new [['GOO', 'GAH'], ['boo', 'bah']]
+
+Now that you can generate step tables, why, go forth, and multiply!
+
+Keep 'Em Seperated
+------------------
+
+If you're using CukeWriter to solve some kind of temporal distortion problem (a.k.a. an asynchronous
+problem) then chances good that when you want to run the features that use CukeWriter to write 
+features, you _don't_ want to run the features that CukeWriter has generated...and vice versa.
+Accordingly, CukeWriter puts a "@cuke_writer" tag on each feature that it generates.  This makes it
+easy to tell cucumber which kind of Cuke is in season now.  When it's time to plant nice neat rows
+of burpless seedlings, you can make Cucumber skip any CukeWriter-generated cukes with this:
+
+    cucumber --tags ~@cuke_writer
+
+And when it's time to turn our attention to the nice new crop of CukeWriter-written cukes, you can
+load 'em up for the county fair with this:
+
+    cucumber --tags @cuke_writer
+
+Thus CukeWriter uses Cucumber tags to heal rifts in the time-space continuum, which is pretty
+freakin' sweet.
+
+Suggestion: you might be able to simplify your personal journey by putting all this `--tags ~@cuke_writer`
+and `--tags @cuke_writer` stuff into your cucumber.yml.  For instance:
+
+    default: --tags ~@cuke_writer     # avoid running CW-generated cukes
+    cuke_writer: --tags @cuke_writer  # run *only* CW-generated cukes
+
+This seems like a very helpful suggestion if I do say so myself.  Someday I will make CukeWriter
+glance at your cucumber.yml and suggest this very same suggestion which I have suggested.  Unless, of
+course, you have already followed this suggestion, in which case CukeWriter will wink at you and 
+smile knowingly, like this: ;)
+
+What CukeWriter Won't Do
+------------------------
+
+_I would do anything for love, but I won't do that. --Meatloaf_
+
+CukeWriter will not kick off the generated batch of cucumber tests automatically.  This is because
+the mechanism for doing that will likely be different depending on the requirements of your project
+and operating environment in which CukeWriter is used:  it could be triggered by cron, your CI server,
+or a Windows scheduled task.  It could be scheduled for five minutes from now, or fifty years from
+now.  Or it could be run manually whenever you darn well please.  So let's leave the "when" and 
+"how" details in your hands.
+
+It also won't generate the step definitions you'll need for running your generated features.  You'll
+want to write those yourself since they're so important!
+
+What It _Will_ Do Soon
+--------------------
+
+Here's a nice, shallow backlog:
+
+ *   _Output "Background" section (only if background steps generate steps)_ ...[DONE]
+ *   _Handle scenario outlines_ ...[DONE]
+ *   _Handle step tables_ ...[DONE]
+ *   _Need a test which actually runs generated features to ensure they are kopasetic._ ...[DONE]
+ *   _Need a special tag (e.g. @cuke_writer) which is added to each generated feature.  This will allow
+     us to (re)run the main features while omitting the generated features and vice versa._ ...[DONE]
+ *   Have CW glance at cucumber.yml and suggest a couple of changes for working with/around
+     the @cw tag (unluss cucumber.yml already does so).
+ *   Generate a nice new rake task for each serialized batch of generated features.
+ *   Create a nice rake task which cleans up old batches of generated features.
+ *   Turn CukeWriter into a gem.
+

data/Rakefile

@@ -0,0 +1,15 @@
+require 'cucumber/rake/task'
+require 'rspec/core/rake_task'
+require 'bundler'
+
+task :default => [:rspec_tests, :cucumber_tests]
+
+Cucumber::Rake::Task.new(:cucumber_tests) do |t|
+  t.cucumber_opts = ['--no-source']
+end
+
+RSpec::Core::RakeTask.new(:rspec_tests) do |t|
+  t.rspec_opts = ['--format', 'nested']
+end
+
+Bundler::GemHelper.install_tasks

data/cuke_writer.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cuke_writer/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cuke_writer"
+  s.version     = CukeWriter::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Joel Helbling"]
+  s.email       = ["joel@joelhelbling.com"]
+  s.homepage    = "http://github.com/joelhelbling/cuke_writer"
+  s.summary     = %q{A Cucumber formatter which writes Cucumber features.}
+  s.description = %q{A custom Cucumber formatter which collects steps and generates serialized sets of Cucumber features. Meta FTW!}
+
+  s.rubyforge_project = "cuke_writer"
+
+  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_dependency 'cucumber', '>= 0.10.0'
+
+  s.add_development_dependency 'rake',       '>= 0.9.2'
+  s.add_development_dependency 'rspec',      '>= 2.6.0'
+  s.add_development_dependency 'rspec-core', '>= 2.6.4'
+  s.add_development_dependency 'aruba',      '>= 0.3.0'
+end

data/features/background.feature

@@ -0,0 +1,61 @@
+@announce
+Feature: As a tester, I want to generate steps from steps which are part of a background.
+
+  Background:
+    Given a typical support/env.rb file
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given /^I don't do much$/ do
+        :do_relatively_nothing
+      end
+      Given /^I add a step "([^"]*)"$/ do |step_tag|
+        @step_collector ||= StepCollector.new
+        @step_collector.add "Given I do \"#{step_tag}\""
+      end
+      """
+
+  Scenario: A feature with background doesn't generate a feature with a background
+    if background doesn't add any steps.
+    Given a file named "features/generate_sans_background.feature" with:
+      """
+      Feature:
+
+        Background: This background doesn't generate steps
+          Given I don't do much
+
+        Scenario: But the scenario does generate steps
+          Given I add a step "foo"
+      """
+    When I run the "generate_sans_background" feature
+    Then the file "features/generated_features/P123456/generate_sans_background.cw.feature" should contain "Feature:"
+    And the file "features/generated_features/P123456/generate_sans_background.cw.feature" should contain "Scenario:"
+    But the file "features/generated_features/P123456/generate_sans_background.cw.feature" should not contain "Background:"
+
+  Scenario: A feature with background does generate a feature with background
+    if background does add steps
+    Given a file named "features/generate_sans_background.feature" with:
+      """
+      Feature:
+
+        Background: This background does generate steps
+          Given I add a step "bar"
+
+        Scenario: And the scenario also generates steps
+          Given I add a step "foo"
+      """
+    When I run the "generate_sans_background" feature
+    Then the file "features/generated_features/P123456/generate_sans_background.cw.feature" should contain exactly:
+      """
+      @cuke_writer
+      Feature: 
+        [generated from features/generate_sans_background.feature]
+
+        Background: This background does generate steps
+          [from features/generate_sans_background.feature:3]
+          Given I do "bar"
+
+        Scenario: And the scenario also generates steps
+          [from features/generate_sans_background.feature:6]
+          Given I do "foo"
+
+        """

data/features/cuke_writer.feature

@@ -0,0 +1,98 @@
+@announce
+Feature: features with simple, straightforward scenarios
+
+  Background:
+    Given a typical support/env.rb file
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given /^I do this$/ do
+        @step_collector ||= StepCollector.new
+        @step_collector.add "Given I do that"
+      end
+      """
+
+  Scenario: A basic single-scenario feature with indentation
+    Given a file named "features/cuke_writer_test.feature" with:
+      """
+      Feature: Testing out CukeWriter
+
+        Scenario: A really basic scenario
+          Given I do this
+      """
+    When I run the "cuke_writer_test" feature
+    Then it should pass with: 
+      """
+      1 scenario (1 passed)
+      1 step (1 passed)
+      """
+    And the following directories should exist:
+      | features/generated_features/P123456 |
+    And the following files should exist:
+      | features/generated_features/P123456/cuke_writer_test.cw.feature |
+    And the file "features/generated_features/P123456/cuke_writer_test.cw.feature" should contain exactly:
+      """
+      @cuke_writer
+      Feature: Testing out CukeWriter
+        [generated from features/cuke_writer_test.feature]
+
+        Scenario: A really basic scenario
+          [from features/cuke_writer_test.feature:3]
+          Given I do that
+
+      """
+
+  Scenario: When no steps are added, don't write a scenario
+    Given a file named "features/suppress_empty_scenarios.feature" with:
+      """
+      Feature: Testing out CukeWriter
+
+        Scenario: that doesn't write a step
+          Given I don't do much
+
+        Scenario: that does write a step
+          Given I do this
+      """
+    And I append to "features/step_definitions/steps.rb" with:
+      """
+
+      Given /^I don't do much$/ do
+        :do_relatively_nothing
+      end
+
+      """
+    When I run the "suppress_empty_scenarios" feature
+    Then the file "features/generated_features/P123456/suppress_empty_scenarios.cw.feature" should contain exactly:
+      """
+      @cuke_writer
+      Feature: Testing out CukeWriter
+        [generated from features/suppress_empty_scenarios.feature]
+
+        Scenario: that does write a step
+          [from features/suppress_empty_scenarios.feature:6]
+          Given I do that
+
+      """
+
+  Scenario: When no scenarios are written, don't write a feature
+    Given a file named "features/suppress_empty_features.feature" with:
+      """
+      Feature: Look Ma, no steps!
+
+        Scenario: this guy don't do nuthin'
+          Given I don't do much
+
+        Scenario: this guy doesn't do anything either
+          Given I don't do much
+      """
+    And I append to "features/step_definitions/steps.rb" with:
+      """
+
+      Given /^I don't do much$/ do
+        :do_relatively_nothing
+      end
+
+      """
+    When I run the "suppress_empty_scenarios" feature
+    Then the following files should not exist:
+      | features/supress_empty_features.feature |
+

data/features/good_job_bob.feature

@@ -0,0 +1,39 @@
+@announce
+Feature: Here is a feature (let's call him "Bob") who uses aruba
+  to write and then run a feature which uses CukeWriter to write
+  another feature which Bob then runs and verifies its output.
+  Great job, Bob!
+
+  Background:
+    Given a typical support/env.rb file
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given /^I wrote this with aruba$/ do
+        @step_collector ||= StepCollector.new
+        @step_collector.add "Then I wrote this with CukeWriter"
+      end
+      Then /^I wrote this with CukeWriter$/ do
+        puts "Hi, Bob!"
+      end
+      """
+
+  Scenario: Bob writes and runs a feature, and then runs the feature written by that feature (via CukeWriter)
+    Given a file named "features/bobs_end_to_end.feature" with:
+      """
+      Feature: Bob writes a feature that writes a feature
+
+        Scenario: here is Bob's scenario
+          Given I wrote this with aruba
+
+      """
+    When I run the "bobs_end_to_end" feature
+    And I run `cucumber features/generated_features/P123456/bobs_end_to_end.cw.feature --no-color --no-source -r features/`
+    Then it should pass with:
+      """
+      1 scenario (1 passed)
+      1 step (1 passed)
+      """
+    And the output should contain:
+      """
+      Hi, Bob!
+      """

data/features/scenario_outline.feature

@@ -0,0 +1,64 @@
+@announce
+Feature: Features which have scenario outlines should generate a separate scenario
+  for each pass through the scenario outlines steps (i.e. through each row in the 
+  examples table).
+
+  Background:
+    Given a typical support/env.rb file
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given /^I don't do much$/ do
+        :do_relatively_nothing
+      end
+      Given /^I add a step "([^"]*)"$/ do |step_tag|
+        @step_collector ||= StepCollector.new
+        @step_collector.add "Given I do \"#{step_tag}\""
+      end
+      """
+
+  Scenario: a feature with a scenario outline generates a separate scenario for each example
+    Given a file named "features/has_a_scenario_outline.feature" with:
+      """
+      Feature: Messin' wit' scenario outlines
+
+        Scenario Outline: This is, well, you know
+          Given I don't do much
+          But I add a step "<step_name>"
+
+        Examples:
+          | step_name |
+          | foo       |
+          | bar       |
+          | baz       |
+
+        Scenario: Another scenario just to prove there are no side effects
+          Given I add a step "have fun!"
+      """
+    When I run the "has_a_scenario_outline" feature
+    Then the file "features/generated_features/P123456/has_a_scenario_outline.cw.feature" should not contain "Scenario Outline:"
+    And the file "features/generated_features/P123456/has_a_scenario_outline.cw.feature" should not contain "Examples:"
+    And the file "features/generated_features/P123456/has_a_scenario_outline.cw.feature" should not contain "Scenarios:"
+    But the file "features/generated_features/P123456/has_a_scenario_outline.cw.feature" should contain exactly:
+      """
+      @cuke_writer
+      Feature: Messin' wit' scenario outlines
+        [generated from features/has_a_scenario_outline.feature]
+
+        Scenario: This is, well, you know
+          [from features/has_a_scenario_outline.feature:9]
+          Given I do "foo"
+
+        Scenario: This is, well, you know
+          [from features/has_a_scenario_outline.feature:10]
+          Given I do "bar"
+
+        Scenario: This is, well, you know
+          [from features/has_a_scenario_outline.feature:11]
+          Given I do "baz"
+
+        Scenario: Another scenario just to prove there are no side effects
+          [from features/has_a_scenario_outline.feature:13]
+          Given I do "have fun!"
+
+      """
+

data/features/step_definitions/cuke_writer_steps.rb

@@ -0,0 +1,17 @@
+Given /^a serial number "([^"]*)"$/ do |serial_number|
+  SerialNumber.number = serial_number
+end
+
+Given /^a typical support\/env.rb file$/ do
+  Given "a file named \"features/support/env.rb\" with:", <<-EOF
+require File.dirname(__FILE__) + '/../../../../lib/cuke_writer'
+require File.dirname(__FILE__) + '/../../../../lib/step_collector'
+require File.dirname(__FILE__) + '/../../../../lib/serial_number'
+
+SerialNumber.number = "P123456"
+  EOF
+end
+
+When /^I run the "([^"]*)" feature$/ do |feature_name|
+    When "I run \`cucumber features/#{feature_name}.feature -f CukeWriter::Formatter -o cuke_writer.txt -f progress\`"
+end

data/features/step_tables.feature

@@ -0,0 +1,41 @@
+@announce
+Feature: a step table may be passed to the step_collector to be 
+  appended after the corresponding step.
+
+  Background:
+    Given a typical support/env.rb file
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given /^I do "([^"]*)" with:$/ do |step_tag, table|
+        @step_collector ||= StepCollector.new
+        @step_collector.add "Then I put \"#{step_tag}\" on the table:", {:table => table}
+      end
+      """
+
+  Scenario:
+    Given a file named "features/has_a_step_table.feature" with:
+      """
+      Feature: Messin' wit step tables!
+
+        Scenario: Here we go
+          Given I do "this" with:
+            | that  | those     |
+            | thing | things    |
+            | there | overthere |
+      """
+    When I run the "has_a_step_table" feature
+    Then the file "features/generated_features/P123456/has_a_step_table.cw.feature" should contain exactly:
+      """
+      @cuke_writer
+      Feature: Messin' wit step tables!
+        [generated from features/has_a_step_table.feature]
+
+        Scenario: Here we go
+          [from features/has_a_step_table.feature:3]
+          Then I put "this" on the table:
+            | that  | those     |
+            | thing | things    |
+            | there | overthere |
+
+      """
+

data/features/support/env.rb

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'aruba/cucumber'
+require File.dirname(__FILE__) + '/../../lib/serial_number'

data/lib/cucumber_ast_feature.rb

@@ -0,0 +1,10 @@
+module Cucumber
+  module Ast
+    class Feature
+      def filename
+        @file.gsub(/^.*\//, '').gsub(/\.feature$/, '.cw.feature')
+      end
+    end
+  end
+end
+

data/lib/cuke_writer.rb

@@ -0,0 +1,62 @@
+require 'fileutils'
+require File.dirname(__FILE__) + '/step_collector'
+require File.dirname(__FILE__) + '/serial_number'
+require File.dirname(__FILE__) + '/cucumber_ast_feature'
+
+module CukeWriter
+  class Formatter
+
+    def initialize(step_mother, path_or_io, options)
+      @options = options
+      @meta_dir = 'generated_features'
+      @step_collector = StepCollector.new
+      @current_scenario_outline_heading = nil
+      @scenario_outline_name = nil
+      @currently_in_examples_table = false
+    end
+
+    def after_feature(feature)
+      if @step_collector.steps.size > 0
+        FileUtils.mkdir_p(output_directory) unless File.directory?(output_directory)
+        File.open("#{output_directory}/#{feature.filename}", 'w') do |fh|
+          fh.write "@cuke_writer\nFeature: #{feature.name}\n  [generated from #{feature.file}]\n"
+          fh.write @step_collector.steps.join("\n") + "\n"
+        end
+      end
+      @step_collector.reset
+    end
+
+    def scenario_name(keyword, name, file_colon_line, source_indent)
+      if keyword == 'Scenario Outline'
+        @scenario_outline_info = {:name => name, :file => file_colon_line.gsub(/:\d+$/, '')}
+      else
+        @step_collector.add_scenario "#{keyword}: #{name}\n    [from #{file_colon_line}]", {:indent => 2}
+      end
+    end
+
+    def background_name(keyword, name, file_colon_line, source_indent)
+      @step_collector.add_scenario "#{keyword}: #{name}\n    [from #{file_colon_line}]", {:indent => 2}
+    end
+
+    def examples_name(*args)
+      @currently_in_examples_table = true
+    end
+
+    def after_examples(*args)
+      @scenario_outline_name = nil
+      @currently_in_examples_table = false
+    end
+
+    def before_table_row(table_row)
+      if @currently_in_examples_table
+        @step_collector.add_scenario("Scenario: #{@scenario_outline_info[:name]}\n    [from #{@scenario_outline_info[:file]}:#{table_row.line}]", {:indent => 2})
+      end
+    end
+
+    private
+
+    def output_directory
+      "features/#{@meta_dir}/#{SerialNumber}"
+    end
+  end
+end

data/lib/cuke_writer/version.rb

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

data/lib/serial_number.rb

@@ -0,0 +1,24 @@
+require 'date'
+
+class SerialNumber
+  @@prefix = ''
+  @@number = nil
+
+  def self.number
+    @@number ||= generate_new_number
+    "#{@@prefix}#{@@number}"
+  end
+  def self.number=(new_number)
+    @@number = new_number
+  end
+  def self.prefix=(prefix)
+    @@prefix = prefix
+  end
+  def self.generate_new_number
+    DateTime.now.strftime('%Y%m%d%H%M%S')
+  end
+  def self.to_s
+    number
+  end
+end
+

data/lib/step_collector.rb

@@ -0,0 +1,29 @@
+class StepCollector
+  @@scenarios = []
+
+  def add_scenario(scenario, p={})
+    indent = p[:indent] || 2
+    spaces = "\n" + " " * indent
+    @@scenarios << [ spaces + scenario ]
+  end
+
+  def add(step, p={})
+    table  = p[:table]
+    indent = p[:indent] || 4
+    spaces = " " * indent
+    @@scenarios.last << spaces + step + prettified(table).to_s
+  end
+
+  def steps
+    @@scenarios.select { |scenario| scenario.size > 1 }.flatten
+  end
+
+  def reset
+    @@scenarios = []
+  end
+
+  def prettified(table, indent=4)
+    return nil unless table
+    table.to_s(:color => false, :indent => indent + 2).gsub(/\|  +/, "| ").gsub(/\s+$/, '')
+  end
+end

data/spec/lib/serial_number_spec.rb

@@ -0,0 +1,36 @@
+require 'date'
+require File.dirname(__FILE__) + '/../../lib/serial_number.rb'
+
+describe 'SerialNumber' do
+  before do
+    @time_piece = DateTime.now.strftime('%Y%m%d%H%M')
+  end
+  it "has a number (autogenerated!)" do
+    SerialNumber.number.should_not be_nil
+  end
+  specify "the autogenerated serial number should be date-time based" do
+    SerialNumber.number.should match(@time_piece)
+  end
+  it "accepts a serial number" do
+    lambda { SerialNumber.number = 123456 }.should_not raise_error
+  end
+  specify "the newly set number should be the serial number" do
+    SerialNumber.number = 987654
+    SerialNumber.number.should == "987654"
+  end
+  it "has a to_s method" do
+    SerialNumber.number = 112233445566
+    SerialNumber.to_s.should == '112233445566'
+  end
+  specify "this is cool: evaluate in string context, and class name returns the serial number!" do
+    SerialNumber.number = 333444555
+    "(#{SerialNumber})".should == '(333444555)'
+  end
+  it "accepts a prefix" do
+    lambda { SerialNumber.prefix = 'bar' }.should_not raise_error
+  end
+  specify "the number should begin with the prefix" do
+    SerialNumber.prefix = 'baz'
+    SerialNumber.number.should match(/^baz/)
+  end
+end

data/spec/lib/step_collector_spec.rb

@@ -0,0 +1,52 @@
+require File.dirname(__FILE__) + '/../../lib/step_collector'
+
+describe StepCollector do
+  before do
+    @step_collector = StepCollector.new
+  end
+
+  it "should return its steps" do
+    @step_collector.steps.should == []
+  end
+
+  it "adds scenarios" do
+    lambda { @step_collector.add_scenario "Scenario: We do stuff" }.should_not raise_error
+  end
+
+  it "should have an add method" do
+    lambda { @step_collector.add "Given my mama didn't raise no fool" }.should_not raise_error
+  end
+
+  specify "default indent for scenario headers is two spaces" do
+    @step_collector.steps.first.should == "\n  Scenario: We do stuff"
+  end
+
+  specify "default indent should be 4 spaces" do
+    @step_collector.add "When I indent things look nicer"
+    @step_collector.steps.last.should == "    When I indent things look nicer"
+  end
+
+  it "accumulates steps" do
+    @step_collector.add "When I spin around like this"
+    @step_collector.steps.should == [
+      "\n  Scenario: We do stuff",
+        "    Given my mama didn't raise no fool",
+        "    When I indent things look nicer",
+        "    When I spin around like this" ]
+  end
+
+  it "doesn't report scenarios which have no steps" do
+    @step_collector.add_scenario "Scenario: We do some more stuff (but not really)"
+    @step_collector.steps.should == [
+      "\n  Scenario: We do stuff",
+        "    Given my mama didn't raise no fool",
+        "    When I indent things look nicer",
+        "    When I spin around like this" ]
+  end
+
+  it "has no steps after resetting" do
+    @step_collector.reset
+    @step_collector.steps.should == []
+  end
+
+end

metadata

@@ -0,0 +1,137 @@
+--- !ruby/object:Gem::Specification 
+name: cuke_writer
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Joel Helbling
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-08 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.10.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.2
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec-core
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.6.4
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: aruba
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.3.0
+  type: :development
+  version_requirements: *id005
+description: A custom Cucumber formatter which collects steps and generates serialized sets of Cucumber features. Meta FTW!
+email: 
+- joel@joelhelbling.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- cuke_writer.gemspec
+- features/background.feature
+- features/cuke_writer.feature
+- features/good_job_bob.feature
+- features/scenario_outline.feature
+- features/step_definitions/cuke_writer_steps.rb
+- features/step_tables.feature
+- features/support/env.rb
+- lib/cucumber_ast_feature.rb
+- lib/cuke_writer.rb
+- lib/cuke_writer/version.rb
+- lib/serial_number.rb
+- lib/step_collector.rb
+- spec/lib/serial_number_spec.rb
+- spec/lib/step_collector_spec.rb
+has_rdoc: true
+homepage: http://github.com/joelhelbling/cuke_writer
+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: cuke_writer
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A Cucumber formatter which writes Cucumber features.
+test_files: 
+- features/background.feature
+- features/cuke_writer.feature
+- features/good_job_bob.feature
+- features/scenario_outline.feature
+- features/step_definitions/cuke_writer_steps.rb
+- features/step_tables.feature
+- features/support/env.rb
+- spec/lib/serial_number_spec.rb
+- spec/lib/step_collector_spec.rb