cucumber-json 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+examples/self_test/*
+*.gem
+pkg/*

data/LICENSE

@@ -0,0 +1,23 @@
+The MIT License
+
+Copyright (c) 2010 Jesse Newland
+Portions Copyright (c) 2008,2009 Aslak Hellesøy
+
+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/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'cucumber/rake/task'
+
+  Cucumber::Rake::Task.new do |t|
+    t.cucumber_opts = "--require features/"
+  end
+rescue LoadError
+end
+
+require 'rubygems'
+require 'rake'
+$LOAD_PATH.unshift 'lib'
+require 'cucumber/formatter/json/version'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.version = Cucumber::Formatter::JSON::VERSION
+  gem.name = "cucumber-json"
+  gem.summary = %Q{A cucumber formatter that outputs JSON}
+  gem.description = %Q{A cucumber formatter that outputs JSON}
+  gem.email = "jnewland@gmail.com"
+  gem.homepage = "http://github.com/jnewland/cucumber-json"
+  gem.authors = ["Jesse Newland"]
+  gem.add_dependency "cucumber", "~> 0.6.3"
+  gem.add_dependency "json", "~> 1.2.1"
+  gem.test_files.include 'features/**/*'
+  gem.test_files.exclude 'examples/self_test/tmp/features'
+  # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+end
+Jeweler::GemcutterTasks.new
+
+task :cucumber => :check_dependencies
+
+task :default => :cucumber

data/Readme.md

