resque-pool 0.3.0.beta.2 → 0.3.0

data/vendor/bundle/ruby/1.8/gems/gherkin-2.9.3/features/json_parser.feature

@@ -0,0 +1,331 @@
+Feature: JSON lexer
+  In order to support greater access to features
+  we want JSON
+
+  Background:
+    Given a PrettyFormatter
+    And a JSON lexer
+
+  Scenario: Only a Feature
+    Given the following JSON is parsed:
+      """
+      [
+        {
+          "comments": [
+            {"value": "# language: no"}, 
+            {"value": "# Another comment"}
+          ],
+          "description": "",
+          "keyword": "Egenskap",
+          "id": "kjapp",
+          "name": "Kjapp",
+          "tags": [],
+          "uri": "test.feature"
+        }
+      ]
+      """
+    Then the outputted text should be:
+      """
+      # language: no
+      # Another comment
+      Egenskap: Kjapp
+      """
+
+  Scenario: Feature with scenarios and outlines
+    Given the following JSON is parsed:
+      """
+      [
+        {
+          "comments": [],
+          "keyword": "Feature",
+          "id": "oh-hai",
+          "name": "OH HAI",
+          "tags": [{"name": "@one"}],
+          "uri": "test.feature",
+          "description": "",
+          "elements":[
+            {
+              "comments": [],
+              "tags": [],
+              "keyword": "Scenario",
+              "id": "oh-hai/fujin",
+              "name": "Fujin",
+              "description": "",
+              "type": "scenario",
+              "line": 4,
+              "steps": [
+                {
+                  "comments": [],
+                  "keyword": "Given ",
+                  "name": "wind",
+                  "line": 5
+                },
+                {
+                  "comments": [],
+                  "keyword": "Then ",
+                  "name": "spirit",
+                  "line": 6
+                }
+              ]
+            },
+            {
+              "comments": [],
+              "tags": [{"name": "@two"}],
+              "keyword": "Scenario",
+              "id": "oh-hai/_why",
+              "name": "_why",
+              "description": "",
+              "type": "scenario",
+              "line": 9,
+              "steps": [
+                {
+                  "comments": [],
+                  "keyword": "Given ",
+                  "name": "chunky",
+                  "line": 10
+                },
+                {
+                  "comments": [],
+                  "keyword": "Then ",
+                  "name": "bacon",
+                  "line": 11
+                }
+              ]
+            },
+            {
+              "comments": [],
+              "tags": [{"name": "@three"}, {"name": "@four"}],
+              "keyword": "Scenario Outline",
+              "id": "oh-hai/life",
+              "name": "Life",
+              "description": "",
+              "type": "scenario_outline",
+              "line": 14,
+              "steps": [
+                {
+                  "comments": [],
+                  "keyword": "Given ",
+                  "name": "some <boredom>",
+                  "line": 15
+                }
+              ],
+              "examples": [
+                {
+                  "type": "examples",
+                  "comments": [],
+                  "tags": [{"name": "@five"}],
+                  "keyword": "Examples",
+                  "id": "oh-hai/life/real-life",
+                  "name": "Real life",
+                  "description": "",
+                  "line": 18,
+                  "rows": [
+                    {
+                      "comments": [],
+                      "cells": ["boredom"],
+                      "line": 19
+                    },
+                    {
+                      "comments": [],
+                      "cells": ["airport"],
+                      "line": 20
+                    },
+                    {
+                      "comments": [],
+                      "cells": ["meeting"],
+                      "line": 21
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              "comments": [],
+              "tags": [],
+              "keyword": "Scenario",
+              "id": "oh-hai/who-stole-my-mojo?",
+              "name": "who stole my mojo?",
+              "description": "",
+              "type": "scenario",
+              "line": 23,
+              "steps": [
+                {
+                  "comments": [],
+                  "keyword": "When ",
+                  "name": "I was",
+                  "line": 24,
+                  "rows": [
+                    {
+                      "comments": [],
+                      "line": 25,
+                      "cells": ["asleep"]
+                    }
+                  ]
+                },
+                {
+                  "comments": [],
+                  "keyword": "And ",
+                  "name": "so",
+                  "line": 26,
+                  "doc_string": {
+                    "value": "innocent",
+                    "line": 27
+                  }
+                }
+              ]
+            },
+            {
+              "comments": [{"value": "# The"}],
+              "tags": [],
+              "keyword": "Scenario Outline",
+              "description": "",
+              "type": "scenario_outline",
+              "line": 32,
+              "id": "oh-hai/with",
+              "name": "with",
+              "steps": [
+                {
+                  "comments": [{"value": "# all"}],
+                  "keyword": "Then ",
+                  "line": 34,
+                  "name": "nice"
+                }
+              ],
+              "examples": [
+                {
+                  "type": "examples",
+                  "comments": [{"value": "# comments"}, {"value": "# everywhere"}],
+                  "tags": [],
+                  "keyword": "Examples",
+                  "id": "oh-hai/with/an-example",
+                  "name": "An example",
+                  "description": "",
+                  "line": 38,
+                  "rows": [
+                    {
+                      "comments": [{"value": "# I mean"}],
+                      "line": 40,
+                      "cells": ["partout"]
+                    },
+                    {
+                      "comments": [{"value": "# I really mean"}],
+                      "line": 40,
+                      "cells": ["bartout"]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      ]
+      """
+    Then the outputted text should be:
+      """
+      @one
+      Feature: OH HAI
+
+        Scenario: Fujin
+          Given wind
+          Then spirit
+
+        @two
+        Scenario: _why
+          Given chunky
+          Then bacon
+
+        @three @four
+        Scenario Outline: Life
+          Given some <boredom>
+
+          @five
+          Examples: Real life
+            | boredom |
+            | airport |
+            | meeting |
+
+        Scenario: who stole my mojo?
+          When I was
+            | asleep |
+          And so
+            \"\"\"
+            innocent
+            \"\"\"
+
+        # The
+        Scenario Outline: with
+          # all
+          Then nice
+
+          # comments
+          # everywhere
+          Examples: An example
+            # I mean
+            | partout |
+            # I really mean
+            | bartout |
+      """
+
+  Scenario: Feature with Background
+    Given the following JSON is parsed:
+      """
+      [
+        {
+          "comments": [],
+          "description": "",
+          "keyword": "Feature",
+          "id": "kjapp",
+          "name": "Kjapp",
+          "tags": [],
+          "uri": "test.feature",
+          "elements": [
+            {
+              "type": "background",
+              "comments": [],
+              "description": "",
+              "keyword": "Background",
+              "line": 2,
+              "name": "No idea what Kjapp means",
+              "steps": [
+                {
+                  "comments": [],
+                  "keyword": "Given ",
+                  "line": 3,
+                  "name": "I Google it"
+                }
+              ]
+            },
+            {
+              "type": "scenario",
+              "comments": [{"value": "# Writing JSON by hand sucks"}],
+              "tags": [],
+              "keyword": "Scenario",
+              "id": "kjapp/",
+              "name": "",
+              "description": "",
+              "line": 6,
+              "steps": [
+                {
+                  "comments": [],
+                  "keyword": "Then ",
+                  "name": "I think it means \"fast\"",
+                  "line": 7
+                }
+              ]
+            }
+          ]
+        }
+      ]
+      """
+    Then the outputted text should be:
+      """
+      Feature: Kjapp
+
+        Background: No idea what Kjapp means
+          Given I Google it
+
+        # Writing JSON by hand sucks
+        Scenario: 
+          Then I think it means "fast"
+      """
+    

