spinach 0.10.1 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 1f75603856e6e68fb9f7eb16a287062659034e02
-  data.tar.gz: a6ea70aaa3ef522f10e6b5c729671c94c84bc67c
+SHA256:
+  metadata.gz: 13ae199ec9413a41d2f1ea007433f4ca9acf8750811468e320927c55cc6ae80d
+  data.tar.gz: 37383a9a6e243a01d113cbe64139ce7119af7c571dcb12589846b8737115ac9e
 SHA512:
-  metadata.gz: c5f580a7a0bc2c9f4ce8901b78f1f63da2a72d14f8233ade3ebd423f6bf0989441b318970266610422b6e53de854fd6cf1ce868f53e80064f6606396d9c39c3f
-  data.tar.gz: 349c9aa0672871576ea8ff8f86944c24816048ccbee2ca3a360b446feed8d6ede0ab2671a8db2505ea4cfd80a0f3e5e66f55578e88d69db215981d37970c06a3
+  metadata.gz: 16007d35b6d52765c78a9e82e7f08e484d6d8f6ddc8ff4de765472ec11c7e236d6dd92de7cb5e89f8d8bda7ddc042fddbc2480ba92b00793784ca5d2d22c0e12
+  data.tar.gz: ff6aad6deac02d61cf3f932afacf62bedb0f16aaa07e415ea1a675c7ac79e815d030ebb86f039e4d726bd5481226f12326c9d9060d0c4f999c820e5226a1a118

data/.github/workflows/ci.yml

@@ -0,0 +1,30 @@
+name: "Tests"
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - "*"
+
+env:
+  CI: "true"
+
+jobs:
+  main:
+    name: Tests
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [2.4, 2.5, 2.6, 2.7, "3.0", 3.1, 3.2, jruby]
+      fail-fast: false
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 1
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle exec rake

data/.ruby-version

@@ -1 +1 @@
-2.3.1
+3.2.0

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.2.1

data/Gemfile

@@ -3,7 +3,6 @@ source 'http://rubygems.org'
 # Specify your gem's dependencies in spinach.gemspec
 gemspec
 
-gem 'coveralls', require: false
 gem 'pry-byebug', platforms: [:ruby]
 
 group :docs do

data/README.markdown

@@ -1,8 +1,7 @@
 # Spinach - BDD framework on top of Gherkin