@@ -0,0 +1,63 @@
+cucumber-json
+=============
+
+A [Cucumber Output Formatter](http://wiki.github.com/aslakhellesoy/cucumber/custom-formatters)
+that generates JSON.
+
+    Feature: JSON formatter
+      As a developer
+      I want to receive reports of failing cucumber features in a parsable format
+      In order to facilitace elegant continuous integration
+      In order to protect revenue
+
+Installation
+------------
+
+    gem install cucumber-json
+
+Usage
+-----
+
+In your project:
+
+    cucumber --format Cucumber::Formatter::JSON
+
+Or, to output to a file:
+
+    cucumber --format Cucumber::Formatter::JSON --out path/to/filename
+
+Parsing
+-------
+
+The JSON generated is a hash that has 3 keys:
+
+* failing_features
+  * an array of all failing features, in a format similar to the default
+    cucumber format
+* features
+  * an array of all  features, in a format similar to the default cucumber
+    format
+* status_counts
+  * a hash of statuses, and the number of steps with that status
+  
+Additional information could be added to this hash in the future; this is just
+what I needed at the moment.
+
+Example
+-------
+
+The output of this project's cucumber features have been run through the
+`Cucumber::Formatter::JSON` formatter and included at `examples/features.json`.
+This was generated like so:
+
+    cucumber -f Cucumber::Formatter::JSON --out examples/features.json
+
+Author
+------
+
+[Jesse Newland](http://twitter.com/jnewland)
+
+License
+-------
+
+MIT, same license as Ruby. See `LICENSE` for more details

data/cucumber-json.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cucumber-json}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jesse Newland"]
+  s.date = %q{2010-05-19}
+  s.description = %q{A cucumber formatter that outputs JSON}
+  s.email = %q{jnewland@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "Rakefile",
+     "Readme.md",
+     "cucumber-json.gemspec",
+     "examples/features.json",
+     "features/formatter.feature",
+     "features/step_definitions/cucumber_steps.rb",
+     "features/step_definitions/custom_steps.rb",
+     "features/support/env.rb",
+     "lib/cucumber/formatter/json.rb",
+     "lib/cucumber/formatter/json/version.rb"
+  ]
+  s.homepage = %q{http://github.com/jnewland/cucumber-json}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A cucumber formatter that outputs JSON}
+  s.test_files = [
+    "features/formatter.feature",
+     "features/step_definitions",
+     "features/step_definitions/cucumber_steps.rb",
+     "features/step_definitions/custom_steps.rb",
+     "features/support",
+     "features/support/env.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<cucumber>, ["~> 0.6.3"])
+      s.add_runtime_dependency(%q<json>, ["~> 1.2.1"])
+    else
+      s.add_dependency(%q<cucumber>, ["~> 0.6.3"])
+      s.add_dependency(%q<json>, ["~> 1.2.1"])
+    end
+  else
+    s.add_dependency(%q<cucumber>, ["~> 0.6.3"])
+    s.add_dependency(%q<json>, ["~> 1.2.1"])
+  end
+end
+

data/examples/features.json

@@ -0,0 +1 @@
+{"failing_features":[],"features":["  Scenario:: One Failing Feature\n    When I run cucumber -r ../../../lib -r features/step_definitions -f Cucumber::Formatter::JSON features/one_failure.feature\n    Then the output should contain \"output['status_counts']['failed']\" set to \"1\"\n    And the output should contain \"output['status_counts']['passed']\" set to \"1\"\n    And the output should contain \"output['status_counts']['undefined']\" set to \"1\"\n    And the output should contain \"output['status_counts']['pending']\" set to \"1\"\n    And the output should contain the failing feature\n      \"\"\"\n        Scenario:: Failing\n          Given failing   # features/step_definitions/steps.rb:1\n            FAIL (RuntimeError)\n            ./features/step_definitions/steps.rb:2:in `/failing/'\n            features/one_failure.feature:4:in `Given failing'\n\n      \"\"\"\n","  Scenario:: Multiple Failing Features\n    When I run cucumber -r ../../../lib -r features/step_definitions -f Cucumber::Formatter::JSON features/multiple_failures.feature\n    Then the output should contain \"output['status_counts']['failed']\" set to \"3\"\n    And the output should contain \"output['status_counts']['passed']\" set to \"1\"\n    And the output should contain the failing feature\n      \"\"\"\n        Scenario:: Failing\n          Given failing   # features/step_definitions/steps.rb:1\n            FAIL (RuntimeError)\n            ./features/step_definitions/steps.rb:2:in `/failing/'\n            features/multiple_failures.feature:4:in `Given failing'\n\n      \"\"\"\n    And the output should contain the failing feature\n      \"\"\"\n        Scenario:: Failing2\n          Given failing    # features/step_definitions/steps.rb:1\n            FAIL (RuntimeError)\n            ./features/step_definitions/steps.rb:2:in `/failing/'\n            features/multiple_failures.feature:7:in `Given failing'\n\n      \"\"\"\n    And the output should contain the failing feature\n      \"\"\"\n        Scenario:: Failing3\n          Given failing    # features/step_definitions/steps.rb:1\n            FAIL (RuntimeError)\n            ./features/step_definitions/steps.rb:2:in `/failing/'\n            features/multiple_failures.feature:10:in `Given failing'\n\n      \"\"\"\n","  Scenario:: All Features Passing\n    When I run cucumber -r ../../../lib -r features/step_definitions -f Cucumber::Formatter::JSON features/all_passing.feature\n    Then the output should contain \"output['status_counts']['passed']\" set to \"2\"\n    And the output should contain no failing features\n"],"status_counts":{"passed":35}}

data/features/formatter.feature

@@ -0,0 +1,115 @@
+Feature: JSON formatter
+  As a developer
+  I want to receive reports of failing cucumber features in a parsable format
+  In order to facilitace elegant continuous integration
+  In order to protect revenue
+
+  Background:
+    Given a standard Cucumber project directory structure
+    And a file named "features/step_definitions/steps.rb" with:
+      """
+      Given /failing/ do
+        raise 'FAIL'
+      end
+
+      Given /pending/ do
+        pending
+      end
+
+      Given /passing/ do
+      end
+      """
+    And a file named "features/one_failure.feature" with:
+      """
+      Feature: One Failure
+
+        Scenario: Failing
+          Given failing
+
+        Scenario: Missing
+          Given missing
+
+        Scenario: Pending
+          Given pending
+
+        Scenario: Passing
+          Given passing
+      """
+    And a file named "features/multiple_failures.feature" with:
+      """
+      Feature: Multiple Failures
+
+        Scenario: Failing
+          Given failing
+
+        Scenario: Failing2
+          Given failing
+
+        Scenario: Failing3
+          Given failing
+
+        Scenario: Passing
+          Given passing
+      """
+    And a file named "features/all_passing.feature" with:
+      """
+      Feature: All Passing
+
+        Scenario: Passing
+          Given passing
+
+        Scenario: Passing2
+          Given passing
+
+      """
+
+  Scenario: One Failing Feature
+    When I run cucumber -r ../../../lib -r features/step_definitions -f Cucumber::Formatter::JSON features/one_failure.feature
+    Then the output should contain "output['status_counts']['failed']" set to "1"
+    And the output should contain "output['status_counts']['passed']" set to "1"
+    And the output should contain "output['status_counts']['undefined']" set to "1"
+    And the output should contain "output['status_counts']['pending']" set to "1"
+    And the output should contain the failing feature
+      """
+        Scenario:: Failing
+          Given failing   # features/step_definitions/steps.rb:1
+            FAIL (RuntimeError)
+            ./features/step_definitions/steps.rb:2:in `/failing/'
+            features/one_failure.feature:4:in `Given failing'
+
+      """
+  Scenario: Multiple Failing Features
+    When I run cucumber -r ../../../lib -r features/step_definitions -f Cucumber::Formatter::JSON features/multiple_failures.feature
+    Then the output should contain "output['status_counts']['failed']" set to "3"
+    And the output should contain "output['status_counts']['passed']" set to "1"
+    And the output should contain the failing feature
+      """
+        Scenario:: Failing
+          Given failing   # features/step_definitions/steps.rb:1
+            FAIL (RuntimeError)
+            ./features/step_definitions/steps.rb:2:in `/failing/'
+            features/multiple_failures.feature:4:in `Given failing'
+
+      """
+    And the output should contain the failing feature
+      """
+        Scenario:: Failing2
+          Given failing    # features/step_definitions/steps.rb:1
+            FAIL (RuntimeError)
+            ./features/step_definitions/steps.rb:2:in `/failing/'
+            features/multiple_failures.feature:7:in `Given failing'
+
+      """
+    And the output should contain the failing feature
+      """
+        Scenario:: Failing3
+          Given failing    # features/step_definitions/steps.rb:1
+            FAIL (RuntimeError)
+            ./features/step_definitions/steps.rb:2:in `/failing/'
+            features/multiple_failures.feature:10:in `Given failing'
+
+      """
+  Scenario: All Features Passing
+    When I run cucumber -r ../../../lib -r features/step_definitions -f Cucumber::Formatter::JSON features/all_passing.feature
+    Then the output should contain "output['status_counts']['passed']" set to "2"
+    And the output should contain no failing features

data/features/step_definitions/cucumber_steps.rb

@@ -0,0 +1,155 @@
+# encoding: utf-8
+require 'tempfile'
+
+Given /^I am in (.*)$/ do |example_dir_relative_path|
+  @current_dir = examples_dir(example_dir_relative_path)
+end
+
+Given /^a standard Cucumber project directory structure$/ do
+  @current_dir = working_dir
+  in_current_dir do
+    FileUtils.rm_rf 'features' if File.directory?('features')
+    FileUtils.mkdir_p 'features/support'
+    FileUtils.mkdir 'features/step_definitions'
+  end
+end
+
+Given /^the (.*) directory is empty$/ do |directory|
+  in_current_dir do
+    FileUtils.remove_dir(directory) rescue nil
+    FileUtils.mkdir 'tmp'
+  end
+end
+
+Given /^a file named "([^"]*)"$/ do |file_name|
+  create_file(file_name, '')
+end
+
+Given /^a file named "([^"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
+Given /^the following profiles? (?:are|is) defined:$/ do |profiles|
+  create_file('cucumber.yml', profiles)
+end
+
+Given /^I am running spork in the background$/ do
+  run_spork_in_background
+end
+
+Given /^I am running spork in the background on port (\d+)$/ do |port|
+  run_spork_in_background(port.to_i)
+end
+
+Given /^I am not running (?:.*) in the background$/ do
+  # no-op
+end
+
+Given /^I have environment variable (\w+) set to "([^"]*)"$/ do |variable, value|
+  set_env_var(variable, value)
+end
+
+When /^I run cucumber (.*)$/ do |cucumber_opts|
+  run "#{Cucumber::RUBY_BINARY} -r rubygems #{Cucumber::BINARY} --no-color #{cucumber_opts} CUCUMBER_OUTPUT_ENCODING=UTF-8"
+end
+
+When /^I run rake (.*)$/ do |rake_opts|
+  run "rake #{rake_opts} --trace"
+end
+
+Then /^it should (fail|pass)$/ do |success|
+  if success == 'fail'
+    last_exit_status.should_not == 0
+  else
+    if last_exit_status != 0
+      raise "Failed with exit status #{last_exit_status}\nSTDOUT:\n#{last_stdout}\nSTDERR:\n#{last_stderr}"
+    end
+  end
+end
+
+Then /^it should (fail|pass) with$/ do |success, output|
+  last_stdout.should == output
+  Then("it should #{success}")
+end
+
+Then /^the output should contain$/ do |text|
+  last_stdout.should include(text)
+end
+
+Then /^the output should not contain$/ do |text|
+  last_stdout.should_not include(text)
+end
+
+Then /^the output should be$/ do |text|
+  last_stdout.should == text
+end
+
+Then /^"([^"]*)" should contain$/ do |file, text|
+  strip_duration(IO.read(file)).should == text
+end
+
+Then /^"([^"]*)" with junit duration "([^"]*)" should contain$/ do |actual_file, duration_replacement, text|
+  actual = IO.read(actual_file)
+  actual = replace_junit_duration(actual, duration_replacement) 
+  actual = strip_ruby186_extra_trace(actual)
+  actual.should == text
+end
+
+Then /^"([^"]*)" should match "([^"]*)"$/ do |file, text|
+  File.open(file, Cucumber.file_mode('r')).read.should =~ Regexp.new(text)
+end
+
+Then /^"([^"]*)" should have the same contents as "([^"]*)"$/ do |actual_file, expected_file|
+  actual = IO.read(actual_file)
+  actual = replace_duration(actual, '0m30.005s')
+  # Comment out to replace expected file. Use with care!
+  # File.open(expected_file, "w") {|io| io.write(actual)}
+  actual.should == IO.read(expected_file)
+end
+
+Then /^STDERR should match$/ do |text|
+  last_stderr.should =~ /#{text}/
+end
+
+Then /^STDERR should not match$/ do |text|
+  last_stderr.should_not =~ /#{text}/
+end
+
+Then /^STDERR should be$/ do |text|
+  last_stderr.should == text
+end
+
+Then /^STDERR should be empty$/ do
+  last_stderr.should == ""
+end
+
+Then /^"([^"]*)" should exist$/ do |file|
+  File.exists?(file).should be_true
+  FileUtils.rm(file)
+end
+
+Then /^"([^"]*)" should not be required$/ do |file_name|
+  last_stdout.should_not include("* #{file_name}")
+end
+
+Then /^"([^"]*)" should be required$/ do |file_name|
+  last_stdout.should include("* #{file_name}")
+end
+
+Then /^exactly these files should be loaded:\s*(.*)$/ do |files|
+  last_stdout.scan(/^  \* (.*\.rb)$/).flatten.should == files.split(/,\s+/)
+end
+
+Then /^exactly these features should be ran:\s*(.*)$/ do |files|
+  last_stdout.scan(/^  \* (.*\.feature)$/).flatten.should == files.split(/,\s+/)
+end
+
+Then /^the (.*) profile should be used$/ do |profile|
+  last_stdout.should =~ /Using the #{profile} profile/
+end
+
+Then /^print output$/ do
+  puts last_stdout
+end
+
+

