cucumber-the 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,9 @@
+rvm:
+  - 1.8.7
+  - 1.9.3
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+
+script: bundle exec rspec spec && bundle exec cucumber

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Magnus Bergmark
+
+MIT License
+
+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/README.md

@@ -0,0 +1,100 @@
+# Cucumber::The
+[![Build Status](https://secure.travis-ci.org/Mange/cucumber-the.png)](http://travis-ci.org/Mange/cucumber-the)
+
+Adds quick access to instances to help you write more fluid steps.
+
+```ruby
+Given 'a published post' do
+  The[:post] = FactoryGirl.create :post, :published
+end
+
+Given 'I publish a post' do
+  The.post = FactoryGirl.create :post, :published, user: The(:logged_in_user)
+end
+
+When 'I go to the post' do
+  visit post_path The.post
+end
+
+Then 'I should see the post title' do
+  page.should have_content The[:post].title
+end
+```
+
+Note that this gem does not generate anything for you, it's up to you to use this to write your own steps in your own style.
+
+## Why?
+
+It's an eyesore to see scenarios like this:
+
+```gherkin
+Scenario: Displaying post tags
+  Given a post titled "10 things you can do with a broken dishwasher"
+  And that the post "10 things you can do with a broken dishwasher" has the tags "topten" and "hackery"
+  When I go to the post "10 things you can do with a broken dishwasher"
+  Then I should see "topten" and "hackery"
+```
+
+It reads a lot better like this:
+
+```gherkin
+Scenario: Displaying post tags
+  Given a post titled "10 things you can do with a broken dishwasher"
+  And that the post has the tags "topten" and "hackery"
+  When I go to the post
+  Then I should see the tags
+```
+
+Note how we can say "the post" and "the tag" instead of referring to the raw data in them. Also note how the second scenario is easier to extend with additional logic, for example:
+
+```ruby
+Then 'I should see the tags' do
+  The.tags.each do |tag|
+    page.should have_css('.tag', text: tag.name)
+  end
+end
+```
+
+## Why not just variables?
+
+You can implement this yourself by using instance variables, but it has one major drawback:
+
+Every time you want to read the variable, you'll need to check that it is set and fail otherwise. If you don't you'll get `NoMethodError on NilClass` further down the stack, making for a very bad experience for the user.
+
+At that point, you start wrapping these up inside a method and bam, you've implemented this gem. If you don't want the extra dependencies, skip this gem and implement it yourself. If you want to save some time, just use this gem instead of reinventing the wheel.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cucumber-the', require: false, group: :test
+
+And then execute:
+
+    $ bundle
+
+Then, `require 'cucumber-the'` inside `features/support/env.rb` (or a similar one that you control).
+
+## Documentation
+
+You can [read the documentation](https://www.relishapp.com/mange/cucumber-the/) using [Relish](https://www.relishapp.com).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write tests
+4. Implement feature
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request
+
+## Ruby versions
+
+This gem supports the following versions of Ruby:
+
+  * Ruby 1.8.7
+  * Ruby 1.9.3
+  * JRuby (1.8 mode)
+  * JRuby (1.9 mode)
+  * Rubinius (1.8 mode)
+  * Rubinius (1.9 mode)

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/cucumber-the.gemspec

@@ -0,0 +1,21 @@
+# Encoding: utf-8
+require File.expand_path('../lib/cucumber-the/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Magnus Bergmark"]
+  gem.email         = ["magnus.bergmark@gmail.com"]
+  gem.description   = %q{Adds quick access to instances to help you write more fluid steps.}
+  gem.summary       = %q{Adds quick access to instances to help you write more fluid steps.}
+  gem.homepage      = ""
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "cucumber-the"
+  gem.require_paths = ["lib"]
+  gem.version       = Cucumber::The::VERSION
+
+  gem.add_dependency 'cucumber', '~> 1.2'
+
+  gem.add_development_dependency 'rspec'
+end

data/features/cucumber_factory.feature

@@ -0,0 +1,40 @@
+Feature: Cucumber factory
+  In order to test cucumber-the in an easy way
+  As a developer
+  I want to dynamically generate cucumber features and run them
+
+  Scenario: Creating passing feature
+    Given a feature "tautology.feature" with the following scenario:
+      """
+      Scenario: 1 is 1
+        Then 1 should equal 1
+      """
+    And step definitions:
+      """
+      Then /^(\d+) should equal (\d+)$/ do |a, b|
+        fail unless a == b
+      end
+      """
+    When I run the features
+    Then all scenarios should pass
+
+  Scenario: Creating failing feature
+    Given a feature "lies.feature" with the following scenario:
+      """
+      Scenario: Big brother
+        Given slavery
+        Then that is freedom
+      """
+    And step definitions:
+      """
+      Given 'slavery' do
+        @slavery = true
+      end
+
+      Then 'that is freedom' do
+        fail if @slavery
+      end
+      """
+    When I run the features
+    Then a scenario should fail
+

data/features/message_access.feature

@@ -0,0 +1,23 @@
+Feature: Message access
+  Some people prefer `The.post` over `The[:post]` and we want to support this.
+
+  Scenario: Referrings to items using messages
+    Given a feature "calculator.feature" with the following scenario:
+      """
+      Scenario: Addition
+        When I add 2 and 2
+        Then the sum should be 4
+      """
+    And step definitions:
+      """
+      When 'I add 2 and 2' do
+        The.sum = 2 + 2
+      end
+
+      Then 'the sum should be 4' do
+        fail if The.sum != 4
+      end
+      """
+    And the gem is loaded
+    When I run the features
+    Then all scenarios should pass

data/features/readme.md

@@ -0,0 +1,50 @@
+# Cucumber::The
+
+`Cucumber::The` adds quick access to instances to help you write more fluid steps.
+
+## Why?
+
+It's an eyesore to see scenarios like this:
+
+```gherkin
+Scenario: Displaying post tags
+  Given a post titled "10 things you can do with a broken dishwasher"
+  And that the post "10 things you can do with a broken dishwasher" has the tags "topten" and "hackery"
+  When I go to the post "10 things you can do with a broken dishwasher"
+  Then I should see "topten" and "hackery"
+```
+
+It reads a lot better like this:
+
+```gherkin
+Scenario: Displaying post tags
+  Given a post titled "10 things you can do with a broken dishwasher"
+  And that the post has the tags "topten" and "hackery"
+  When I go to the post
+  Then I should see the tags
+```
+
+Note how we can say "the post" and "the tag" instead of referring to the raw data in them. Also note how the second scenario is easier to extend with additional logic, for example:
+
+```ruby
+Then 'I should see the tags' do
+  The.tags.each do |tag|
+    page.should have_css('.tag', text: tag.name)
+  end
+end
+```
+
+## How?
+
+Take a peek at the features to see how to use this project.
+
+## Ruby versions
+
+This gem supports the following versions of Ruby:
+
+  * Ruby 1.8.7
+  * Ruby 1.9.3
+  * JRuby (1.8 mode)
+  * JRuby (1.9 mode)
+  * Rubinius (1.8 mode)
+  * Rubinius (1.9 mode)

data/features/simple_usage.feature

@@ -0,0 +1,122 @@
+Feature: Simple usage
+  In the most simple case, just use `The` as a getter and setter inside the tests.
+
+  Scenario: Referring to previously set value
+    Given a feature "calculator.feature" with the following scenario:
+      """
+      Scenario: Addition
+        When I add 2 and 2
+        Then the sum should be 4
+      """
+    And step definitions:
+      """
+      When 'I add 2 and 2' do
+        The[:sum] = 2 + 2
+      end
+
+      Then 'the sum should be 4' do
+        fail if The[:sum] != 4
+      end
+      """
+    And the gem is loaded
+    When I run the features
+    Then all scenarios should pass
+
+  Scenario: Failing on missing values
+    Given a feature "dog.feature" with the following scenario:
+      """
+      Scenario: Humping
+        When I hump the leg
+        Then I should be happy
+      """
+    And step definitions:
+      """
+      class Dog
+        def happy?
+          @humped
+        end
+
+        def hump(item)
+          @humped = true
+        end
+      end
+
+      When 'I hump the leg' do
+        @dog = Dog.new
+        @dog.hump The[:leg]
+      end
+
+      Then 'I should be happy' do
+        @dog.happy?
+      end
+      """
+    And the gem is loaded
+    When I run the features
+    Then a scenario should fail with:
+      """
+      Don't know what "the leg" is. Did you forget to assign it and/or run a prerequisite step before this step?
+      """
+
+  Scenario: No pollution between scenarios
+    Given a feature "cat.feature" with the following scenarios:
+      """
+      Background:
+        Given I am a cat
+
+      Scenario: Sleeping
+        When I sleep on a blanket
+        Then I should be as warm as the blanket
+
+      Scenario: 
+        When I pee on the blanket
+        Then I should be smug about it
+      """
+    And step definitions:
+      """
+      class Cat
+        def sleep_on(item)
+          @sleeping_on = item
+        end
+
+        def temperature
+          @sleeping_on.temperature
+        end
+
+        def pee_on(item)
+          item.ruin
+        end
+      end
+
+      class Blanket
+        def temperature() 22 end # Celcius, because standards are nice
+        def ruin() @ruined = true end
+        def ruined?() @ruined end
+      end
+
+      Given 'I am a cat' do
+        @cat = Cat.new
+      end
+
+      When 'I sleep on a blanket' do
+        The[:blanket] = Blanket.new
+        @cat.sleep_on The[:blanket]
+      end
+
+      When 'I pee on the blanket' do
+        @cat.pee_on The[:blanket]
+      end
+
+      Then 'I should be smug about it' do
+        @cat.instance_of?(Cat) # Cats are always smug
+      end
+
+      Then 'I should be as warm as the blanket' do
+        @cat.temperature.should == The[:blanket].temperature
+      end
+      """
+    And the gem is loaded
+    When I run the features
+    Then a scenario should fail with:
+      """
+      Don't know what "the blanket" is.
+      """

data/features/smart_error_messages.feature

@@ -0,0 +1,15 @@
+Feature: Smart error messages
+  Error messages should be clear and easy to understand.
+
+  Background:
+    Given there is a The registry
+
+  Scenario Outline: A simple name
+    Given I try to access <Key> from the registry
+    Then I should get an error containing "<Text>"
+
+  Examples:
+    | Key                | Text                  |
+    | :bar               | the bar               |
+    | :smart_creationist | the smart creationist |
+    | :10_goons          | the 10 goons          |

data/features/step_definitions/error_messages_steps.rb

@@ -0,0 +1,15 @@
+require 'cucumber-the/registry'
+
+Given 'there is a The registry' do
+  @the_registry = Cucumber::The::Registry.new
+end
+
+Given /^I try to access :(\w+) from the registry$/ do |key|
+  @the_key = key.to_sym
+end
+
+Then 'I should get an error containing "$message"' do |message|
+  expect {
+    @the_registry[@the_key]
+  }.to raise_error { |error| error.message.should include message }
+end

data/features/step_definitions/feature_factory_steps.rb

@@ -0,0 +1,36 @@
+Given /^a feature "([^"]+)" with the following scenarios?:$/ do |name, scenario_body|
+  @cucumber_factory.create_feature name, scenario_body
+end
+
+Given 'step definitions:' do |body|
+  @cucumber_factory.create_step_definitions 'all.rb', body
+end
+
+Given 'the gem is loaded' do
+  gempath = File.expand_path '../../../lib', __FILE__
+  @cucumber_factory.create_support 'env.rb', <<-RUBY
+    $LOAD_PATH << #{gempath.inspect}
+    require "cucumber-the"
+  RUBY
+end
+
+When 'I run the features' do
+  @cucumber_factory.run
+end
+
+Then 'all scenarios should pass' do
+  unless @cucumber_factory.status.success?
+    fail "Some scenario did not pass. Output:\n#{@cucumber_factory.output}"
+  end
+end
+
+Then 'a scenario should fail' do
+  if @cucumber_factory.status.success?
+    fail "Scenarios passed, but shouldn't have. Output:\n#{@cucumber_factory.output}"
+  end
+end
+
+Then 'a scenario should fail with:' do |text|
+  fail "Scenarios passed" if @cucumber_factory.status.success?
+  @cucumber_factory.output.should include text
+end

data/features/support/feature_factory.rb

@@ -0,0 +1,83 @@
+require 'pathname'
+require 'tmpdir'
+require 'timeout'
+
+class CucumberFactory
+  def self.use
+    # Travis CI + JRuby have trouble with Dir.mktmpdir. After the resource
+    # block is done Dir tries to remove the tmp directory, but that fails in
+    # that configuration. We ignore these errors, but only after safeguarding
+    # that we're not ignoring errors that was actually caused by our own code.
+    error_in_test = false
+
+    Dir.mktmpdir do |dir|
+      @instance = new dir
+      begin
+        yield
+      rescue Errno::EACCES
+        error_in_test = true
+        raise
+      end
+    end
+  rescue Errno::EACCES => error
+    raise if error_in_test
+    warn "Could not remove temporary directory. Error: #{error}"
+  ensure
+    @instance = nil
+  end
+
+  def self.instance() @instance end
+
+  attr_reader :status, :output
+
+  def initialize(root)
+    @root = Pathname(root)
+    @status = nil
+    @output = "(Have not been run yet)"
+    ensure_structure
+  end
+
+  def create_feature(name, body)
+    @root.join(name).open('w') do |file|
+      file << "Feature: #{clean_name name}\n\n"
+      file << body
+    end
+  end
+
+  def create_step_definitions(name, body)
+    create_file @root.join('step_definitions', name), body
+  end
+
+  def create_support(name, body)
+    create_file @root.join('support', name), body
+  end
+
+  def run
+    IO.popen("#{$0} #{@root.to_s}") do |output|
+      @output = output.read
+    end
+    @status = $?
+  end
+
+  private
+  def clean_name(name)
+    name.gsub(/\.feature$/, '').gsub('_', ' ')
+  end
+
+  def ensure_structure
+    @root.join('support').mkpath
+    @root.join('step_definitions').mkpath
+  end
+
+  def create_file(path, body)
+    path.open('w') { |file| file << body }
+  end
+end
+
+Around do |scenario, block|
+  CucumberFactory.use(&block)
+end
+
+Before do
+  @cucumber_factory = CucumberFactory.instance
+end

data/lib/cucumber-the.rb

@@ -0,0 +1,13 @@
+require "cucumber-the/version"
+require "cucumber-the/registry"
+
+module Cucumber
+  module The
+  end
+end
+
+The = Cucumber::The::Registry.new
+
+Before do
+  The.clear
+end

data/lib/cucumber-the/registry.rb

@@ -0,0 +1,44 @@
+module Cucumber
+  module The
+    class Registry
+      def []=(name, value)
+        thread_registry[name] = value
+      end
+
+      def [](name)
+        thread_registry[name] || raise_error(name)
+      end
+
+      def clear
+        thread_registry.clear
+      end
+
+      def method_missing(name, *args)
+        key_name = name.to_s
+        if key_name.chomp! '='
+          self[key_name.to_sym] = args.first
+        else
+          self[name]
+        end
+      end
+
+      def responds_to(name, *)
+        true
+      end
+
+      private
+      def thread_registry
+        Thread.current[:the_registry] ||= {}
+      end
+
+      def raise_error(name, trace = caller(2))
+        raise RuntimeError, error_message(name), trace
+      end
+
+      def error_message(name)
+        formatted_name = name.to_s.gsub('_', ' ')
+        %(Don't know what "the #{formatted_name}" is. Did you forget to assign it and/or run a prerequisite step before this step?)
+      end
+    end
+  end
+end

data/lib/cucumber-the/version.rb

@@ -0,0 +1,5 @@
+module Cucumber
+  module The
+    VERSION = "1.0.0"
+  end
+end

data/spec/cucumber-the_spec.rb

@@ -0,0 +1,15 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+describe Cucumber::The do
+  it "adds a The constant with a Registry" do
+    The.should be_instance_of(Cucumber::The::Registry)
+  end
+
+  it "adds a Before block that clears the registry on every step" do
+    The.should_receive(:clear)
+
+    before_blocks.should have_at_least(1).block
+    before_blocks.each(&:call)
+  end
+end

data/spec/registry_spec.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+require 'spec_helper'
+
+module Cucumber
+  module The
+    describe Registry do
+      subject(:registry) { Registry.new }
+
+      it "can set and access values using hash notation" do
+        registry[:foo] = "bar"
+        registry[:foo].should == "bar"
+      end
+
+      it "can set and access values using messages" do
+        registry.foo = "bar"
+        registry.foo.should == "bar"
+      end
+
+      it "raises an error when accessing unset values using hash notation" do
+        expect {
+          registry[:elephant]
+        }.to raise_error /the elephant/
+      end
+
+      it "raises an error when accessing unset values using hash notation" do
+        expect {
+          registry.elephant
+        }.to raise_error /the elephant/
+      end
+
+      it "can be cleared" do
+        registry[:foo] = "bar"
+        registry.clear
+        expect { registry[:foo] }.to raise_error
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end
+
+def before_blocks
+  Thread.current[:before_blocks] ||= []
+end
+
+def Before(&block)
+  before_blocks << block
+end
+
+require 'cucumber-the'

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: cucumber-the
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Magnus Bergmark
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cucumber
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Adds quick access to instances to help you write more fluid steps.
+email:
+- magnus.bergmark@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- cucumber-the.gemspec
+- features/cucumber_factory.feature
+- features/message_access.feature
+- features/readme.md
+- features/simple_usage.feature
+- features/smart_error_messages.feature
+- features/step_definitions/error_messages_steps.rb
+- features/step_definitions/feature_factory_steps.rb
+- features/support/feature_factory.rb
+- lib/cucumber-the.rb
+- lib/cucumber-the/registry.rb
+- lib/cucumber-the/version.rb
+- spec/cucumber-the_spec.rb
+- spec/registry_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Adds quick access to instances to help you write more fluid steps.
+test_files:
+- features/cucumber_factory.feature
+- features/message_access.feature
+- features/readme.md
+- features/simple_usage.feature
+- features/smart_error_messages.feature
+- features/step_definitions/error_messages_steps.rb
+- features/step_definitions/feature_factory_steps.rb
+- features/support/feature_factory.rb
+- spec/cucumber-the_spec.rb
+- spec/registry_spec.rb
+- spec/spec_helper.rb
+has_rdoc: