rspec-example_steps 0.2.4 → 3.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8172abd39b0b7013b32df9b0975101cf9f40928b02b3be3a88e4abbcbe3b4f2
+  data.tar.gz: d69aa231297cefa1b45ee6fbbe7bbccc16572117f9bf066f20ad3eed50aaedd1
+SHA512:
+  metadata.gz: 7dc7552ba3b6cc78140942dec817cb323a5721ebf920e344b9f61405bd4ea6e99e380ca4e68665a56a1a9672446150482790f60437d20efc5fe31b9a46c6829b
+  data.tar.gz: a06829b9fb3749a89c50abbd335f13ba3c7c1ff0d555a7bbc78aa980e43fc5cd81d50340fc1f3b0d4cde820636873a69d83b4384d5b65a8dcfbb9ab75335c542

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## 3.1.0
+
+* Removed shared_steps feature

data/Gemfile

@@ -2,4 +2,4 @@ source "http://rubygems.org"
 
 gemspec
 
-gem 'rspec', '2.7.0'
+gem 'rspec', '3.0.0'

data/README.md

@@ -2,133 +2,88 @@
 
 Given/When/Then/And/But steps for RSpec examples
 
-### Example
-
-    require 'rspec/example_steps'
+### Description
 
-    context "Searching" do
-      Steps "Result found" do
-        Given "I am on search page" do
-          page.visit("/search")
-          page.should have_content("Search")
-        end
+This gem brings two major functionality to your `spec/features`
 
-        When "I search something" do
-          page.fill_in('Search', :with => 'John')
-          page.click_button "Go"
-        end
+* Verbosity for rspec documentation formatter.
+* Ability to comment or describe set of actions in example into some step.
 
-        Then "I should see result" do
-          page.should have_content("Result")
-        end
-      end
-    end
-
-### Documentation formatting output:
+### Installation
 
-    Searching
-      User succesfully replaces device
-        Given I am on search page
-        When I search something
-        Then I should see result
+* For rspec v2 use gem **v0.2.x** or rspec2 branch
+* For rspec v3 use gem **v3.x.x** or master branch
 
+```ruby
+gem 'rspec-example_steps'
+```
 
-### Shared steps
+Add to `spec/spec_helper.rb`
 
-Use _shared_steps_ do define block that will be evaluated in the context of example using _include_steps_.
+```ruby
+require 'rspec/example_steps'
+```
 
-Shared _steps_ behavior is simular to shared _example_ but context is example nor example_group.
+### Example
 
-### Example with shared steps
+`spec/features/search_spec.rb`
 
-    shared_steps "login" do
-      When "I go to login page" do
-        page.visit '/login'
-      end
-      When "I put credentials" do
-        page.fill_in 'Login', :with => 'jack@example.com'
-        page.fill_in 'Password', :with => 'password''
-      end
-      Then "I should be logged in" do
-        page.status_code.should == 200
-        page.should have_content("Welcome jack@example.com")
-      end
+```ruby
+context 'Searching' do
+  Steps 'Result found' do
+    Given 'I am on search page' do
+      visit '/search'
+      expect(page).to have_content('Search')
     end
 
-    shared_steps "logout" do
-      page.visit '/logout'
-      page.status_code.should == 200
+    When 'I search something' do
+      fill_in 'Search', with: 'John'
+      click_button 'Go'
     end
 
-    context "user flow"
-      Steps "User updates profile description" do
-        include_steps "login"
-        When "I update profile description" do
-          ...
-        end
-        include_steps "logout"
-      end
-
-      Steps "User updates profile avatar" do
-        include_steps "login"
-        When "I update profile avatar" do
-          ...
-        end
-        include_steps "logout"
-      end
+    Then 'I should see result' do
+      expect(page).to have_content('Result')
     end
+  end
+end
+```
 
-### Passing arguments to shared steps
-
-It's possible to customize shared steps. See example
-
-### Example with shared steps with arguments
-
-    shared_steps "login" do |email, password|
-      When "I go to login page" do
-        page.visit '/login'
-      end
-      When "I put credentials" do
-        page.fill_in 'Login', :with => email
-        page.fill_in 'Password', :with => password
-      end
-    end
+### Documentation formatting output:
 