data/features/step_definitions/custom_steps.rb

@@ -0,0 +1,18 @@
+require 'json'
+Then /^the output should contain "([^"]*)" set to "([^"]*)"$/ do |variable, value|
+  Then 'STDERR should be empty'
+  output = JSON.parse(last_stdout)
+  eval(variable).to_s.should == value
+end
+
+Then /^the output should contain the failing feature$/ do |alert|
+  Then 'STDERR should be empty'
+  output = JSON.parse(last_stdout)
+  output['failing_features'].should include(alert)
+end
+
+Then /^the output should contain no failing features$/ do
+  Then 'STDERR should be empty'
+  output = JSON.parse(last_stdout)
+  output['failing_features'].should == []
+end

data/features/support/env.rb

@@ -0,0 +1,143 @@
+require 'rubygems'
+require 'tempfile'
+begin
+  require 'rspec/expectations'
+rescue LoadError
+  require 'spec/expectations'
+end
+require 'fileutils'
+require 'forwardable'
+require 'cucumber/formatter/unicode'
+
+class CucumberWorld
+  extend Forwardable
+  def_delegators CucumberWorld, :examples_dir, :self_test_dir, :working_dir, :cucumber_lib_dir
+
+  def self.examples_dir(subdir=nil)
+    @examples_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../examples'))
+    subdir ? File.join(@examples_dir, subdir) : @examples_dir
+  end
+
+  def self.self_test_dir
+    @self_test_dir ||= examples_dir('self_test')
+  end
+
+  def self.working_dir
+    @working_dir ||= examples_dir('self_test/tmp')
+  end
+
+  def cucumber_lib_dir
+    @cucumber_lib_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../lib'))
+  end
+
+  def initialize
+    @current_dir = self_test_dir
+  end
+
+  private
+  attr_reader :last_exit_status, :last_stderr
+
+  # The last standard out, with the duration line taken out (unpredictable)
+  def last_stdout
+    strip_1_9_paths(strip_duration(@last_stdout))
+  end
+
+  def strip_duration(s)
+    s.gsub(/^\d+m\d+\.\d+s\n/m, "")
+  end
+
+  def strip_1_9_paths(s)
+    s.gsub(/#{Dir.pwd}\/examples\/self_test\/tmp/m, ".").gsub(/#{Dir.pwd}\/examples\/self_test/m, ".")
+  end
+
+  def replace_duration(s, replacement)
+    s.gsub(/\d+m\d+\.\d+s/m, replacement)
+  end
+
+  def replace_junit_duration(s, replacement)
+    s.gsub(/\d+\.\d\d+/m, replacement)
+  end
+
+  def strip_ruby186_extra_trace(s)  
+    s.gsub(/^.*\.\/features\/step_definitions(.*)\n/, "")
+  end
+
+  def create_file(file_name, file_content)
+    file_content.gsub!("CUCUMBER_LIB", "'#{cucumber_lib_dir}'") # Some files, such as Rakefiles need to use the lib dir
+    in_current_dir do
+      FileUtils.mkdir_p(File.dirname(file_name)) unless File.directory?(File.dirname(file_name))
+      File.open(file_name, 'w') { |f| f << file_content }
+    end
+  end
+
+  def set_env_var(variable, value)
+    @original_env_vars ||= {}
+    @original_env_vars[variable] = ENV[variable] 
+    ENV[variable]  = value
+  end
+
+  def background_jobs
+    @background_jobs ||= []
+  end
+
+  def in_current_dir(&block)
+    Dir.chdir(@current_dir, &block)
+  end
+
+  def run(command)
+    stderr_file = Tempfile.new('cucumber')
+    stderr_file.close
+    in_current_dir do
+      mode = Cucumber::RUBY_1_9 ? {:external_encoding=>"UTF-8"} : 'r'
+      IO.popen("#{command} 2> #{stderr_file.path}", mode) do |io|
+        @last_stdout = io.read
+      end
+
+      @last_exit_status = $?.exitstatus
+    end
+    @last_stderr = IO.read(stderr_file.path)
+  end
+
+  def run_spork_in_background(port = nil)
+    require 'spork'
+
+    pid = fork
+    in_current_dir do
+      if pid
+        background_jobs << pid
+      else
+        # STDOUT.close
+        # STDERR.close
+        port_arg = port ? "-p #{port}" : ''
+        cmd = "#{Cucumber::RUBY_BINARY} -I #{Cucumber::LIBDIR} #{Spork::BINARY} cuc #{port_arg}"
+        exec cmd
+      end
+    end
+    sleep 1.0
+  end
+
+  def terminate_background_jobs
+    background_jobs.each do |pid|
+      Process.kill(Signal.list['TERM'], pid)
+    end
+  end
+
+  def restore_original_env_vars
+    @original_env_vars.each { |variable, value| ENV[variable] = value } if @original_env_vars
+  end
+
+end
+
+World do
+  CucumberWorld.new
+end
+
+Before do
+  FileUtils.rm_rf CucumberWorld.working_dir
+  FileUtils.mkdir CucumberWorld.working_dir
+end
+
+After do
+  terminate_background_jobs
+  restore_original_env_vars
+end

data/lib/cucumber/formatter/json/version.rb

@@ -0,0 +1,7 @@
+module Cucumber
+  module Formatter
+    class JSON
+      VERSION = '0.0.1'
+    end
+  end
+end

data/lib/cucumber/formatter/json.rb

@@ -0,0 +1,241 @@
+require 'json'
+require 'cucumber/formatter/io'
+
+module Cucumber
+  module Formatter
+    class JSON
+      include Io
+
+      FORMATS = Hash.new{|hash, format| hash[format] = method(format).to_proc}
+
+      def initialize(step_mother, path_or_io, options)
+        @io = ensure_io(path_or_io, "json")
+        @options = options
+        @status_counts = Hash.new{|h,k| h[k] = 0}
+        @indent = 0
+        @hash = {}
+      end
+
+      def before_examples(*args)
+        @header_row = true
+      end
+
+      def before_feature(feature)
+        @exceptions = []
+        @indent = 0
+        @feature = ''
+      end
+
+      def before_feature_element(feature_element)
+        @indent = 2
+        @element_exceptions = []
+        @feature = ""
+        @scenario_indent = 2
+      end
+
+      def before_background(background)
+        @indent = 2
+        @scenario_indent = 2
+        @in_background = true
+      end
+
+      def after_background(background)
+        @in_background = nil
+      end
+
+      def background_name(keyword, name, file_colon_line, source_indent)
+        print_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def background_name(keyword, name, file_colon_line, source_indent)
+        print_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def before_examples_array(examples_array)
+        @indent = 4
+        @visiting_first_example_name = true
+      end
+
+      def examples_name(keyword, name)
+        @feature <<  "\n" unless @visiting_first_example_name
+        @visiting_first_example_name = false
+        names = name.strip.empty? ? [name.strip] : name.split("\n")
+        @feature <<  "    #{keyword}: #{names[0]}\n"
+        names[1..-1].each {|s| @feature <<  "      #{s}\n" } unless names.empty?
+        @indent = 6
+        @scenario_indent = 6
+      end
+
+      def before_outline_table(outline_table)
+        @table = outline_table
+      end
+
+      def after_outline_table(outline_table)
+        @table = nil
+        @indent = 4
+      end
+
+      def scenario_name(keyword, name, file_colon_line, source_indent)
+        print_feature_element_name(keyword, name, file_colon_line, source_indent)
+      end
+
+      def before_step(step)
+        @current_step = step
+        @indent = 6
+      end
+
+      def before_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        @hide_this_step = false
+        if exception
+          if @exceptions.include?(exception)
+            @hide_this_step = true
+            return
+          end
+          @element_exceptions << exception
+          @exceptions << exception
+        end
+        if status != :failed && @in_background ^ background
+          @hide_this_step = true
+          return
+        end
+        @status = status
+      end
+
+      def step_name(keyword, step_match, status, source_indent, background)
+        return if @hide_this_step
+        source_indent = nil unless @options[:source]
+        name_to_report = format_step(keyword, step_match, status, source_indent)
+        @feature <<  name_to_report.indent(@scenario_indent + 2)
+        @feature <<  "\n"
+      end
+
+      def py_string(string)
+        return if @hide_this_step
+        s = %{"""\n#{string}\n"""}.indent(@indent)
+        s = s.split("\n").map{|l| l =~ /^\s+$/ ? '' : l}.join("\n")
+        @feature <<  format_string(s, @current_step.status)
+        @feature <<  "\n"
+      end
+
+      def exception(exception, status)
+        return if @hide_this_step
+        print_exception(exception, status, @indent)
+      end
+
+      def before_multiline_arg(multiline_arg)
+        return if @options[:no_multiline] || @hide_this_step
+        @table = multiline_arg
+      end
+
+      def after_multiline_arg(multiline_arg)
+        @table = nil
+      end
+
+      def before_table_row(table_row)
+        return if !@table || @hide_this_step
+        @col_index = 0
+        @feature <<  '  |'.indent(@indent-2)
+      end
+
+      def after_table_cell(cell)
+        return unless @table
+        @col_index += 1
+      end
+
+      def table_cell_value(value, status)
+        return if !@table || @hide_this_step
+        status ||= @status || :passed
+        width = @table.col_width(@col_index)
+        cell_text = value.to_s || ''
+        padded = cell_text + (' ' * (width - cell_text.jlength))
+        prefix = cell_prefix(status)
+        @feature <<  ' ' + format_string("#{prefix}#{padded}", status) + ::Term::ANSIColor.reset(" |")
+        @feature <<  "\n"
+      end
+
+      # mine
+
+      def after_step_result(keyword, step_match, multiline_arg, status, exception, source_indent, background)
+        record_result(status, :step_match => step_match)
+      end
+
+      def after_table_row(table_row)
+        unless @header_row
+          record_result(table_row.status) if table_row.respond_to?(:status)
+        end
+        @header_row = false if @header_row
+        return if !@table || @hide_this_step
+        print_table_row_announcements
+        @feature <<  "\n"
+        if table_row.exception && !@exceptions.include?(table_row.exception)
+          print_exception(table_row.exception, table_row.status, @indent)
+        end
+      end
+
+      def after_features(steps)
+        @hash[:status_counts] = @status_counts
+        @io.print(@hash.to_json)
+        @io.flush
+        @io.close
+      end
+
+      def after_feature_element(element)
+        @hash[:features] ||= []
+        @hash[:features] << @feature
+        @hash[:failing_features] ||= []
+        if @element_exceptions.size > 0
+          @hash[:failing_features] << @feature
+        end
+        @feature = ''
+      end
+
+    private
+
+      def record_result(status, opts={})
+        step_match = opts[:step_match] || true
+        @status_counts[status] = @status_counts[status] + 1
+      end
+
+      def print_feature_element_name(keyword, name, file_colon_line, source_indent)
+        @feature <<  "\n" if @scenario_indent == 6
+        names = name.empty? ? [name] : name.split("\n")
+        line = "#{keyword}: #{names[0]}".indent(@scenario_indent)
+        @feature <<  line
+        @feature <<  "\n"
+        names[1..-1].each {|s| @feature <<  "    #{s}\n"}
+      end
+
+      def print_exception(e, status, indent)
+        @feature <<  format_string("#{e.message} (#{e.class})\n#{e.backtrace.join("\n")}".indent(indent), status)
+        @feature <<  "\n"
+      end
+
+      def cell_prefix(status)
+        @prefixes[status]
+      end
+
+      def format_string(string, status)
+       string
+      end
+
+      def format_step(keyword, step_match, status, source_indent)
+        comment = if source_indent
+          c = (' # ' + step_match.file_colon_line).indent(source_indent)
+          format_string(c, :comment)
+        else
+          ''
+        end
+
+        if status == :passed
+          line = keyword + ' ' + step_match.format_args("%s")
+          format_string(line, status)
+        else
+          line = keyword + ' ' + step_match.format_args("%s") + comment
+          format_string(line, status)
+        end
+      end
+
+    end
+  end
+end
+require "#{File.dirname(__FILE__)}/json/version"

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification 
+name: cucumber-json
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Jesse Newland
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-19 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: cucumber
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 6
+        - 3
+        version: 0.6.3
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: json
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 2
+        - 1
+        version: 1.2.1
+  type: :runtime
+  version_requirements: *id002
+description: A cucumber formatter that outputs JSON
+email: jnewland@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+files: 
+- .gitignore
+- LICENSE
+- Rakefile
+- Readme.md
+- cucumber-json.gemspec
+- examples/features.json
+- features/formatter.feature
+- features/step_definitions/cucumber_steps.rb
+- features/step_definitions/custom_steps.rb
+- features/support/env.rb
+- lib/cucumber/formatter/json.rb
+- lib/cucumber/formatter/json/version.rb
+has_rdoc: true
+homepage: http://github.com/jnewland/cucumber-json
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A cucumber formatter that outputs JSON
+test_files: 
+- features/formatter.feature
+- features/step_definitions/cucumber_steps.rb
+- features/step_definitions/custom_steps.rb
+- features/support/env.rb