tuktuk-rails 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/formatters/configurable_colors.feature

@@ -0,0 +1,31 @@
+Feature: Configurable colors
+
+  RSpec allows you to configure the terminal colors used in the text formatters.
+
+  * `failure_color`: Color used when tests fail (default: `:red`)
+  * `success_color`: Color used when tests pass (default: `:green`)
+  * `pending_color`: Color used when tests are pending (default: `:yellow`)
+  * `fixed_color`: Color used when a pending block inside an example passes, but was expected to fail (default: `:blue`)
+  * `detail_color`: Color used for miscellaneous test details (default: `:cyan`)
+
+  Colors are normally specified as symbols. Options are `:black`, `:red`,
+  `:green`, `:yellow`, `:blue`, `:magenta`, `:cyan`, and `:white`.
+
+  @ansi
+  Scenario: Customizing the failure color
+    Given a file named "custom_failure_color_spec.rb" with:
+      """ruby
+      RSpec.configure do |config|
+        config.failure_color = :magenta
+        config.tty = true
+        config.color = true
+      end
+
+      describe "failure" do
+        it "fails and uses the custom color" do
+          expect(2).to eq(4)
+        end
+      end
+      """
+      When I run `rspec custom_failure_color_spec.rb --format progress`
+      Then the failing example is printed in magenta

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/formatters/custom_formatter.feature

@@ -0,0 +1,36 @@
+Feature: custom formatters
+
+  RSpec ships with general purpose output formatters. You can tell RSpec which
+  one to use using the [`--format` command line
+  option]('../command_line/format_option').
+
+  When RSpec's built-in output formatters don't, however, give you everything
+  you need, you can write your own custom formatter and tell RSpec to use that
+  one instead.  The simplest way is to subclass RSpec's `BaseTextFormatter`,
+  and then override just the methods that you want to modify.
+
+  Scenario: custom formatter
+    Given a file named "custom_formatter.rb" with:
+      """ruby
+      require "rspec/core/formatters/base_text_formatter"
+
+      class CustomFormatter < RSpec::Core::Formatters::BaseTextFormatter
+        def initialize(output)
+          super(output)
+        end
+
+        def example_started(proxy)
+          output << "example: " << proxy.description
+        end
+      end
+      """
+    And a file named "example_spec.rb" with:
+      """ruby
+      describe "my group" do
+        specify "my example" do
+        end
+      end
+      """
+    When I run `rspec example_spec.rb --require ./custom_formatter.rb --format CustomFormatter`
+    Then the output should contain "example: my example"
+    And  the exit status should be 0

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/formatters/json_formatter.feature