data/vendor/bundle/ruby/1.8/gems/gherkin-2.9.3/features/native_lexer.feature

@@ -0,0 +1,19 @@
+Feature: Native (C/Java) Lexer
+
+  Background: 
+    Given a "native" "root" parser
+
+  Scenario: Parsing an empty feature
+    Given the following text is parsed:
+      """
+      Feature: blah
+      """
+    Then there should be no parse errors
+
+  Scenario: Parsing a comment
+    Given the following text is parsed:
+      """
+      # A comment
+      Feature: Hello
+      """
+    Then there should be no parse errors

data/vendor/bundle/ruby/1.8/gems/gherkin-2.9.3/features/parser_with_native_lexer.feature

@@ -0,0 +1,205 @@
+Feature: Gherkin Feature lexer/parser
+  In order to make it easy to control the Gherkin syntax
+  As a Gherkin developer bent on Gherkin world-domination
+  I want a feature lexer that uses a feature parser to
+  make all the syntax decisions for me
+
+  Background: 
+    Given a "native" "root" parser
+
+  Scenario: Correctly formed feature
+    When the following text is parsed:
+      """
+      # Apologies to Bill Watterson
+      @cardboard_box @wip
+      Feature: Transmogrification
+        As a young boy with a hyperactive imagination
+        I want a cardboard box
+        In order to transform the ennui of suburban life into something
+          befitting my imagination
+        
+        Background: 
+          Given I have a transmogrifier
+          And I am a member of G.R.O.S.S
+        
+        Scenario: Whoozit to whatzit transmogrification
+          Given I have a whoozit
+          When I put it in the transmogrifier
+          And I press the "transmogrify" button
+          Then I should have a whatzit
+      
+        Scenario Outline: Imaginary Beings
+          Given I have a <boring being>
+          When I transmogrify it with the incantation:
+          \"\"\"
+          ALAKAZAM!
+          \"\"\"
+          Then I should have an <exciting being>
+      
+          Examples:
+          | boring being | exciting being |
+          | Sparrow      | Alicanto       |
+          | Goldfish     | Baldanders     |
+          | Cow          | Hsiao          |
+          
+        Scenario: Sense of humor detection
+          Given the following excerpt:
+            \"\"\"
+            WOMAN:  Who are the Britons?
+            ARTHUR:  Well, we all are. we're all Britons and I am your king.
+            WOMAN:  I didn't know we had a king.  I thought we were an autonomous
+                collective.
+            DENNIS:  You're fooling yourself.  We're living in a dictatorship.
+                A self-perpetuating autocracy in which the working classes--
+            WOMAN:  Oh there you go, bringing class into it again.
+            DENNIS:  That's what it's all about if only people would--
+            ARTHUR:  Please, please good people.  I am in haste.  Who lives
+                in that castle?  
+            \"\"\"
+          When I read it
+          Then I should be amused
+      """
+    Then there should be no parse errors
+
+  Scenario: Keyword before feature
+    When the following text is parsed:
+      """
+      Scenario: Bullying my way to the head of the line
+        Given I am a big bully of a scenario
+        Then I should be caught by the syntax police(y)
+      
+      Feature: Too timid to stand up for myself
+      """
+    Then there should be parse errors on lines 1 through 3
+
+  Scenario: Tag ends background and scenario
+    When the following text is parsed:
+      """
+      Feature: test feature
+        Background:
+          Given a something
+          @tag
+          And something else
+          
+      @foo
+      Scenario: my scenario
+        @tag
+        Given this is a step
+        @oh_hai
+        And this is a horrible idea
+        Then it shouldn't work
+      """
+    Then there should be parse errors on lines 5, 10 and 12
+
+  Scenario: Tables
+    When the following text is parsed:
+      """
+      Feature: Antiques Roadshow
+      Scenario Outline: Table
+        Given a <foo>
+        Then a <bar>        
+        
+      Examples:
+        | foo | bar   |
+        | 42  | towel |
+        @hello
+        | 1   | prime |
+        
+      Scenario: Table arguments
+        Given this step needs this table:
+        | foo | bar |
+        | one | two |
+        @tag
+        | aaa | bbb |
+      """
+    Then there should be parse errors on lines 10 and 17
+
+  Scenario: Multiline keyword descriptions
+    When the following text is parsed:
+      """
+        Feature: Documentation is fun
+          Scenario Outline: With lots of docs
+            We need lots of embedded documentation for some reason 
+            \"\"\" # Not interpreted as a pystring, just plain text
+            Oh hai
+            \"\"\"
+      
+            La la la
+      
+            Examples:
+            | one | two |
+            | foo | bar |
+      
+            \"\"\"
+            Oh Hello
+            \"\"\"
+      
+            # Body of the scenario outline starts below
+            Given <something> 
+            And something <else>
+      
+            # The real examples table
+            Examples: 
+            | something | else |
+            | orange | apple |
+      """
+    Then there should be no parse errors
+
+  Scenario: Scenario Outline with multiple Example groups
+    When the following text is parsed:
+      """
+      Feature: Outline Sample
+      
+        Scenario: I have no steps
+      
+        Scenario Outline: Test state
+          Given <state> without a table
+          Given <other_state> without a table
+      
+          Examples: Rainbow colours
+            | state   | other_state |
+            | missing | passing     |
+            | passing | passing     |
+            | failing | passing     |
+          
+          Examples: Only passing
+            |  state   | other_state |
+            | passing  | passing |
+      """
+    Then there should be no parse errors
+
+  Scenario: Multiple Scenario Outlines with multiline outline steps
+    When the following text is parsed:
+      """
+      Feature: Test
+        Scenario Outline: with step tables
+          Given I have the following fruits in my pantry
+            | name        | quantity |
+            | cucumbers   | 10       |
+            | strawberrys | 5        |
+            | apricots    | 7        |
+      
+          When I eat <number> <fruits> from the pantry
+          Then I should have <left> <fruits> in the pantry
+      
+          Examples:
+            | number | fruits      | left |
+            | 2      | cucumbers   | 8    |
+            | 4      | strawberrys | 1    |
+            | 2      | apricots    | 5    |
+      
+        Scenario Outline: placeholder in a multiline string
+          Given my shopping list
+            \"\"\"
+              Must buy some <fruits>
+            \"\"\"
+          Then my shopping list should equal
+            \"\"\"
+              Must buy some cucumbers
+            \"\"\"
+      
+          Examples:
+            | fruits    |
+            | cucumbers |
+      """
+    Then there should be no parse errors

