tuktuk-rails 0.0.6 → 0.0.7

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/configuration/show_failures_in_pending_blocks.feature

@@ -0,0 +1,61 @@
+Feature: show_failures_in_pending_blocks
+
+  Use the show_failures_in_pending_blocks option to run the code in pending blocks while keeping the tests pending.
+
+    RSpec.configure { |c| c.show_failures_in_pending_blocks = true }
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure {|c| c.show_failures_in_pending_blocks = true}
+      """
+
+  Scenario: by default, code in pending examples is not exercised
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      describe "fails" do
+        pending "code will not be exercised" do
+          fail
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the output should not contain "Failure/Error: pending { fail }"
+
+  Scenario: by default, code in pending blocks inside examples is not exercised
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      describe "fails" do
+        it "code will not be exercised" do
+          pending { fail }
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the output should not contain "Failure/Error: pending { fail }"
+
+  Scenario: when turned on, pending code blocks inside examples are exercised
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      require "spec_helper"
+      describe "fails" do
+        it "code will be exercised" do
+          pending { fail }
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the output should contain "Failure/Error: pending { fail }"
+
+  Scenario: when turned on, code inside pending examples is not exercised
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      require "spec_helper"
+      describe "fails" do
+        pending "code will not be exercised" do
+          fail
+        end
+      end
+      """
+    When I run `rspec spec/example_spec.rb`
+    Then the output should not contain "Failure/Error: pending { fail }"

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/configuration/treat_symbols_as_metadata_keys_with_true_values.feature