@@ -0,0 +1,30 @@
+Feature: JSON formatter
+
+  Scenario: Formatting example names for retry
+    Given a file named "various_spec.rb" with:
+    """ruby
+    describe "Various" do
+      it "fails" do
+        "fail".should eq("succeed")
+      end
+
+      it "succeeds" do
+        "succeed".should eq("succeed")
+      end
+
+      it "pends"
+    end
+    """
+    When I run `rspec various_spec.rb --format j`
+    Then the output should contain all of these:
+          |"summary_line":"3 examples, 1 failure, 1 pending"|
+          |"examples":[                                     |
+          |"description":"fails"                             |
+          |"full_description":"Various fails"                |
+          |"status":"failed"                                 |
+          |"file_path":"./various_spec.rb"                   |
+          |"line_number":2                                   |
+          |"exception":{                                     |
+          |"class":"RSpec::Expectations::ExpectationNotMetError"|
+
+    And the exit status should be 1

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/formatters/text_formatter.feature

@@ -0,0 +1,46 @@
+Feature: text formatter
+
+  In order to easily see the result of running my specs
+  As an RSpec user
+  I want clear, concise, well-formatted output
+
+  Scenario: Backtrace formatting for failing specs in multiple files
+    Given a file named "string_spec.rb" with:
+      """ruby
+      describe String do
+        it "has a failing example" do
+          "foo".reverse.should eq("ofo")
+        end
+      end
+      """
+    And a file named "integer_spec.rb" with:
+      """ruby
+      describe Integer do
+        it "has a failing example" do
+          (7 + 5).should eq(11)
+        end
+      end
+      """
+    When I run `rspec integer_spec.rb string_spec.rb`
+    Then the backtrace-normalized output should contain:
+      """
+        1) Integer has a failing example
+           Failure/Error: (7 + 5).should eq(11)
+             
+             expected: 11
+                  got: 12
+             
+             (compared using ==)
+           # ./integer_spec.rb:3
+      """
+    And the backtrace-normalized output should contain:
+      """
+        2) String has a failing example
+           Failure/Error: "foo".reverse.should eq("ofo")
+             
+             expected: "ofo"
+                  got: "oof"
+             
+             (compared using ==)
+           # ./string_spec.rb:3
+      """

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/helper_methods/arbitrary_methods.feature

@@ -0,0 +1,40 @@
+Feature: arbitrary helper methods
+
+  You can define methods in any example group using Ruby's `def` keyword or
+  `define_method` method. These _helper_ methods are exposed to examples in the
+  group in which they are defined and groups nested within that group, but not
+  parent or sibling groups.
+
+  Scenario: use a method defined in the same group
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "an example" do
+        def help
+          :available
+        end
+
+        it "has access to methods defined in its group" do
+          help.should be(:available)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass
+
+  Scenario: use a method defined in a parent group
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "an example" do
+        def help
+          :available
+        end
+
+        describe "in a nested group" do
+          it "has access to methods defined in its parent group" do
+            help.should be(:available)
+          end
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the examples should all pass

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/helper_methods/let.feature

@@ -0,0 +1,50 @@
+Feature: let and let!
+
+  Use `let` to define a memoized helper method.  The value will be cached
+  across multiple calls in the same example but not across examples.
+
+  Note that `let` is lazy-evaluated: it is not evaluated until the first time
+  the method it defines is invoked. You can use `let!` to force the method's
+  invocation before each example.
+
+  Scenario: use let to define memoized helper method
+    Given a file named "let_spec.rb" with:
+      """ruby
+      $count = 0
+      describe "let" do
+        let(:count) { $count += 1 }
+
+        it "memoizes the value" do
+          count.should eq(1)
+          count.should eq(1)
+        end
+
+        it "is not cached across examples" do
+          count.should eq(2)
+        end
+      end
+      """
+    When I run `rspec let_spec.rb`
+    Then the examples should all pass
+
+  Scenario: use let! to define a memoized helper method that is called in a before hook
+    Given a file named "let_bang_spec.rb" with:
+      """ruby
+      $count = 0
+      describe "let!" do
+        invocation_order = []
+
+        let!(:count) do
+          invocation_order << :let!
+          $count += 1
+        end
+
+        it "calls the helper method in a before hook" do
+          invocation_order << :example
+          invocation_order.should == [:let!, :example]
+          count.should eq(1)
+        end
+      end
+      """
+    When I run `rspec let_bang_spec.rb`
+    Then the examples should all pass

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/helper_methods/modules.feature

@@ -0,0 +1,149 @@
+Feature: Define helper methods in a module
+
+  You can define helper methods in a module and include it in
+  your example groups using the `config.include` configuration
+  option.  `config.extend` can be used to extend the module onto
+  your example groups so that the methods in the module are available
+  in the example groups themselves (but not in the actual examples).
+
+  You can also include or extend the module onto only certain example
+  groups by passing a metadata hash as the last argument.  Only groups
+  that match the given metadata will include or extend the module.
+
+  If you set the `treat_symbols_as_metadata_keys_with_true_values` config option
+  to `true`, you can specify metadata using only symbols.
+
+  Background:
+    Given a file named "helpers.rb" with:
+      """ruby
+      module Helpers
+        def help
+          :available
+        end
+      end
+      """
+
+  Scenario: include a module in all example groups
+    Given a file named "include_module_spec.rb" with:
+      """ruby
+      require './helpers'
+
+      RSpec.configure do |c|
+        c.include Helpers
+      end
+
+      describe "an example group" do
+        it "has access to the helper methods defined in the module" do
+          help.should be(:available)
+        end
+      end
+      """
+    When I run `rspec include_module_spec.rb`
+    Then the examples should all pass
+
+  Scenario: extend a module in all example groups
+    Given a file named "extend_module_spec.rb" with:
+      """ruby
+      require './helpers'
+
+      RSpec.configure do |c|
+        c.extend Helpers
+      end
+
+      describe "an example group" do
+        puts "Help is #{help}"
+
+        it "does not have access to the helper methods defined in the module" do
+          expect { help }.to raise_error(NameError)
+        end
+      end
+      """
+    When I run `rspec extend_module_spec.rb`
+    Then the examples should all pass
+    And the output should contain "Help is available"
+
+  Scenario: include a module in only some example groups
+    Given a file named "include_module_in_some_groups_spec.rb" with:
+      """ruby
+      require './helpers'
+
+      RSpec.configure do |c|
+        c.include Helpers, :foo => :bar
+      end
+
+      describe "an example group with matching metadata", :foo => :bar do
+        it "has access to the helper methods defined in the module" do
+          help.should be(:available)
+        end
+      end
+
+      describe "an example group without matching metadata" do
+        it "does not have access to the helper methods defined in the module" do
+          expect { help }.to raise_error(NameError)
+        end
+      end
+      """
+    When I run `rspec include_module_in_some_groups_spec.rb`
+    Then the examples should all pass
+
+  Scenario: extend a module in only some example groups
+    Given a file named "extend_module_in_only_some_groups_spec.rb" with:
+      """ruby
+      require './helpers'
+
+      RSpec.configure do |c|
+        c.extend Helpers, :foo => :bar
+      end
+
+      describe "an example group with matching metadata", :foo => :bar do
+        puts "In a matching group, help is #{help}"
+
+        it "does not have access to the helper methods defined in the module" do
+          expect { help }.to raise_error(NameError)
+        end
+      end
+
+      describe "an example group without matching metadata" do
+        puts "In a non-matching group, help is #{help rescue 'not available'}"
+
+        it "does not have access to the helper methods defined in the module" do
+          expect { help }.to raise_error(NameError)
+        end
+      end
+      """
+    When I run `rspec extend_module_in_only_some_groups_spec.rb`
+    Then the examples should all pass
+    And the output should contain "In a matching group, help is available"
+    And the output should contain "In a non-matching group, help is not available"
+
+  Scenario: use symbols as metadata
+    Given a file named "symbols_as_metadata_spec.rb" with:
+      """ruby
+      require './helpers'
+
+      RSpec.configure do |c|
+        c.treat_symbols_as_metadata_keys_with_true_values = true
+        c.include Helpers, :include_helpers
+        c.extend  Helpers, :extend_helpers
+      end
+
+      describe "an example group with matching include metadata", :include_helpers do
+        puts "In a group not matching the extend filter, help is #{help rescue 'not available'}"
+
+        it "has access to the helper methods defined in the module" do
+          help.should be(:available)
+        end
+      end
+
+      describe "an example group with matching extend metadata", :extend_helpers do
+        puts "In a group matching the extend filter, help is #{help}"
+
+        it "does not have access to the helper methods defined in the module" do
+          expect { help }.to raise_error(NameError)
+        end
+      end
+      """
+    When I run `rspec symbols_as_metadata_spec.rb`
+    Then the examples should all pass
+    And the output should contain "In a group not matching the extend filter, help is not available"
+    And the output should contain "In a group matching the extend filter, help is available"

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/hooks/around_hooks.feature

@@ -0,0 +1,343 @@
+Feature: around hooks
+
+  Around hooks receive the example as a block argument, extended to behave like
+  a proc.  This lets you define code that should be executed before and after
+  the example. Of course, you can do the same thing with before and after hooks,
+  and it's often cleaner to do so.
+
+  Where around hooks shine is when you want to run an example in a block. For
+  example, if your database library offers a transaction method that receives
+  a block, you can use an around hook as described in the first scenario:
+
+  WARNING: around hooks do not share state with the example the way before and
+  after hooks do. This means that you can not share instance variables between
+  around hooks and examples.
+
+  Also, mock frameworks are set up and torn down within the context of running
+  the example, so you can not interact with them directly in around hooks.
+
+  Scenario: use the example as a proc within the block passed to around()
+    Given a file named "example_spec.rb" with:
+      """ruby
+      class Database
+        def self.transaction
+          puts "open transaction"
+          yield
+          puts "close transaction"
+        end
+      end
+
+      describe "around filter" do
+        around(:each) do |example|
+          Database.transaction(&example)
+        end
+
+        it "gets run in order" do
+          puts "run the example"
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain:
+      """
+      open transaction
+      run the example
+      close transaction
+      """
+
+  Scenario: invoke the example using run()
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "around hook" do
+        around(:each) do |example|
+          puts "around each before"
+          example.run
+          puts "around each after"
+        end
+
+        it "gets run in order" do
+          puts "in the example"
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain:
+      """
+      around each before
+      in the example
+      around each after
+      """
+
+  Scenario: access the example metadata
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "something" do
+        around(:each) do |example|
+          puts example.metadata[:foo]
+          example.run
+        end
+
+        it "does something", :foo => "this should show up in the output" do
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "this should show up in the output"
+
+  Scenario: define a global around hook
+    Given a file named "example_spec.rb" with:
+      """ruby
+      RSpec.configure do |c|
+        c.around(:each) do |example|
+          puts "around each before"
+          example.run
+          puts "around each after"
+        end
+      end
+
+      describe "around filter" do
+        it "gets run in order" do
+          puts "in the example"
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain:
+      """
+      around each before
+      in the example
+      around each after
+      """
+
+  Scenario: before/after(:each) hooks are wrapped by the around hook
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "around filter" do
+        around(:each) do |example|
+          puts "around each before"
+          example.run
+          puts "around each after"
+        end
+
+        before(:each) do
+          puts "before each"
+        end
+
+        after(:each) do
+          puts "after each"
+        end
+
+        it "gets run in order" do
+          puts "in the example"
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain:
+      """
+      around each before
+      before each
+      in the example
+      after each
+      around each after
+      """
+
+  Scenario: before/after(:all) hooks are NOT wrapped by the around hook
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "around filter" do
+        around(:each) do |example|
+          puts "around each before"
+          example.run
+          puts "around each after"
+        end
+
+        before(:all) do
+          puts "before all"
+        end
+
+        after(:all) do
+          puts "after all"
+        end
+
+        it "gets run in order" do
+          puts "in the example"
+        end
+      end
+      """
+    When I run `rspec --format progress example_spec.rb`
+    Then the output should contain:
+      """
+      before all
+      around each before
+      in the example
+      around each after
+      .after all
+      """
+
+  Scenario: examples run by an around block are run in the configured context
+    Given a file named "example_spec.rb" with:
+      """ruby
+      module IncludedInConfigureBlock
+        def included_in_configure_block; true; end
+      end
+
+      RSpec.configure do |c|
+        c.include IncludedInConfigureBlock
+      end
+
+      describe "around filter" do
+        around(:each) do |example|
+          example.run
+        end
+
+        it "runs the example in the correct context" do
+          included_in_configure_block.should be_true
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "1 example, 0 failure"
+
+  Scenario: implicitly pending examples are detected as Not yet implemented
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "implicit pending example" do
+        around(:each) do |example|
+          example.run
+        end
+
+        it "should be detected as Not yet implemented"
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "1 example, 0 failures, 1 pending"
+    And the output should contain:
+      """
+      Pending:
+        implicit pending example should be detected as Not yet implemented
+          # Not yet implemented
+      """
+
+
+  Scenario: explicitly pending examples are detected as pending
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "explicit pending example" do
+        around(:each) do |example|
+          example.run
+        end
+
+        it "should be detected as pending" do
+          pending
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "1 example, 0 failures, 1 pending"
+    And the output should contain:
+      """
+        explicit pending example should be detected as pending
+          # No reason given
+      """
+
+  Scenario: multiple around hooks in the same scope
+    Given a file named "example_spec.rb" with:
+      """ruby
+      describe "if there are multiple around hooks in the same scope" do
+        around(:each) do |example|
+          puts "first around hook before"
+          example.run
+          puts "first around hook after"
+        end
+
+        around(:each) do |example|
+          puts "second around hook before"
+          example.run
+          puts "second around hook after"
+        end
+
+        it "they should all be run" do
+          puts "in the example"
+          1.should eq(1)
+        end
+      end
+      """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "1 example, 0 failure"
+    And the output should contain:
+      """
+      first around hook before
+      second around hook before
+      in the example
+      second around hook after
+      first around hook after
+      """
+
+  Scenario: around hooks in multiple scopes
+    Given a file named "example_spec.rb" with:
+    """ruby
+    describe "if there are around hooks in an outer scope" do
+      around(:each) do |example|
+        puts "first outermost around hook before"
+        example.run
+        puts "first outermost around hook after"
+      end
+
+      around(:each) do |example|
+        puts "second outermost around hook before"
+        example.run
+        puts "second outermost around hook after"
+      end
+
+      describe "outer scope" do
+        around(:each) do |example|
+          puts "first outer around hook before"
+          example.run
+          puts "first outer around hook after"
+        end
+
+        around(:each) do |example|
+          puts "second outer around hook before"
+          example.run
+          puts "second outer around hook after"
+        end
+
+        describe "inner scope" do
+          around(:each) do |example|
+            puts "first inner around hook before"
+            example.run
+            puts "first inner around hook after"
+          end
+
+          around(:each) do |example|
+            puts "second inner around hook before"
+            example.run
+            puts "second inner around hook after"
+          end
+
+          it "they should all be run" do
+            puts "in the example"
+          end
+        end
+      end
+    end
+    """
+    When I run `rspec example_spec.rb`
+    Then the output should contain "1 example, 0 failure"
+    And the output should contain:
+    """
+    first outermost around hook before
+    second outermost around hook before
+    first outer around hook before
+    second outer around hook before
+    first inner around hook before
+    second inner around hook before
+    in the example
+    second inner around hook after
+    first inner around hook after
+    second outer around hook after
+    first outer around hook after
+    second outermost around hook after
+    first outermost around hook after
+    """