data/vendor/bundle/ruby/1.8/gems/gherkin-2.9.3/features/pretty_formatter.feature

@@ -0,0 +1,16 @@
+@cucumber-source-available
+Feature: Pretty Formatter
+  In order to have pretty gherkin
+  I want to verify that all prettified cucumber features parse OK
+
+  Scenario: Parse all the features in Cucumber
+    Given I have Cucumber's source code next to Gherkin's
+    And I find all of the .feature files
+    When I send each prettified original through the "pretty" machinery
+    Then the machinery output should be identical to the prettified original
+
+  Scenario: Parse all the features in Cucumber with JSON
+    Given I have Cucumber's source code next to Gherkin's
+    And I find all of the .feature files
+    When I send each prettified original through the "json" machinery
+    Then the machinery output should be identical to the prettified original

data/vendor/bundle/ruby/1.8/gems/gherkin-2.9.3/features/step_definitions/eyeball_steps.rb

@@ -0,0 +1,3 @@
+Given /^they have arrived$/ do |table|
+  puts table.raw
+end

data/vendor/bundle/ruby/1.8/gems/gherkin-2.9.3/features/step_definitions/gherkin_steps.rb

@@ -0,0 +1,29 @@
+Given /^a "(ruby|native)" "([^\"]*)" parser$/ do |ruby_or_native, parser_name|
+  @parser = Gherkin::Parser::Parser.new(@formatter, false, parser_name, ruby_or_native=="ruby")
+end
+
+Given "the following text is parsed:" do |text|
+  @parser.parse(text, "test.feature", 0)
+end
+
+Then "there should be no parse errors" do
+  @formatter.errors.should == []
+end
+
+Then /^there should be a parse error on (line \d+)$/ do |line|
+  @formatter.line(line).should include(:syntax_error, line)
+end
+
+Then /^there should be parse errors on (lines .*)$/ do |lines|
+  lines.each do |line|
+    step "there should be a parse error on line #{line}"
+  end
+end
+
+Transform /^line \d+$/ do |step_arg|
+  tr_line_number(step_arg)
+end
+
+Transform /^lines .*$/ do |step_arg|
+  tr_line_numbers(step_arg)
+end