-[![Gem Version](https://badge.fury.io/rb/spinach.png)](http://badge.fury.io/rb/spinach)
-[![Build Status](https://secure.travis-ci.org/codegram/spinach.png)](http://travis-ci.org/codegram/spinach)
-[![Dependency Status](https://gemnasium.com/codegram/spinach.png)](http://gemnasium.com/codegram/spinach)
-[![Coverage Status](https://coveralls.io/repos/codegram/spinach/badge.png?branch=master)](https://coveralls.io/r/codegram/spinach)
+
+[![Gem Version](https://badge.fury.io/rb/spinach.svg)](https://badge.fury.io/rb/spinach)
+![Tests](https://github.com/codegram/spinach/workflows/Tests/badge.svg)
 
 Spinach is a high-level BDD framework that leverages the expressive
 [Gherkin language][gherkin] (used by [Cucumber][cucumber]) to help you define
@@ -10,13 +9,13 @@ executable specifications of your application or library's acceptance criteria.
 
 Conceived as an alternative to Cucumber, here are some of its design goals:
 
-* Step maintainability: since features map to their own classes, their steps are
+- Step maintainability: since features map to their own classes, their steps are
   just methods of that class. This encourages step encapsulation.
 
-* Step reusability: In case you want to reuse steps across features, you can
+- Step reusability: In case you want to reuse steps across features, you can
   always wrap those in plain ol' Ruby modules.
 
-Spinach is tested against **2.0, 2.1, 2.2 and 2.3** as well as **JRuby 9000**.
+Spinach is tested against Ruby MRI **2.4, 2.5, 2.6, 2.7, 3.0, 3.1, 3.2** as well as **JRuby **.
 
 ## Getting started
 
@@ -184,7 +183,7 @@ end
 ## Audit
 
 Over time, the definitions of your features will change. When you add, remove
-or change steps in the feature files, you can easily audit your existing step 
+or change steps in the feature files, you can easily audit your existing step
 files with:
 
 ```shell
@@ -198,12 +197,11 @@ This does not modify the step files, so you will need to paste the boilerplate
 into the appropriate places. If a new feature file is detected, you will be
 asked to run `spinach --generate` beforehand.
 
-**Important**: If auditing individual files, common steps (as above) may be 
-reported as unused when they are actually used in a feature file that is not 
+**Important**: If auditing individual files, common steps (as above) may be
+reported as unused when they are actually used in a feature file that is not
 currently being audited. To avoid this, run the audit with no arguments to
 audit all step files simultaneously.
 
-
 ## Tags
 
 Feature and Scenarios can be marked with tags in the form: `@tag`. Tags can be
@@ -238,19 +236,19 @@ Feature: So something great
   Scenario: Ensure no regression on this
 ```
 
-  Then you can run all Scenarios in your suite related to `@feat-1` using:
+Then you can run all Scenarios in your suite tagged `@feat-1` using:
 
 ```shell
 $ spinach --tags @feat-1
 ```
 
-  Or only Scenarios related to `@feat-1` and `@bug-12` using:
+Or only Scenarios tagged either `@feat-1` or `@bug-12` using:
 
 ```shell
 $ spinach --tags @feat-1,@bug-12
 ```
 
-  Or only Scenarios related to `@feat-1` excluding `@bug-12` using:
+Or only Scenarios tagged `@feat-1` that aren't tagged `@bug-12` using:
 
 ```shell
 $ spinach --tags @feat-1,~@bug-12
@@ -292,7 +290,7 @@ Full hook documentation is here:
 
 ## Local Before and After Hooks
 
-Sometimes it feels awkward to add steps into feature file just because you need to do some test setup and cleanup. And it is equally awkward to add a global hooks for this purpose. For example, if you want to add a session timeout feature, to do so, you want to set the session timeout time to 1 second just for this feature, and put the normal timeout back after this feature. It doesn't make sense to add two steps in the feature file just to change the session timeout value. In this scenario, a ```before``` and ```after``` blocks are perfect for this kind of tasks. Below is an example implementation:
+Sometimes it feels awkward to add steps into feature file just because you need to do some test setup and cleanup. And it is equally awkward to add a global hooks for this purpose. For example, if you want to add a session timeout feature, to do so, you want to set the session timeout time to 1 second just for this feature, and put the normal timeout back after this feature. It doesn't make sense to add two steps in the feature file just to change the session timeout value. In this scenario, a `before` and `after` blocks are perfect for this kind of tasks. Below is an example implementation:
 
 ```ruby
 class Spinach::Features::SessionTimeout < Spinach::FeatureSteps
@@ -329,8 +327,8 @@ When no reporter is specified, `stdout` will be used by default.
 
 Other reporters:
 
-* For a console reporter with no colors, try [spinach-console-reporter][spinach-console-reporter] (to be used with Jenkins)
-* For a rerun reporter, try [spinach-rerun-reporter][spinach-rerun-reporter] (writes failed scenarios in a file)
+- For a console reporter with no colors, try [spinach-console-reporter][spinach-console-reporter] (to be used with Jenkins)
+- For a rerun reporter, try [spinach-rerun-reporter][spinach-rerun-reporter] (writes failed scenarios in a file)
 
 ## Wanna use it with Rails 3?
 
@@ -342,46 +340,45 @@ Check out our [spinach-sinatra demo](https://github.com/codegram/spinach-sinatra
 
 ## Resources
 
-* [Landing page](http://codegram.github.com/spinach)
-* [Slides](http://codegram.github.com/spinach-presentation)
-* [Blog post](http://blog.codegram.com/2011/10/how-to-achieve-more-clean-encapsulated-modular-step-definitions-with-spinach)
-* [API Documentation](http://rubydoc.info/github/codegram/spinach/master/frames)
-* [Google group](https://groups.google.com/forum/#!forum/spinach_bdd)
+- [Landing page](http://codegram.github.com/spinach)
+- [Slides](http://codegram.github.com/spinach-presentation)
+- [Blog post](http://blog.codegram.com/2011/10/how-to-achieve-more-clean-encapsulated-modular-step-definitions-with-spinach)
+- [API Documentation](http://rubydoc.info/github/codegram/spinach/master/frames)
+- [Google group](https://groups.google.com/forum/#!forum/spinach_bdd)
 
 ### Related gems
 
-* [guard-spinach](http://github.com/codegram/guard-spinach)
-* [spinach-rails](http://github.com/codegram/spinach-rails)
-* [spinach-console-reporter][spinach-console-reporter] (to be used with Jenkins)
-* [spinach-rerun-reporter][spinach-rerun-reporter] (writes failed scenarios in a file)
-* [spring-commands-spinach](https://github.com/jvanbaarsen/spring-commands-spinach) (to be used with spring)
+- [guard-spinach](http://github.com/codegram/guard-spinach)
+- [spinach-rails](http://github.com/codegram/spinach-rails)
+- [spinach-console-reporter][spinach-console-reporter] (to be used with Jenkins)
+- [spinach-rerun-reporter][spinach-rerun-reporter] (writes failed scenarios in a file)
+- [spring-commands-spinach](https://github.com/jvanbaarsen/spring-commands-spinach) (to be used with spring)
 
 ### Demos
 
-* [spinach rails demo](https://github.com/codegram/spinach-rails-demo)
-* [spinach sinatra demo](https://github.com/codegram/spinach-sinatra-demo)
-* [simple todo Rails app](https://github.com/codegram/tasca-spinach-demo)
+- [spinach rails demo](https://github.com/codegram/spinach-rails-demo)
+- [spinach sinatra demo](https://github.com/codegram/spinach-sinatra-demo)
+- [simple todo Rails app](https://github.com/codegram/tasca-spinach-demo)
 
 ## Contributing
 
-* [List of spinach contributors](https://github.com/codegram/spinach/contributors)
+- [List of spinach contributors](https://github.com/codegram/spinach/contributors)
 
 You can easily contribute to Spinach. Its codebase is simple and
 [extensively documented][documentation].
 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add specs for it. This is important so we don't break it in a future
+- Fork the project.
+- Make your feature addition or bug fix.
+- Add specs for it. This is important so we don't break it in a future
   version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
+- Commit, do not mess with rakefile, version, or history.
   If you want to have your own version, that is fine but bump version
   in a commit by itself I can ignore when I pull.
-* Send me a pull request. Bonus points for topic branches.
+- Send me a pull request. Bonus points for topic branches.
 
 ## License
 
-MIT (Expat) License. Copyright 2011-2016 [Codegram Technologies](http://codegram.com)
-
+MIT (Expat) License. Copyright 2011-2023 [Codegram Technologies](http://codegram.com)
 
 [gherkin]: http://github.com/codegram/gherkin-ruby
 [cucumber]: http://github.com/cucumber/cucumber

data/Rakefile

@@ -11,7 +11,7 @@ end
 
 desc 'Run spinach features'
 task :spinach do
-  exec "bin/spinach"
+  exec "bin/spinach --rand"
 end
 
 task :default => [:test, :spinach]

data/bin/spinach

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 begin
-  require "bundler/setup" 
+  require "bundler/setup"
 rescue LoadError
 end
 

data/features/feature_hooks_and_tags.feature

@@ -0,0 +1,22 @@
+Feature: Feature Hooks and Tags
+  In order to run only the appropriate setup and teardown code
+  As a developer
+  I want spinach to only run feature hooks if those features would be run under the tags I provided
+
+  Scenario: No tags specified
+    Given I have a tagged feature with an untagged scenario
+    And I have an untagged feature with a tagged scenario
+    When I don't specify tags
+    Then all the feature hooks should have run
+
+  Scenario: Tags specified
+    Given I have a tagged feature with an untagged scenario
+    And I have an untagged feature with a tagged scenario
+    When I specify a tag the features and scenarios are tagged with
+    Then all the feature hooks should have run
+
+  Scenario: Tags excluded
+    Given I have a tagged feature with an untagged scenario
+    And I have an untagged feature with a tagged scenario
+    When I exclude a tag the features and scenarios are tagged with
+    Then no feature hooks should have run

data/features/randomization.feature

@@ -0,0 +1,16 @@
+Feature: Randomizing Features & Scenarios
+  In order to ensure my tests aren't dependent
+  As a developer
+  I want spinach to randomize features and scenarios (but not steps)
+
+  Scenario: Randomizing the run without specifying a seed
+    Given I have 2 features with 2 scenarios each
+    When I randomize the run without specifying a seed
+    Then The features and scenarios are run
+    And The runner output shows a seed
+
+  Scenario: Specifying the seed
+    Given I have 2 features with 2 scenarios each
+    When I specify the seed for the run
+    Then The features and scenarios are run in a different order
+    And The runner output shows the seed

data/features/reporting/display_run_summary.feature

@@ -1,9 +1,25 @@
 Feature: Display run summary
   As a developer
   I want spinach to display a summary of steps statuses
-  So I can easyly know general features status
+  So I can easily know general features status
 
-  Scenario: Display run summary at the end of features run
+  Scenario: Display run summary at the end of features run without randomization
     Given I have a feature that has some successful, undefined, failed and error steps
-    When I run it
+
+    When I run it without randomization
+    Then I should see a summary with steps status information
+    And I shouldn't see a randomization seed
+
+  Scenario: Display run summary at the end of features run with randomization
+    Given I have a feature that has some successful, undefined, failed and error steps
+
+    When I run it with randomization
+    Then I should see a summary with steps status information
+    And I should see a randomization seed
+
+  Scenario: Display run summary at the end of features run with a randomization seed
+    Given I have a feature that has some successful, undefined, failed and error steps
+
+    When I run it with a specific randomization seed
     Then I should see a summary with steps status information
+    And I should see that specific randomization seed

data/features/steps/automatic_feature_generation.rb

@@ -20,7 +20,7 @@ Feature: Cheezburger can I has
   Then 'I a feature should exist named "features/steps/cheezburger_can_i_has.rb"' do
     in_current_dir do
       @file = 'features/steps/cheezburger_can_i_has.rb'
-      File.exists?(@file).must_equal true
+      File.exist?(@file).must_equal true
     end
   end
 

data/features/steps/feature_hooks_and_tags.rb

@@ -0,0 +1,55 @@
+class Spinach::Features::FeatureHooksAndTags < Spinach::FeatureSteps
+  include Integration::SpinachRunner
+
+  step 'I have a tagged feature with an untagged scenario' do
+    write_file 'features/a.feature', <<-FEATURE
+@tag
+Feature: A
+  Scenario: A1
+    Then a1
+    FEATURE
+
+    write_file 'features/steps/a.rb', <<-STEPS
+class Spinach::Features::A < Spinach::FeatureSteps
+  step 'a1' do; end
+end
+    STEPS
+  end
+
+  step 'I have an untagged feature with a tagged scenario' do
+    write_file 'features/b.feature', <<-FEATURE
+Feature: B
+  @tag
+  Scenario: B1
+    Then b1
+    FEATURE
+
+    write_file 'features/steps/b.rb', <<-STEPS
+class Spinach::Features::B < Spinach::FeatureSteps
+  step 'b1' do; end
+end
+    STEPS
+  end
+
+  step "I don't specify tags" do
+    run_spinach
+  end
+
+  step 'I specify a tag the features and scenarios are tagged with' do
+    run_spinach({append: "--tags @tag"})
+  end
+
+  step 'I exclude a tag the features and scenarios are tagged with' do
+    run_spinach({append: "--tags ~@tag"})
+  end
+
+  step 'all the feature hooks should have run' do
+    @stdout.must_match("Feature: A")
+    @stdout.must_match("Feature: B")
+  end
+
+  step 'no feature hooks should have run' do
+    @stdout.wont_match("Feature: A")
+    @stdout.wont_match("Feature: B")
+  end
+end

data/features/steps/randomizing_features_scenarios.rb

@@ -0,0 +1,68 @@
+class Spinach::Features::RandomizingFeaturesScenarios < Spinach::FeatureSteps
+  include Integration::SpinachRunner
+
+  step 'I have 2 features with 2 scenarios each' do
+    write_file 'features/success_a.feature', <<-FEATURE
+Feature: Success A
+  Scenario: A1
+    Then a1
+  Scenario: A2
+    Then a2
+    FEATURE
+
+    write_file 'features/steps/success_a.rb', <<-STEPS
+class Spinach::Features::SuccessA < Spinach::FeatureSteps
+  step 'a1' do; end
+  step 'a2' do; end
+end
+    STEPS
+
+    write_file 'features/success_b.feature', <<-FEATURE
+Feature: Success B
+  Scenario: B1
+    Then b1
+  Scenario: B2
+    Then b2
+    FEATURE
+
+    write_file 'features/steps/success_b.rb', <<-STEPS
+class Spinach::Features::SuccessB < Spinach::FeatureSteps
+  step 'b1' do; end
+  step 'b2' do; end
+end
+    STEPS
+  end
+
+  step 'I randomize the run without specifying a seed' do
+    run_spinach({append: "--rand"})
+  end
+
+  step 'I specify the seed for the run' do
+    # Reverse order (A2 A1 B2 B1) is the only way I can show that
+    # scenarios and features are randomized by the seed when the
+    # example has 2 features each with 2 scenarios. I tried seeds
+    # until I found one that ordered the test in that order.
+    @seed = 1
+
+    run_spinach({append: "--seed #{@seed}"})
+  end
+
+  step 'The features and scenarios are run' do
+    @stdout.must_include("A1")
+    @stdout.must_include("A2")
+    @stdout.must_include("B1")
+    @stdout.must_include("B2")
+  end
+
+  step 'The features and scenarios are run in a different order' do
+    @stdout.must_match(/B2.*B1.*A2.*A1/m)
+  end
+
+  step 'The runner output shows a seed' do
+    @stdout.must_match(/^Randomized with seed \d*$/)
+  end
+
+  step 'The runner output shows the seed' do
+    @stdout.must_match(/^Randomized with seed #{@seed}$/)
+  end
+end

data/features/steps/reporting/display_run_summary.rb

@@ -62,7 +62,7 @@ Feature: A test feature
     @feature = "features/test_feature.feature"
   end
 
-  When "I run it" do
+  When "I run it without randomization" do
     run_feature @feature
   end
 
@@ -71,4 +71,32 @@ Feature: A test feature
       /Summary:.*4.*Successful.*1.*Undefined.*1.*Failed.*1.*Error/
     )
   end
+
+  And "I shouldn't see a randomization seed" do
+    @stdout.wont_match(
+      /Randomized\ with\ seed\ \d+/
+    )
+  end
+
+  When "I run it with randomization" do
+    run_feature @feature, {append: "--rand"}
+  end
+
+  And "I should see a randomization seed" do
+    @stdout.must_match(
+      /Randomized\ with\ seed\ \d+/
+    )
+  end
+
+  When "I run it with a specific randomization seed" do
+    @seed = rand(0xFFFF)
+
+    run_feature @feature, {append: "--seed #{@seed}"}
+  end
+
+  And "I should see that specific randomization seed" do
+    @stdout.must_match(
+      /Randomized\ with\ seed\ #{@seed}/
+    )
+  end
 end

data/features/support/env.rb

@@ -1,19 +1,6 @@
 require 'minitest/autorun'
 require 'minitest/spec'
 require_relative 'filesystem'
-require 'simplecov'
-
-if ENV['CI'] && !defined?(Rubinius)
-  require 'coveralls'
-  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
-  require 'simplecov'
-
-  SimpleCov.start do
-    add_filter '/test/'
-    add_filter '/features/'
-  end
-end
-
 
 Spinach.hooks.after_scenario do |scenario|
   FileUtils.rm_rf(Filesystem.dirs)

data/features/support/spinach_runner.rb

@@ -23,6 +23,17 @@ module Integration
       run "#{ruby} #{spinach} #{feature} #{options[:append]}", options[:env]
     end
 
+    def run_spinach(options = {})
+      options[:framework] ||= :minitest
+
+      use_minitest if options[:framework] == :minitest
+      use_rspec    if options[:framework] == :rspec
+
+      spinach = File.expand_path("bin/spinach")
+
+      run "#{ruby} #{spinach} #{options[:append]}"
+    end
+
     def ruby
       return @ruby if defined?(@ruby)
 

data/lib/spinach/cli.rb

@@ -56,7 +56,7 @@ module Spinach
 
       @args.each do |arg|
         if arg.match(/\.feature/)
-          if File.exists? arg.gsub(/:\d*/, '')
+          if File.exist? arg.gsub(/:\d*/, '')
             files_to_run << arg
           else
             fail! "#{arg} could not be found"
@@ -131,6 +131,16 @@ module Spinach
             config[:reporter_classes] = names
           end
 
+          opts.on('--rand', "Randomize the order of features and scenarios") do
+            config[:orderer_class] = orderer_class(:random)
+          end
+
+          opts.on('--seed SEED', Integer,
+                  "Provide a seed for randomizing the order of features and scenarios") do |seed|
+            config[:orderer_class] = orderer_class(:random)
+            config[:seed]          = seed
+          end
+
           opts.on_tail('--fail-fast',
                        'Terminate the suite run on the first failure') do |class_name|
             config[:fail_fast] = true
@@ -164,7 +174,7 @@ and obsolete steps") do
     # Builds the class name to use an output reporter.
     #
     # @param [String] klass
-    #   The class name fo the reporter.
+    #   The class name of the reporter.
     #
     # @return [String]
     #   The full name of the reporter class.
@@ -177,5 +187,22 @@ and obsolete steps") do
     def reporter_class(klass)
       "Spinach::Reporter::" + Spinach::Support.camelize(klass)
     end
+
+    # Builds the class to use an orderer.
+    #
+    # @param [String] klass
+    #   The class name of the orderer.
+    #
+    # @return [String]
+    #   The full name of the orderer class.
+    #
+    # @example
+    #   orderer_class('random')
+    #   # => Spinach::Orderers::Random
+    #
+    # @api private
+    def orderer_class(klass)
+      "Spinach::Orderers::" + Spinach::Support.camelize(klass)
+    end
   end
 end

data/lib/spinach/config.rb

@@ -33,6 +33,8 @@ module Spinach
                 :save_and_open_page_on_failure,
                 :reporter_classes,
                 :reporter_options,
+                :orderer_class,
+                :seed,
                 :fail_fast,
                 :audit
 
@@ -66,6 +68,29 @@ module Spinach
       @reporter_options || {}
     end
 
+    # The "orderer class" holds the orderer class name
+    # Defaults to Spinach::Orderers::Default
+    #
+    # @return [orderer object]
+    #    The orderer that responds to specific messages.
+    #
+    # @api public
+    def orderer_class
+      @orderer_class || "Spinach::Orderers::Default"
+    end
+
+    # A randomization seed. This is what spinach uses for test run
+    # randomization, so if you call `Kernel.srand(Spinach.config.seed)`
+    # in your support environment file, not only will the test run
+    # order be guaranteed to be stable under a specific seed, all
+    # the Ruby-generated random numbers produced during your test
+    # run will also be stable under that seed.
+    #
+    # @api public
+    def seed
+      @seed ||= rand(0xFFFF)
+    end
+
     # The "step definitions path" holds the place where your feature step
     # classes will be searched for. Defaults to '#{features_path}/steps'
     #

data/lib/spinach/feature.rb

@@ -24,6 +24,14 @@ module Spinach
       lines_to_run.empty?
     end
 
+    # Identifier used by orderers.
+    #
+    # Needs to involve the relative file path so that the ordering
+    # a seed generates is stable across both runs and machines.
+    #
+    # @api public
+    alias ordering_id filename
+
     # Run the provided code for every step
     def each_step
       scenarios.each { |scenario| scenario.steps.each { |step| yield step } }

data/lib/spinach/orderers/default.rb

@@ -0,0 +1,25 @@
+module Spinach
+  module Orderers
+    class Default
+      def initialize(**options); end
+
+      # Appends any necessary report output (by default does nothing).
+      #
+      # @param [IO] io
+      #   Output buffer for report.
+      #
+      # @api public
+      def attach_summary(io); end
+
+      # Returns a reordered version of the provided array
+      #
+      # @param [Array] items
+      #   Items to order
+      #
+      # @api public
+      def order(items)
+        items
+      end
+    end
+  end
+end