-    shared_steps "invalid login" do
-      Then "I should see login error" do
-      ...
-      end
-    end
-
-    Steps "User provides wrong email" do
-      include_steps "login", 'jack', 'qwerty'
-      include_steps "invalid login"
-    end
-
-    Steps "User provides wrong password" do
-      include_steps "login", 'jack@example.com', 'bla'
-      include_steps "invalid login"
-    end
+`rspec -fd spec/features/search_spec.rb`
 
+<pre>
+Searching
+  User succesfully replaces device
+    Given I am on search page
+    When I search something
+    Then I should see result
+</pre>
 
 ### Pending steps
 
 Simular to Example :pending behavior:
 
-    Steps "User login" do
-      # just skip block
-      When "I go to login"
+```ruby
+Steps 'User login' do
+  # just skip block
+  When 'I go to login'
 
-      # pass :pending => true option
-      Then "I should see welcome", :pending => true do
-	...
-      end
+  # pass pending: true option
+  Then 'I should see welcome', pending: true do
+  ...
+  end
 
-      # pass :pending => "some pending message"
-      Then "I should see last login IP", :pending => "WIP" do
-	...
-      end
-    end
+  # pass pending: 'some pending message'
+  Then 'I should see last login IP', pending: 'WIP' do
+  ...
+  end
+end
+```
+
+## Authors
+
+* [Andriy Yanko](http://ayanko.github.io)
 
 ## License
 

data/lib/rspec/example_steps.rb

@@ -1,27 +1,25 @@
 require 'rspec/core'
-require 'rspec/core/formatters/base_formatter'
+require 'rspec/core/formatters'
+require 'rspec/core/formatters/console_codes'
 require 'rspec/core/formatters/documentation_formatter'
 require 'rspec/core/example_group'
 require 'rspec/core/reporter'
 require 'rspec/core/world'
 
-require 'rspec/example_steps/base_formatter'
 require 'rspec/example_steps/documentation_formatter'
 require 'rspec/example_steps/example_group'
+require 'rspec/example_steps/notification'
 require 'rspec/example_steps/reporter'
 require 'rspec/example_steps/world'
 
-RSpec::Core::Formatters::BaseFormatter.send          :include, RSpec::ExampleSteps::BaseFormatter
 RSpec::Core::Formatters::DocumentationFormatter.send :include, RSpec::ExampleSteps::DocumentationFormatter
 RSpec::Core::ExampleGroup.send                       :include, RSpec::ExampleSteps::ExampleGroup
 RSpec::Core::Reporter.send                           :include, RSpec::ExampleSteps::Reporter
 RSpec::Core::World.send                              :include, RSpec::ExampleSteps::World
 
-if RSpec::Core::ExampleGroup.singleton_class.respond_to?(:define_example_method, true)
-  RSpec::Core::ExampleGroup.singleton_class.define_example_method :Steps, :with_steps => true
-else
-  RSpec::Core::ExampleGroup.define_example_method :Steps, :with_steps => true
-end
+RSpec::Core::ExampleGroup.define_example_method :Steps, with_steps: true
 
-require 'rspec/example_steps/shared_steps'
-include RSpec::ExampleSteps::SharedSteps
+if formatter = RSpec.world.reporter.find_registered_formatter(RSpec::Core::Formatters::DocumentationFormatter)
+ RSpec.world.reporter.register_listener formatter,
+   :example_started, :example_step_passed, :example_step_pending, :example_step_failed
+end

data/lib/rspec/example_steps/documentation_formatter.rb

@@ -14,55 +14,42 @@ module RSpec
       end
 
       module InstanceMethods
-        def example_started_with_steps(example)
-          example_started_without_steps(example)
+        def example_started(notification)
+        end
+
+        def example_started_with_steps(notification)
+          example_started_without_steps(notification)
 
-          if example.options[:with_steps]
-            full_message = "#{current_indentation}#{example.description}"
-            if respond_to?(:default_color, true)
-              output.puts default_color(full_message)
-            else
-              output.puts white(full_message)
-            end
+          if notification.example.metadata[:with_steps]
+            full_message = "#{current_indentation}#{notification.example.description}"
+            output.puts Core::Formatters::ConsoleCodes.wrap(full_message, :default)
           end
         end
 
-        def example_passed_with_steps(example)
-          example_passed_without_steps(example) unless example.options[:with_steps]
+        def example_passed_with_steps(notification)
+          example_passed_without_steps(notification) unless notification.example.metadata[:with_steps]
         end
 
-        def example_step_passed(example_group, type, message, options)
-          full_message = "#{current_indentation}  #{type.to_s.capitalize} #{message}"
-          if respond_to?(:success_color, true)
-            output.puts success_color(full_message)
-          else
-            output.puts green(full_message)
-          end
+        def example_step_passed(notification)
+          full_message = "#{current_indentation}  #{notification.type.to_s.capitalize} #{notification.message}"
+          output.puts Core::Formatters::ConsoleCodes.wrap(full_message, :success)
         end
 
-        def example_step_pending(example_group, type, message, options)
-          full_message = "#{current_indentation}  #{type.to_s.capitalize} #{message}"
+        def example_step_pending(notification)
+          full_message = "#{current_indentation}  #{notification.type.to_s.capitalize} #{notification.message}"
 
-          if options[:pending] && options[:pending] != true
-            full_message << " (PENDING: #{options[:pending]})"
+          if notification.options[:pending] && notification.options[:pending] != true
+            full_message << " (PENDING: #{notification.options[:pending]})"
           else
             full_message << " (PENDING)"
           end
 
-          if respond_to?(:pending_color, true)
-            output.puts pending_color(full_message)
-          else
-            output.puts yellow(full_message)
-          end
+          output.puts Core::Formatters::ConsoleCodes.wrap(full_message, :pending)
         end
 
-        def example_step_failed(example_group, type, message, options)
-          full_message = "#{current_indentation}  #{type.to_s.capitalize} #{message} (FAILED)"
-          if respond_to?(:failure_color, true)
-            output.puts failure_color(full_message)
-          else
-            output.puts red(full_message)
-          end
+        def example_step_failed(notification)
+          full_message = "#{current_indentation}  #{notification.type.to_s.capitalize} #{notification.message} (FAILED)"
+          output.puts Core::Formatters::ConsoleCodes.wrap(full_message, :failure)
         end
       end
     end

data/lib/rspec/example_steps/example_group.rb

@@ -2,85 +2,30 @@ module RSpec
   module ExampleSteps
     module ExampleGroup
       def include_steps(*args)
-        name = args.shift 
+        name = args.shift
         shared_block = RSpec.world.shared_example_steps[name]
         shared_block or raise ArgumentError, "Could not find shared steps #{name.inspect}"
-        instance_eval_with_args(*args, &shared_block)
+        instance_exec(*args, &shared_block)
       end
 
-      def Given(message, options = {})
-        RSpec.world.reporter.example_step_started(self, :given, message, options)
-        if block_given? && !options[:pending]
-          begin
-            yield
-          rescue Exception => e
-            RSpec.world.reporter.example_step_failed(self, :given, message, options)
-            raise e
-          end
-          RSpec.world.reporter.example_step_passed(self, :given, message, options)
-        else
-          RSpec.world.reporter.example_step_pending(self, :given, message, options)
-        end
+      def Given(message, options = {}, &block)
+        RSpec.world.reporter.process_example_step(self, :given, message, options, &block)
       end
 
-      def When(message, options = {})
-        RSpec.world.reporter.example_step_started(self, :when, message, options)
-        if block_given? && !options[:pending]
-          begin
-            yield
-          rescue Exception => e
-            RSpec.world.reporter.example_step_failed(self, :when, message, options)
-            raise e
-          end
-          RSpec.world.reporter.example_step_passed(self, :when, message, options)
-        else
-          RSpec.world.reporter.example_step_pending(self, :when, message, options)
-        end
+      def When(message, options = {}, &block)
+        RSpec.world.reporter.process_example_step(self, :when, message, options, &block)
       end
 
-      def Then(message, options = {})
-        RSpec.world.reporter.example_step_started(self, :then, message, options)
-        if block_given? && !options[:pending]
-          begin
-            yield
-          rescue Exception => e
-            RSpec.world.reporter.example_step_failed(self, :then, message, options)
-            raise e
-          end
-          RSpec.world.reporter.example_step_passed(self, :then, message, options)
-        else
-          RSpec.world.reporter.example_step_pending(self, :then, message, options)
-        end
+      def Then(message, options = {}, &block)
+        RSpec.world.reporter.process_example_step(self, :then, message, options, &block)
       end
 
-      def And(message, options = {})
-        RSpec.world.reporter.example_step_started(self, :and, message, options)
-        if block_given? && !options[:pending]
-          begin
-            yield
-          rescue Exception => e
-            RSpec.world.reporter.example_step_failed(self, :and, message, options)
-            raise e
-          end
-          RSpec.world.reporter.example_step_passed(self, :and, message, options)
-        else
-          RSpec.world.reporter.example_step_pending(self, :and, message, options)
-        end
+      def And(message, options = {}, &block)
+        RSpec.world.reporter.process_example_step(self, :and, message, options, &block)
       end
 
-      def But(message, options = {})
-        RSpec.world.reporter.example_step_started(self, :but, message, options)
-        if block_given? && !options[:pending]
-          begin
-            yield
-          rescue Exception => e
-            RSpec.world.reporter.example_step_failed(self, :but, message, options)
-            raise e
-          end
-          RSpec.world.reporter.example_step_passed(self, :but, message, options)
-        else
-          RSpec.world.reporter.example_step_pending(self, :but, message, options)
-        end
+      def But(message, options = {}, &block)
+        RSpec.world.reporter.process_example_step(self, :but, message, options, &block)
       end
 
     end

data/lib/rspec/example_steps/notification.rb

@@ -0,0 +1,6 @@
+module RSpec
+  module ExampleSteps
+    class Notification < Struct.new(:example, :type, :message, :options)
+    end
+  end
+end

data/lib/rspec/example_steps/reporter.rb

@@ -1,20 +1,44 @@
 module RSpec
   module ExampleSteps
     module Reporter
+      def process_example_step(example, type, message, options)
+        example_step_started(self, type, message, options)
+
+        if block_given? && !options[:pending]
+          begin
+            yield
+          rescue Exception => e
+            example_step_failed(self, type, message, options)
+            raise e
+          end
+          example_step_passed(self, type, message, options)
+        else
+          example_step_pending(self, type, message, options)
+        end
+      end
+
       def example_step_started(example, type, message, options)
-        notify :example_step_started, example, type, message, options
+        notify :example_step_started, Notification.new(example, type, message, options)
       end
 
       def example_step_passed(example, type, message, options)
-        notify :example_step_passed, example, type, message, options
+        notify :example_step_passed, Notification.new(example, type, message, options)
       end
 
       def example_step_pending(example, type, message, options)
-        notify :example_step_pending, example, type, message, options
+        notify :example_step_pending, Notification.new(example, type, message, options)
       end
 
       def example_step_failed(example, type, message, options)
-        notify :example_step_failed, example, type, message, options
+        notify :example_step_failed, Notification.new(example, type, message, options)
+      end
+
+      def registered_formatters
+        @listeners.values.map(&:to_a).flatten.uniq
+      end
+
+      def find_registered_formatter(klass)
+        registered_formatters.detect { |formatter| formatter.class == klass }
       end
     end
   end

data/rspec-example_steps.gemspec

@@ -2,19 +2,20 @@
 $:.push File.expand_path("../lib", __FILE__)
 
 Gem::Specification.new do |s|
-  s.name        = "rspec-example_steps"
-  s.version     = "0.2.4"
-  s.authors     = ["Andriy Yanko"]
-  s.email       = ["andriy.yanko@gmail.com"]
-  s.homepage    = "https://github.com/railsware/rspec-example_steps"
+  s.name        = 'rspec-example_steps'
+  s.version     = '3.1.0'
+  s.authors     = ['Andriy Yanko']
+  s.email       = ['andriy.yanko@gmail.com']
+  s.homepage    = 'https://github.com/railsware/rspec-example_steps'
   s.summary     = %q{Given/When/Then steps for RSpec examples}
+  s.license     = 'MIT'
 
-  s.rubyforge_project = "rspec_example_steps"
+  s.rubyforge_project = 'rspec_example_steps'
 
   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.require_paths = ['lib']
 
-  s.add_runtime_dependency "rspec-core", ">2.0.0"
+  s.add_runtime_dependency 'rspec-core', '>=3.0.0'
 end

data/spec/example_steps_spec.rb

@@ -25,11 +25,11 @@ describe "example steps" do
         @but = "But value"
       end
 
-      @thing.should  == "Given value"
-      @action.should == "When value"
-      @result.should == "Then value"
-      @and.should == "And value"
-      @but.should == "But value"
+      expect(@thing).to eq("Given value")
+      expect(@action).to eq("When value")
+      expect(@result).to eq("Then value")
+      expect(@and).to eq("And value")
+      expect(@but).to eq("But value")
     end
   end
 
@@ -113,7 +113,7 @@ describe "example steps" do
 
     Steps "When fails" do
       When "action" do
-        (2*2).should == 5
+        expect(2*2).to eq(5)
       end
 
       Then "I should see error" do

data/spec/regression_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'Usual example' do
+  subject { 2 + 2 }
+
+  context 'success' do
+    specify { expect(subject).to eq(4) }
+  end
+
+  context 'failed' do
+    specify { expect(subject).to eq(5) }
+  end
+
+  context 'pending' do
+    it 'should be pending'
+  end
+end

metadata

@@ -1,80 +1,76 @@
 --- !ruby/object:Gem::Specification
 name: rspec-example_steps
 version: !ruby/object:Gem::Version
-  version: 0.2.4
-  prerelease: 
+  version: 3.1.0
 platform: ruby
 authors:
 - Andriy Yanko
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-07-18 00:00:00.000000000 Z
+date: 2021-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 3.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
-description: 
+        version: 3.0.0
+description:
 email:
 - andriy.yanko@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - lib/rspec/example_steps.rb
-- lib/rspec/example_steps/base_formatter.rb
 - lib/rspec/example_steps/documentation_formatter.rb
 - lib/rspec/example_steps/example_group.rb
+- lib/rspec/example_steps/notification.rb
 - lib/rspec/example_steps/reporter.rb
-- lib/rspec/example_steps/shared_steps.rb
 - lib/rspec/example_steps/world.rb
 - rspec-example_steps.gemspec
 - spec/example_steps_spec.rb
-- spec/shared_steps_spec.rb
+- spec/regression_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/railsware/rspec-example_steps
-licenses: []
-post_install_message: 
+licenses:
+- MIT
+metadata: {}
+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: rspec_example_steps
-rubygems_version: 1.8.23
-signing_key: 
-specification_version: 3
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
 summary: Given/When/Then steps for RSpec examples
 test_files:
 - spec/example_steps_spec.rb
-- spec/shared_steps_spec.rb
+- spec/regression_spec.rb
 - spec/spec_helper.rb

data/lib/rspec/example_steps/base_formatter.rb

@@ -1,17 +0,0 @@
-module RSpec
-  module ExampleSteps
-    module BaseFormatter
-      def example_step_started(example, type, message, options)
-      end
-
-      def example_step_passed(example, type, message, options)
-      end
-
-      def example_step_pending(example, type, message, options)
-      end
-
-      def example_step_failed(example, type, message, options)
-      end
-    end
-  end
-end

data/lib/rspec/example_steps/shared_steps.rb

@@ -1,20 +0,0 @@
-module RSpec
-  module ExampleSteps
-    module SharedSteps
-
-      def shared_steps(name, &block)
-        ensure_shared_example_steps_name_not_taken(name)
-        RSpec.world.shared_example_steps[name] = block
-      end
-      
-      private
-
-      def ensure_shared_example_steps_name_not_taken(name)
-        if RSpec.world.shared_example_steps.has_key?(name)
-          raise ArgumentError.new("Shared example steps '#{name}' already exists")
-        end
-      end
-
-    end
-  end
-end

data/spec/shared_steps_spec.rb

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-shared_steps "push steps" do
-  Given "empty pipe" do
-    pipe.clear
-  end
-
-  When "push data" do
-    pipe.push "hello"
-  end
-
-  Then "pipe should have data" do
-    pipe.items.should == ["hello"]
-  end
-end
-
-shared_steps "push with arguments steps" do |value|
-  When "push data" do
-    pipe.push value
-  end
-end
-
-shared_steps "pull steps" do
-  When "pull data" do
-    pipe.pull
-  end
-
-  Then "pipe should be empty" do
-    pipe.items.should == []
-  end
-end
-
-describe "shared steps" do
-
-  let(:pipe) do
-    Class.new do
-      def initialize
-        @values = []
-      end
-
-      def items
-        @values
-      end
-
-      def clear
-        @values = []
-      end
-
-      def push(value)
-        @values << value
-      end
-
-      def pull
-        @values.shift
-      end
-
-    end.new
-  end
-
-  Steps "push and pull steps" do
-    include_steps "push steps"
-    include_steps "pull steps"
-  end
-
-  Steps "push, count and pull" do
-    include_steps "push steps"
-    Then "pipe should have 1 item" do
-      pipe.items.size.should == 1
-    end
-    include_steps "pull steps"
-  end
-
-  Steps "push with arguments and pull" do
-    include_steps "push with arguments steps", "hi"
-    pipe.items.should == ["hi"]
-    include_steps "pull steps"
-  end
-end