data/vendor/bundle/ruby/1.8/gems/gherkin-2.9.3/features/step_definitions/json_formatter_steps.rb

@@ -0,0 +1,30 @@
+require 'stringio'
+require 'gherkin/formatter/json_formatter'
+require 'gherkin/listener/formatter_listener'
+
+# Monkey patching so that Hash.to_json has a predictable result.
+class Hash
+  alias orig_keys keys
+  def keys
+    orig_keys.sort
+  end
+end
+
+Given /^a JSON formatter$/ do
+  @out = StringIO.new
+  @formatter = Gherkin::Formatter::JSONFormatter.new(@out)
+end
+
+Then /^the outputted JSON should be:$/ do |expected_json|
+  require 'json'
+  @formatter.done
+  actual_json = @out.string
+  puts actual_json
+  puts JSON.pretty_generate(JSON.parse(actual_json))
+  expected = JSON.parse(expected_json)
+  actual   = JSON.parse(actual_json)
+  actual.should == expected
+end
+
+
+

data/vendor/bundle/ruby/1.8/gems/gherkin-2.9.3/features/step_definitions/json_parser_steps.rb

@@ -0,0 +1,20 @@
+require 'stringio'
+require 'gherkin/formatter/pretty_formatter'
+require 'gherkin/json_parser'
+
+Given /^a PrettyFormatter$/ do
+  @io = StringIO.new
+  @formatter = Gherkin::Formatter::PrettyFormatter.new(@io, true, false)
+end
+
+Given /^a JSON lexer$/ do
+  @json_parser = Gherkin::JSONParser.new(@formatter, @formatter)
+end
+
+Given /^the following JSON is parsed:$/ do |text|
+  @json_parser.parse(JSON.pretty_generate(JSON.parse(text)))
+end
+
+Then /^the outputted text should be:$/ do |expected_text|
+  @io.string.strip.should == expected_text
+end