@@ -0,0 +1,52 @@
+Feature: treat symbols as metadata keys with true values
+
+  Use the treat_symbols_as_metadata_keys_with_true_values option to tell RSpec that :key is shorthand for :key => true.
+
+    RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = true }
+
+  Background:
+    Given a file named "spec/spec_helper.rb" with:
+      """ruby
+      RSpec.configure { |c| c.treat_symbols_as_metadata_keys_with_true_values = true }
+      """
+
+  Scenario: by default, symbols without values are ignored and the specs are filtered out
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      describe "failed filtering" do
+        it "this will be filted out", :some_tag do
+          true
+        end
+
+        it "so will this" do
+          false
+        end
+      end
+      """
+      When I run `rspec spec/example_spec.rb --tag some_tag`
+      Then the output should contain "0 examples, 0 failures"
+      And the output should contain "All examples were filtered out"
+
+  Scenario: when treat_symbols_as_metadata_keys_with_true_values is true, specs can be tagged with only a symbol
+    Given a file named "spec/example_spec.rb" with:
+      """ruby
+      require "spec_helper"
+      describe "run me", :some_tag do
+        it "runs" do
+          true
+        end
+      end
+
+      describe "run one of these" do
+        it "run this one", :some_tag do
+          true
+        end
+
+        it "but not me" do
+          false
+        end
+      end
+      """
+      When I run `rspec spec/example_spec.rb --tag some_tag`
+      Then the output should contain "2 examples, 0 failures"
+      And the output should contain "Run options: include {:some_tag=>true}"

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/example_groups/basic_structure.feature

@@ -0,0 +1,55 @@
+Feature: basic structure (describe/it)
+
+  RSpec is a DSL for creating executable examples of how code is expected to
+  behave, organized in groups. It uses the words "describe" and "it" so we can
+  express concepts like a conversation:
+
+      "Describe an account when it is first opened."
+      "It has a balance of zero."
+
+  The `describe` method creates an example group.  Within the block passed to
+  `describe` you can declare nested groups using the `describe` or `context`
+  methods, or you can declare examples using the `it` or `specify` methods.
+
+  Under the hood, an example group is a class in which the block passed to
+  `describe` or `context` is evaluated. The blocks passed to `it` are evaluated
+  in the context of an _instance_ of that class.
+
+  Scenario: one group, one example
+    Given a file named "sample_spec.rb" with:
+    """ruby
+    describe "something" do
+      it "does something" do
+      end
+    end
+    """
+    When I run `rspec sample_spec.rb -fn`
+    Then the output should contain:
+      """
+      something
+        does something
+      """
+
+  Scenario: nested example groups (using context)
+    Given a file named "nested_example_groups_spec.rb" with:
+    """ruby
+    describe "something" do
+      context "in one context" do
+        it "does one thing" do
+        end
+      end
+      context "in another context" do
+        it "does another thing" do
+        end
+      end
+    end
+    """
+    When I run `rspec nested_example_groups_spec.rb -fdoc`
+    Then the output should contain:
+      """
+      something
+        in one context
+          does one thing
+        in another context
+          does another thing
+      """

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/example_groups/shared_context.feature

@@ -0,0 +1,74 @@
+Feature: shared context
+
+  Use `shared_context` to define a block that will be evaluated in the context
+  of example groups either explicitly, using `include_context`, or implicitly by
+  matching metadata.
+
+  Background:
+    Given a file named "shared_stuff.rb" with:
+      """ruby
+      shared_context "shared stuff", :a => :b do
+        before { @some_var = :some_value }
+        def shared_method
+          "it works"
+        end
+        let(:shared_let) { {'arbitrary' => 'object'} }
+        subject do
+          'this is the subject'
+        end
+      end
+      """
+
+  Scenario: declare shared context and include it with include_context
+    Given a file named "shared_context_example.rb" with:
+      """ruby
+      require "./shared_stuff.rb"
+
+      describe "group that includes a shared context using 'include_context'" do
+        include_context "shared stuff"
+
+        it "has access to methods defined in shared context" do
+          shared_method.should eq("it works")
+        end
+
+        it "has access to methods defined with let in shared context" do
+          shared_let['arbitrary'].should eq('object')
+        end
+
+        it "runs the before hooks defined in the shared context" do
+          @some_var.should be(:some_value)
+        end
+
+        it "accesses the subject defined in the shared context" do
+          subject.should eq('this is the subject')
+        end
+      end
+      """
+    When I run `rspec shared_context_example.rb`
+    Then the examples should all pass
+
+  Scenario: declare shared context and include it with metadata
+    Given a file named "shared_context_example.rb" with:
+      """ruby
+      require "./shared_stuff.rb"
+
+      describe "group that includes a shared context using metadata", :a => :b do
+        it "has access to methods defined in shared context" do
+          shared_method.should eq("it works")
+        end
+
+        it "has access to methods defined with let in shared context" do
+          shared_let['arbitrary'].should eq('object')
+        end
+
+        it "runs the before hooks defined in the shared context" do
+          @some_var.should be(:some_value)
+        end
+
+        it "accesses the subject defined in the shared context" do
+          subject.should eq('this is the subject')
+        end
+      end
+      """
+    When I run `rspec shared_context_example.rb`
+    Then the examples should all pass

data/vendor/bundle/ruby/2.0.0/gems/rspec-core-2.14.7/features/example_groups/shared_examples.feature

@@ -0,0 +1,294 @@
+Feature: shared examples
+
+  Shared examples let you describe behaviour of types or modules. When
+  declared, a shared group's content is stored. It is only realized in the
+  context of another example group, which provides any context the shared group
+  needs to run.
+
+  A shared group is included in another group using any of:
+
+      include_examples "name"      # include the examples in the current context
+      it_behaves_like "name"       # include the examples in a nested context
+      it_should_behave_like "name" # include the examples in a nested context
+      matching metadata            # include the examples in the current context
+
+  WARNING: Files containing shared groups must be loaded before the files that
+  use them.  While there are conventions to handle this, RSpec does _not_ do
+  anything special (like autoload). Doing so would require a strict naming
+  convention for files that would break existing suites.
+
+  CONVENTIONS:
+
+  1.  The simplest approach is to require files with shared examples explicitly
+      from the files that use them. Keep in mind that RSpec adds the `spec`
+      directory to the `LOAD_PATH`, so you can say `require
+      'shared_examples_for_widgets'` to require a file at
+      `#{PROJECT_ROOT}/spec/shared_examples_for_widgets.rb`.
+
+  2.  Put files containing shared examples in `spec/support/` and require files
+      in that directory from `spec/spec_helper.rb`:
+
+          Dir["./spec/support/**/*.rb"].sort.each {|f| require f}
+
+      This is included in the generated `spec/spec_helper.rb` file in
+      `rspec-rails`
+
+  3. When all of the groups that include the shared group, just declare
+     the shared group in the same file.
+
+  Scenario: shared examples group included in two groups in one file
+    Given a file named "collection_spec.rb" with:
+      """ruby
+      require "set"
+
+      shared_examples "a collection" do
+        let(:collection) { described_class.new([7, 2, 4]) }
+
+        context "initialized with 3 items" do
+          it "says it has three items" do
+            collection.size.should eq(3)
+          end
+        end
+
+        describe "#include?" do
+          context "with an an item that is in the collection" do
+            it "returns true" do
+              collection.include?(7).should be_true
+            end
+          end
+
+          context "with an an item that is not in the collection" do
+            it "returns false" do
+              collection.include?(9).should be_false
+            end
+          end
+        end
+      end
+
+      describe Array do
+        it_behaves_like "a collection"
+      end
+
+      describe Set do
+        it_behaves_like "a collection"
+      end
+      """
+    When I run `rspec collection_spec.rb --format documentation`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      Array
+        behaves like a collection
+          initialized with 3 items
+            says it has three items
+          #include?
+            with an an item that is in the collection
+              returns true
+            with an an item that is not in the collection
+              returns false
+
+      Set
+        behaves like a collection
+          initialized with 3 items
+            says it has three items
+          #include?
+            with an an item that is in the collection
+              returns true
+            with an an item that is not in the collection
+              returns false
+      """
+
+  Scenario: Providing context to a shared group using a block
+    Given a file named "shared_example_group_spec.rb" with:
+    """ruby
+    require "set"
+
+    shared_examples "a collection object" do
+      describe "<<" do
+        it "adds objects to the end of the collection" do
+          collection << 1
+          collection << 2
+          expect(collection.to_a).to match_array([1, 2])
+        end
+      end
+    end
+
+    describe Array do
+      it_behaves_like "a collection object" do
+        let(:collection) { Array.new }
+      end
+    end
+
+    describe Set do
+      it_behaves_like "a collection object" do
+        let(:collection) { Set.new }
+      end
+    end
+    """
+    When I run `rspec shared_example_group_spec.rb --format documentation`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      Array
+        behaves like a collection object
+          <<
+            adds objects to the end of the collection
+
+      Set
+        behaves like a collection object
+          <<
+            adds objects to the end of the collection
+      """
+
+  Scenario: Passing parameters to a shared example group
+    Given a file named "shared_example_group_params_spec.rb" with:
+    """ruby
+    shared_examples "a measurable object" do |measurement, measurement_methods|
+      measurement_methods.each do |measurement_method|
+        it "should return #{measurement} from ##{measurement_method}" do
+          subject.send(measurement_method).should == measurement
+        end
+      end
+    end
+
+    describe Array, "with 3 items" do
+      subject { [1, 2, 3] }
+      it_should_behave_like "a measurable object", 3, [:size, :length]
+    end
+
+    describe String, "of 6 characters" do
+      subject { "FooBar" }
+      it_should_behave_like "a measurable object", 6, [:size, :length]
+    end
+    """
+    When I run `rspec shared_example_group_params_spec.rb --format documentation`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      Array with 3 items
+        it should behave like a measurable object
+          should return 3 from #size
+          should return 3 from #length
+
+      String of 6 characters
+        it should behave like a measurable object
+          should return 6 from #size
+          should return 6 from #length
+      """
+
+  Scenario: Aliasing "it_should_behave_like" to "it_has_behavior"
+    Given a file named "shared_example_group_spec.rb" with:
+      """ruby
+      RSpec.configure do |c|
+        c.alias_it_should_behave_like_to :it_has_behavior, 'has behavior:'
+      end
+
+      shared_examples 'sortability' do
+        it 'responds to <=>' do
+          sortable.should respond_to(:<=>)
+        end
+      end
+
+      describe String do
+        it_has_behavior 'sortability' do
+          let(:sortable) { 'sample string' }
+        end
+      end
+      """
+    When I run `rspec shared_example_group_spec.rb --format documentation`
+    Then the examples should all pass
+    And the output should contain:
+      """
+      String
+        has behavior: sortability
+          responds to <=>
+      """
+
+  Scenario: Sharing metadata automatically includes shared example groups
+    Given a file named "shared_example_metadata_spec.rb" with:
+      """ruby
+      shared_examples "shared stuff", :a => :b do
+        it 'runs wherever the metadata is shared' do
+        end
+      end
+
+      describe String, :a => :b do
+      end
+      """
+      When I run `rspec shared_example_metadata_spec.rb`
+      Then the output should contain:
+        """
+        1 example, 0 failures
+        """
+
+  Scenario: Shared examples are nestable by context
+    Given a file named "context_specific_examples_spec.rb" with:
+      """Ruby
+      describe "shared examples" do
+        context "per context" do
+
+          shared_examples "shared examples are nestable" do
+            specify { expect(true).to eq true }
+          end
+
+          it_behaves_like "shared examples are nestable"
+        end
+      end
+      """
+    When I run `rspec context_specific_examples_spec.rb`
+    Then the output should contain:
+      """
+      1 example, 0 failures
+      """
+
+  Scenario: Shared examples are accessible from offspring contexts
+    Given a file named "context_specific_examples_spec.rb" with:
+      """Ruby
+      describe "shared examples" do
+        shared_examples "shared examples are nestable" do
+          specify { expect(true).to eq true }
+        end
+
+        context "per context" do
+          it_behaves_like "shared examples are nestable"
+        end
+      end
+      """
+    When I run `rspec context_specific_examples_spec.rb`
+    Then the output should contain:
+      """
+      1 example, 0 failures
+      """
+    And the output should not contain:
+      """
+      Accessing shared_examples defined across contexts is deprecated
+      """
+
+  Scenario: Shared examples are isolated per context
+    Given a file named "isolated_shared_examples_spec.rb" with:
+      """Ruby
+      describe "shared examples" do
+        context do
+          shared_examples "shared examples are isolated" do
+            specify { expect(true).to eq true }
+          end
+        end
+
+        context do
+          it_behaves_like "shared examples are isolated"
+        end
+      end
+      """
+    When I run `rspec isolated_shared_examples_spec.rb`
+    Then the output should contain:
+      """
+      1 example, 0 failures
+      """
+    But the output should contain:
+      """
+      Accessing shared_examples defined across contexts is deprecated
+      """
+    And the output should contain:
+      """
+      isolated_shared_examples_spec.rb:9
+      """