rspec-gherkin 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8c9bab3b667c903dfa4cf5449becaa7778099a1e
+  data.tar.gz: fe2a11c885696386a5adcc938dde4204fb571266
+SHA512:
+  metadata.gz: c0fda6e78aa39013889fdb409ec4810ecad15e3757952e0661cbccb7e60a04a8149fcebcc56c16d257fc299f9c2cdb6af20b48845e117b06fd26c250f8b8d0f6
+  data.tar.gz: 871433b8d10a664de7be4147d9b4fdf4745508c9eb7aba85834cab997988d93326050cfbffe1bbda8ab946e3c335cf8b2d7601727c6728ea5a272b99ce46db47

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+bundler_stubs
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,3 @@
+-r rspec-gherkin
+--color
+--tag ~feature

data/.travis.yml

@@ -0,0 +1,11 @@
+rvm:
+ - 1.9.2
+ - 1.9.3
+ - ruby-head
+ - rbx-19mode
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+script:
+  bundle exec rspec
+

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1,125 @@
+# RSpec Gherkin [![Build Status][travis-img-url]][travis-url]
+
+[travis-img-url]: https://travis-ci.org/sheerun/rspec-gherkin.png
+[travis-url]: https://travis-ci.org/rspec-gherkin
+
+Different approach to Gherkin features in RSpec. It is based on two premises:
+
+1. Requirements are written by **business** in semi-formal, human-readable Gherkin.
+2. Automation of those is done by **programmers** in formal, machine-readable RSpec.
+
+It resigns from the idea of regexp-parseable Cucumber features. As Uncle Bob [noticed in his article](http://blog.8thlight.com/uncle-bob/2013/09/26/AT-FAIL.html):
+
+> I mean, the point was to get the *business* to provide a formal specification of the system so that the *programmers* could understand it. What in the name of heaven is the point of having the *programmers* write the formal specification so that the *programmers* can then understand it?
+
+## Installation
+
+Add this gem to `test` group in `Gemfile`:
+
+```ruby
+group :test do
+  gem 'rspec-gherkin'
+end
+```
+
+In your `spec_helper` include environment and `rspec-gherkin`:
+
+```ruby
+require File.expand_path('../../config/environment', __FILE__)
+require 'capybara/rails' # only for Rails
+require 'rspec-gherkin'
+```
+
+## Basic Usage
+
+1. Put your requirements in `features` directory under application's root path:
+
+    ```
+    features/manage_articles.feature
+    ```
+
+    ```
+    Feature: Manage Articles
+      In order to make a blog
+      As an author
+      I want to create and manage articles
+
+      Scenario: Articles List
+        Given I have articles titled Pizza, Breadsticks
+        When I go to the list of articles
+        Then I should see "Pizza"
+        And I should see "Breadsticks"
+    ```
+
+2. Put specs for for those features in `spec/features` directory:
+
+    ```
+    spec/features/manage_articles_spec.rb
+    ```
+
+    ```ruby
+    require 'spec_helper'
+
+    feature 'Manage Articles' do
+      scenario 'Articles List' do
+        create(:article, :title => "Pizza")
+        create(:article, :title => "Breadsticks")
+        visit articles_path
+        expect(page).to have_content 'Pizza'
+        expect(page).to have_content 'Breadsticks'
+      end
+    end
+    ```
+
+In specs you can use Capybara, FactoryGirl, helpers, and whatever you want.
+
+You can run both `*.feature` files and `_spec.rb` spec as usual.
+
+```sh
+# Run all features
+rspec features
+rspec spec/features
+rspec --tag feature
+
+# Run individual features
+rspec features/manage_articles.feature
+rspec spec/features/manage_articles_spec.rb
+```
+
+You may want to add `--tag ~feature` to your `.rspec` file to not run
+slow features specs by default.
+
+## Configuration
+
+By default features in `features` directory are mapped to specs in `spec/features`.
+
+Also each feature has an additional metadata: `{ :type => :feature, :feature => true }`.
+
+You can change this by adding configuration options in `spec_helper`. Here are the defaults:
+
+```ruby
+RSpec.configure do |config|
+  config.feature_mapping = {
+    :feature => 'features/**/*.feature',
+    :spec => 'spec/features/**/*_spec.rb'
+  }
+  config.feature_metadata = { :type => :feature, :feature => :true }
+end
+```
+
+## FAQ
+
+*How it differs from `capybara/rspec`*
+
+It is an extension to it. `rspec-gherin` among others:
+
+1. Focuses on strong mapping between features and specs for them
+2. Allows for running feature files directly
+3. Notifies if any features/scenarios have pending specs
+4. Notifies if any specs have no matching features/scenarios
+5. Marks specs as pending if matchinf feature has been tagged as `@updated`
+6. Provides RSpec messages, indicating location of feature and spec files.
+
+## License
+
+This gem is MIT-licensed. You are awesome.

data/Rakefile

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

data/features/no_scenario.feature

@@ -0,0 +1 @@
+Feature: Missing scenario

data/features/scenario_outline.feature

@@ -0,0 +1,10 @@
+Feature: using scenario outlines
+  Scenario Outline: a simple outline
+    Given there is a monster with <hp> hitpoints
+    When I attack the monster and do <damage> points damage
+    Then the monster should be <state>
+
+    Examples:
+      | hp     | damage | state   | happy |
+      | 10.0   | 13     | dead    | false |
+      | 8.0    | 5      | alive   | true  |

data/features/simple_feature.feature

@@ -0,0 +1,16 @@
+Feature: A simple feature
+  Background:
+    Given we live in monster world
+  Scenario: A simple scenario
+    Given there is a monster
+    When I attack it
+    Then it should die
+  Scenario: Raising error
+    When Running this scenario
+    Then Error should be raisen
+  Scenario: Diferant metadata type
+    When Running this scenario
+    Then Type of this scenario should be :controller
+  Scenario: Custom metadata tag
+    When Running this scenario
+    Then Metadata should contain :custom key with 'foobar' value

data/features/updated_feature.feature

@@ -0,0 +1,12 @@
+@updated
+Feature: Updated feature
+  Scenario: Attack a monster with cool tag
+    Given there is a monster
+    When I attack it
+    Then it should die
+
+  Scenario: Attack another monster
+    Given there is a strong monster
+    When I attack it
+    And I attack it
+    Then it should die

data/features/updated_scenario.feature

@@ -0,0 +1,12 @@
+Feature: Feature with updated scenario
+  @updated
+  Scenario: Updated scenario
+    Given there is a monster
+    When I attack it
+    Then it should die
+
+  Scenario: Attack another monster
+    Given there is a strong monster
+    When I attack it
+    And I attack it
+    Then it should die

data/lib/rspec-gherkin/builder.rb

@@ -0,0 +1,157 @@
+require "gherkin"
+
+module RSpecGherkin
+  class Builder
+    module Tags
+      def tags
+        @raw.tags.map { |tag| tag.name.sub(/^@/, '') }
+      end
+
+      def tags_hash
+        Hash[tags.map { |t| [t.to_sym, true] }]
+      end
+
+      def metadata_hash
+        tags_hash
+      end
+    end
+
+    module Name
+      def name
+        @raw.name
+      end
+    end
+
+    class Feature
+      include Tags
+      include Name
+
+      attr_reader :scenarios, :backgrounds
+      attr_accessor :feature_tag
+
+      def initialize(raw)
+        @raw = raw
+        @scenarios = []
+        @backgrounds = []
+      end
+
+      def line
+        @raw.line
+      end
+    end
+
+    class Background
+      def initialize(raw)
+        @raw = raw
+      end
+    end
+
+    class Scenario
+      include Tags
+      include Name
+
+      attr_accessor :arguments
+
+      def initialize(raw)
+        @raw = raw
+        @arguments = []
+      end
+    end
+
+    class Step < Struct.new(:description, :extra_args, :line)
+      # 1.9.2 support hack
+      def split(*args)
+        self.to_s.split(*args)
+      end
+
+      def to_s
+        description
+      end
+    end
+
+    attr_reader :features
+
+    class << self
+      def build(feature_file)
+        RSpecGherkin::Builder.new.tap do |builder|
+          parser = Gherkin::Parser::Parser.new(builder, true)
+          parser.parse(File.read(feature_file), feature_file, 0)
+        end
+      end
+    end
+
+    def initialize
+      @features = []
+    end
+
+    def background(background)
+      @current_step_context = Background.new(background)
+      @current_feature.backgrounds << @current_step_context
+    end
+
+    def feature(feature)
+      @current_feature = Feature.new(feature)
+      @features << @current_feature
+    end
+
+    def scenario(scenario)
+      @current_step_context = Scenario.new(scenario)
+      @current_feature.scenarios << @current_step_context
+    end
+
+    def scenario_outline(outline)
+      @current_scenario_template = outline
+    end
+
+    def examples(examples)
+      rows_to_array(examples.rows).each do |arguments|
+        scenario = Scenario.new(@current_scenario_template)
+        scenario.arguments = arguments.map do |argument|
+          if numeric?(argument)
+            integer?(argument) ? argument.to_i : argument.to_f
+          elsif boolean?(argument)
+            to_bool(argument)
+          else
+            argument
+          end
+        end
+
+        @current_feature.scenarios << scenario
+      end
+    end
+
+    def step(*)
+    end
+
+    def uri(*)
+    end
+
+    def eof
+    end
+
+    private
+
+    def integer?(string)
+      return true if string =~ /^\d+$/
+    end
+
+    def numeric?(string)
+      return true if string =~ /^\d+$/
+      true if Float(string) rescue false
+    end
+
+    def boolean?(string)
+      string =~ (/(true|t|yes|y)$/i) ||
+      string =~ (/(false|f|no|n)$/i)
+    end
+
+    def to_bool(string)
+      return true if string =~ (/(true|t|yes|y|1)$/i)
+      return false if string =~ (/(false|f|no|n|0)$/i)
+    end
+
+    def rows_to_array(rows)
+      rows.map { |row| row.cells(&:value) }.drop(1)
+    end
+  end
+end

data/lib/rspec-gherkin/rspec-dsl.rb

@@ -0,0 +1,112 @@
+require "capybara/rspec" rescue nil
+
+class << self
+  def feature(name = nil, new_metadata = {}, &block)
+    raise ArgumentError.new("requires a name") if name.nil?
+
+    new_metadata = ::RSpec.configuration.feature_metadata.merge(new_metadata)
+    matching_feature = find_feature(name)
+
+    if matching_feature
+      if matching_feature.tags.include?('updated')
+        pending_feature(name, new_metadata, block.source_location, [
+          "Feature has been marked as updated",
+          "Update specs for this feature and remove the @updated tag",
+          "Feature file: '#{feature_path(block.source_location)}'"
+        ])
+      else
+        describe("Feature: #{name}", new_metadata.merge(:current_feature => matching_feature), &block)
+      end
+    else
+      pending_feature(name, new_metadata, block.source_location,
+        "No such feature in '#{feature_path(block.source_location)}'"
+      )
+    end
+  end
+
+  private
+
+  def find_feature(name)
+    RSpecGherkin.features.find do |feature|
+      feature.name == name
+    end
+  end
+
+  def feature_path(spec_location)
+    RSpecGherkin.spec_to_feature(spec_location.first, false)
+  end
+
+  def pending_feature(name, new_metadata, spec_location, reason)
+    describe "Feature: #{name}", new_metadata do
+      it do
+        example.metadata.merge!(
+          file_path: spec_location[0],
+          line_number: spec_location[1]
+        )
+
+        pending [*reason].join("\n    #  ")
+      end
+    end
+  end
+end
+
+module RSpecGherkin
+  module DSL
+    module Rspec
+      def background(&block)
+        before(:each, &block)
+      end
+
+      def scenario(name = nil, new_metadata = {}, &block)
+        raise ArgumentError.new("requires a name") if name.nil?
+
+        matching_scenario = find_scenario(self.metadata[:current_feature], name)
+
+        if matching_scenario
+          if matching_scenario.tags.include?('updated')
+            pending_scenario(name, new_metadata, block.source_location, [
+              "Scenario has been marked as updated",
+              "Update specs for this scenario and remove the @updated tag",
+              "Feature file: '#{feature_path(block.source_location)}'"
+            ])
+          elsif matching_scenario.arguments
+            specify "Scenario: #{name}", new_metadata do
+              instance_exec(*matching_scenario.arguments, &block)
+            end
+          else
+            specify("Scenario: #{name}", new_metadata, &block)
+          end
+        else
+          pending_scenario(name, new_metadata, block.source_location,
+            "No such scenario in '#{feature_path(block.source_location)}'"
+          )
+        end
+      end
+
+      private
+
+      def find_scenario(feature, name)
+        feature.scenarios.find do |scenario|
+          scenario.name == name
+        end
+      end
+
+      def feature_path(spec_location)
+        RSpecGherkin.spec_to_feature(spec_location.first, false)
+      end
+
+      def pending_scenario(name, new_metadata, spec_location, reason)
+        specify name, new_metadata do
+          example.metadata.merge!(
+            file_path: spec_location[0],
+            line_number: spec_location[1]
+          )
+          example.metadata[:example_group].merge!(
+            description_args: ["Scenario:"]
+          )
+          pending [*reason].join("\n    #  ")
+        end
+      end
+    end
+  end
+end

data/lib/rspec-gherkin/rspec-loader.rb

@@ -0,0 +1,56 @@
+require "rspec-gherkin"
+require "rspec"
+
+module RSpecGherkin
+  module RSpec
+    module Loader
+      def load(*paths, &block)
+
+        # Override feature exclusion filter if running features
+        if paths.any? { |path| RSpecGherkin.feature?(path) }
+          ::RSpec.configuration.filter_manager.exclusions.reject! do |key, value|
+            key == :feature || (key == :type && value == 'feature')
+          end
+        end
+
+        paths = paths.map do |path|
+          if RSpecGherkin.feature?(path)
+            spec_path = RSpecGherkin.feature_to_spec(path)
+            if File.exist?(spec_path)
+              spec_path
+            else
+              RSpecGherkin::Builder.build(path).features.each do |feature|
+                ::RSpec::Core::ExampleGroup.describe(
+                  "Feature: #{feature.name}", :type => :feature, :feature => true
+                ) do
+                  it do
+                    example.metadata[:file_path] = spec_path
+                    example.metadata[:line_number] = 1
+                    pending('Not yet implemented')
+                  end
+                end.register
+              end
+
+              nil
+            end
+          else
+            path
+          end
+        end.compact
+
+        # Load needed features to RSpecGherkin.features array
+        paths.each do |path|
+          if RSpecGherkin.feature_spec?(path)
+            feature_path = RSpecGherkin.spec_to_feature(path)
+
+            if File.exists?(feature_path)
+              RSpecGherkin.features += RSpecGherkin::Builder.build(feature_path).features
+            end
+          end
+        end
+
+        super(*paths, &block) if paths.size > 0
+      end
+    end
+  end
+end

data/lib/rspec-gherkin/version.rb

@@ -0,0 +1,3 @@
+module RSpecGherkin
+  VERSION = "0.1.0"
+end

data/lib/rspec-gherkin.rb

@@ -0,0 +1,68 @@
+require "rspec-gherkin/builder"
+require "rspec-gherkin/rspec-dsl"
+require "rspec-gherkin/rspec-loader"
+require "rspec-gherkin/version"
+
+module RSpecGherkin extend self
+
+  class << self
+    attr_accessor :features
+  end
+
+  class Pending < StandardError; end
+  class Malformed < StandardError; end
+  class Ambiguous < StandardError; end
+
+  def feature?(path)
+    !!path.match(mask_to_pattern(feature_mask))
+  end
+
+  def feature_spec?(path)
+    !!path.match(mask_to_pattern(spec_mask))
+  end
+
+  def feature_to_spec(path, prefix = true)
+    path = path.match(mask_to_pattern(feature_mask))[0] unless prefix
+    path.sub(mask_to_pattern(feature_mask), mask_to_replacement(spec_mask))
+  end
+
+  def spec_to_feature(path, prefix = true)
+    path = path.match(mask_to_pattern(spec_mask))[0] unless prefix
+    path.sub(mask_to_pattern(spec_mask), mask_to_replacement(feature_mask))
+  end
+
+  protected
+
+  def spec_mask
+    ::RSpec.configuration.feature_mapping[:spec]
+  end
+
+  def feature_mask
+    ::RSpec.configuration.feature_mapping[:feature]
+  end
+
+  def mask_to_pattern(mask)
+    Regexp.new("#{Regexp.escape(mask).sub("\\*\\*/\\*", '(.+)')}$")
+  end
+
+  def mask_to_replacement(mask)
+    "#{mask.sub('**/*'){ '\\1' }}"
+  end
+
+end
+
+RSpecGherkin.features = []
+
+::RSpec.configure do |config|
+  config.extend RSpecGherkin::DSL::Rspec
+  config.pattern << ",**/*.feature"
+  config.add_setting :feature_mapping
+  config.add_setting :feature_metadata
+  config.feature_mapping = {
+    :feature => 'features/**/*.feature',
+    :spec => 'spec/features/**/*_spec.rb'
+  }
+  config.feature_metadata = { :type => :feature, :feature => :true }
+end
+
+::RSpec::Core::Configuration.send(:include, RSpecGherkin::RSpec::Loader)

data/rspec-gherkin.gemspec

@@ -0,0 +1,22 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+require "rspec-gherkin/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rspec-gherkin"
+  s.version     = RSpecGherkin::VERSION
+  s.authors     = ["Adam Stankiewicz"]
+  s.email       = ["sheerun@sher.pl"]
+  s.homepage    = ""
+  s.summary     = %q{Different approach to Gherkin features in RSpec}
+  s.description = %q{Different approach to Gherkin features in RSpec}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "rspec", "~> 2.0"
+  s.add_runtime_dependency "gherkin", ">= 2.5"
+  s.add_development_dependency "rake"
+end

data/spec/builder_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe RSpecGherkin::Builder do
+  context "with scenario outlines" do
+    let(:feature_file) { File.expand_path('../features/scenario_outline.feature', File.dirname(__FILE__)) }
+    let(:builder) { RSpecGherkin::Builder.build(feature_file) }
+    let(:feature) { builder.features.first }
+
+    it "extracts scenario" do
+      feature.scenarios.map(&:name).should eq([
+        'a simple outline',
+        'a simple outline'
+      ])
+    end
+
+    it "add additional arguments to scenarios" do
+      feature.scenarios[0].arguments.should eq([ 10.0, 13, "dead", false ])
+      feature.scenarios[1].arguments.should eq([ 8.0, 5, "alive", true ])
+    end
+  end
+end

data/spec/features/no_feature_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+feature 'Missing feature' do
+  scenario 'This should never be executed' do
+    raise 'Scenario in spec with missing feature should not be executed'
+  end
+end

data/spec/features/no_scenario_spec.rb

@@ -0,0 +1,5 @@
+feature 'Missing scenario' do
+  scenario 'Non-existing scenario' do
+    expect(1).to eq(1)
+  end
+end

data/spec/features/scenario_outline_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+feature 'using scenario outlines' do
+  scenario 'a simple outline' do |hp, damage, state, happy|
+    expect(hp).to be_a(Float)
+    expect(damage).to be_a(Fixnum)
+    expect(state).to be_a(String)
+    expect([true, false]).to include happy
+  end
+end

data/spec/features/simple_feature_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+feature 'A simple feature' do
+  # ensure background is executed as before(:each)
+  background do
+    @number ||= 41
+    @number += 1 
+  end
+
+  scenario 'A simple scenario' do
+    expect(@number).to eq(42)
+  end
+
+  scenario 'Raising error' do
+    raise ArgumentError.new("Your argument is invalid!")
+  end
+
+  scenario 'Diferant metadata type', :type => :controller, :feature => false do
+    expect(example.metadata[:type]).to eq(:controller)
+    expect(example.metadata[:feature]).to eq(false)
+  end
+
+  scenario 'Custom metadata tag', :custom => "foobar" do
+    expect(example.metadata[:custom]).to eq("foobar")
+  end
+end

data/spec/features/updated_feature_spec.rb

@@ -0,0 +1,11 @@
+# This feature should be marked as pending
+# because it is tagged as @updated in gherkin
+feature 'Updated feature' do
+  scenario 'Attack a monster with cool tag' do
+    expect(1).to eq(1)
+  end
+
+  scenario 'Attack another monster' do
+    expect(1).to eq(1)
+  end
+end

data/spec/features/updated_scenario_spec.rb

@@ -0,0 +1,11 @@
+# This feature should be marked as pending
+# because it is tagged as @updated in gherkin
+feature 'Feature with updated scenario' do
+  scenario 'Updated scenario' do
+    expect(1).to eq(1)
+  end
+
+  scenario 'Attack another monster' do
+    expect(1).to eq(1)
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe 'The CLI', :type => :integration do
+  context 'runing features from features directory' do
+    it 'ignores --tag ~feature flag when running features' do
+      expect(%x(rspec features --tag ~feature 2>&1)).
+        to include('9 examples, 1 failure, 3 pending')
+    end
+
+    it 'ignores --tag ~type:feature flag when running features' do
+      expect(%x(rspec features --tag ~type:feature 2>&1)).
+        to include('9 examples, 1 failure, 3 pending')
+    end
+  end
+
+  context 'runing features specs on their own' do
+    before(:all) do
+      @result = %x(rspec --tag feature --format documentation 2>&1)
+    end
+
+    it 'passes all specs' do
+      expect(@result).to include('9 examples, 1 failure, 4 pending')
+    end
+
+    it 'prepends features with "Feature: " prefix' do
+      expect(@result).to include('Feature: A simple feature')
+    end
+
+    it 'prepends scenarios with "Scenario: " prefix' do
+      expect(@result).to include('Scenario: A simple scenario')
+    end
+
+    context 'non-existing scenario' do
+      it 'shows name of non-existing scenario' do
+        expect(@result).to include(
+          "Scenario: Non-existing scenario"
+        )
+      end
+
+      it 'shows that spec implements non-existing scenario' do
+        expect(@result).to include(
+          "No such scenario in 'features/no_scenario.feature'"
+        )
+      end
+
+      it 'shows line number where missing scenario is mentioned' do
+        expect(@result).to include(
+          "./spec/features/no_scenario_spec.rb:2"
+        )
+      end
+    end
+
+    context 'non-existing feature' do
+      it 'shows name of non-existing feature' do
+        expect(@result).to include(
+          "Feature: Missing feature"
+        )
+      end
+
+      it 'shows that spec implements non-existing feature' do
+        expect(@result).to include(
+          "No such feature in 'features/no_feature.feature'"
+        )
+      end
+
+      it 'shows line number where missing scenario is mentioned' do
+        expect(@result).to include(
+          "./spec/features/no_feature_spec.rb:3"
+        )
+      end
+    end
+
+    context 'updated features and scenarios' do
+      it 'recognizes and notifies when feature is marked as @updated' do
+        expect(@result).to include(
+          'Feature has been marked as updated'
+        )
+      end
+
+      it 'recognizes and notifies when scenario is marked as @updated' do
+        expect(@result).to include(
+          'Scenario has been marked as updated'
+        )
+      end
+    end
+  end
+
+  # it "shows the correct description" do
+  #   @result.should include('A simple feature')
+  #   @result.should include('is a simple feature')
+  # end
+
+  # it "prints out failures and successes" do
+  #   @result.should include('35 examples, 3 failures, 5 pending')
+  # end
+
+  # it "includes features in backtraces" do
+  #   @result.should include('examples/errors.feature:5:in `raise error')
+  # end
+
+  # it "includes the right step name when steps call steps" do
+  #   @result.should include("No such step: 'this is an unimplemented step'")
+  # end
+end

data/spec/rspec-gherkin_spec.rb

@@ -0,0 +1,56 @@
+describe RSpecGherkin do
+  let(:feature_path) { '/project/features/awesome-def_file.feature' }
+  let(:spec_path) { '/project/spec/features/awesome-def_file_spec.rb' }
+
+  let(:short_feature_path) { 'features/awesome-def_file.feature' }
+  let(:short_spec_path) { 'spec/features/awesome-def_file_spec.rb' }
+
+  context '#feature?' do
+    it 'recognizes if path is feature path' do
+      expect(RSpecGherkin.feature?(feature_path)).to eq(true)
+    end
+
+    it 'recognizes if path is not feature path' do
+      expect(RSpecGherkin.feature?(spec_path)).to eq(false)
+    end
+  end
+
+  context '#feature_spec?' do
+    it 'recognizes if path is spec path' do
+      expect(RSpecGherkin.feature_spec?(spec_path)).to eq(true)
+    end
+
+    it 'recognizes if path is not spec path' do
+      expect(RSpecGherkin.feature_spec?(feature_path)).to eq(false)
+    end
+  end
+
+  context '#feature_to_spec' do
+    it 'properly translates feature file to spec file' do
+      expect(RSpecGherkin.feature_to_spec(feature_path)).to eq(spec_path)
+    end
+
+    it 'excludes prefix when requested' do
+      expect(RSpecGherkin.feature_to_spec(feature_path, false)).
+        to eq(short_spec_path)
+    end
+  end
+
+  context '#spec_to_feature' do
+    it 'properly translates spec file to feature file' do
+      expect(RSpecGherkin.spec_to_feature(spec_path)).
+        to eq(feature_path)
+    end
+
+    it 'excludes prefix when requested' do
+      expect(RSpecGherkin.spec_to_feature(spec_path, false)).
+        to eq(short_feature_path)
+    end
+  end
+
+  specify '#spec_to_feature and #feature_to_spec should be idempotent' do
+    p1 = RSpecGherkin.feature_to_spec(RSpecGherkin.spec_to_feature(spec_path))
+    p2 = RSpecGherkin.feature_to_spec(feature_path)
+    expect(p1).to eq(p2)
+  end
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: rspec-gherkin
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adam Stankiewicz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: gherkin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Different approach to Gherkin features in RSpec
+email:
+- sheerun@sher.pl
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- features/no_scenario.feature
+- features/scenario_outline.feature
+- features/simple_feature.feature
+- features/updated_feature.feature
+- features/updated_scenario.feature
+- lib/rspec-gherkin.rb
+- lib/rspec-gherkin/builder.rb
+- lib/rspec-gherkin/rspec-dsl.rb
+- lib/rspec-gherkin/rspec-loader.rb
+- lib/rspec-gherkin/version.rb
+- rspec-gherkin.gemspec
+- spec/builder_spec.rb
+- spec/features/no_feature_spec.rb
+- spec/features/no_scenario_spec.rb
+- spec/features/scenario_outline_spec.rb
+- spec/features/simple_feature_spec.rb
+- spec/features/updated_feature_spec.rb
+- spec/features/updated_scenario_spec.rb
+- spec/integration_spec.rb
+- spec/rspec-gherkin_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Different approach to Gherkin features in RSpec
+test_files:
+- features/no_scenario.feature
+- features/scenario_outline.feature
+- features/simple_feature.feature
+- features/updated_feature.feature
+- features/updated_scenario.feature
+- spec/builder_spec.rb
+- spec/features/no_feature_spec.rb
+- spec/features/no_scenario_spec.rb
+- spec/features/scenario_outline_spec.rb
+- spec/features/simple_feature_spec.rb
+- spec/features/updated_feature_spec.rb
+- spec/features/updated_scenario_spec.rb
+- spec/integration_spec.rb
+- spec/rspec-gherkin_spec.rb
+- spec/spec_helper.rb
+has_rdoc: