RubyGems - transpec - Versions diffs - 3.0.0 → 3.0.1 - Mend

transpec 3.0.0 → 3.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (53) hide show

checksums.yaml +4 -4
data/.rubocop.yml +2 -0
data/CHANGELOG.md +4 -0
data/lib/transpec/version.rb +1 -1
data/transpec.gemspec +4 -3
metadata +3 -97
data/spec/.rubocop.yml +0 -23
data/spec/integration/configuration_modification_spec.rb +0 -186
data/spec/integration/conversion_spec.rb +0 -145
data/spec/spec_helper.rb +0 -52
data/spec/support/cache_helper.rb +0 -62
data/spec/support/file_helper.rb +0 -25
data/spec/support/shared_context.rb +0 -84
data/spec/transpec/cli_spec.rb +0 -341
data/spec/transpec/commit_message_spec.rb +0 -81
data/spec/transpec/config_spec.rb +0 -99
data/spec/transpec/converter_spec.rb +0 -1374
data/spec/transpec/directory_cloner_spec.rb +0 -74
data/spec/transpec/dynamic_analyzer/rewriter_spec.rb +0 -143
data/spec/transpec/dynamic_analyzer_spec.rb +0 -329
data/spec/transpec/git_spec.rb +0 -151
data/spec/transpec/option_parser_spec.rb +0 -275
data/spec/transpec/processed_source_spec.rb +0 -93
data/spec/transpec/project_spec.rb +0 -194
data/spec/transpec/record_spec.rb +0 -128
data/spec/transpec/report_spec.rb +0 -126
data/spec/transpec/rspec_version_spec.rb +0 -129
data/spec/transpec/spec_file_finder_spec.rb +0 -118
data/spec/transpec/spec_suite_spec.rb +0 -108
data/spec/transpec/static_context_inspector_spec.rb +0 -713
data/spec/transpec/syntax/allow_spec.rb +0 -122
data/spec/transpec/syntax/be_boolean_spec.rb +0 -176
data/spec/transpec/syntax/be_close_spec.rb +0 -51
data/spec/transpec/syntax/current_example_spec.rb +0 -319
data/spec/transpec/syntax/double_spec.rb +0 -175
data/spec/transpec/syntax/example_group_spec.rb +0 -716
data/spec/transpec/syntax/example_spec.rb +0 -301
data/spec/transpec/syntax/expect_spec.rb +0 -313
data/spec/transpec/syntax/have_spec.rb +0 -1276
data/spec/transpec/syntax/hook_spec.rb +0 -215
data/spec/transpec/syntax/its_spec.rb +0 -448
data/spec/transpec/syntax/matcher_definition_spec.rb +0 -59
data/spec/transpec/syntax/method_stub_spec.rb +0 -1301
data/spec/transpec/syntax/oneliner_should_spec.rb +0 -628
data/spec/transpec/syntax/operator_spec.rb +0 -871
data/spec/transpec/syntax/pending_spec.rb +0 -415
data/spec/transpec/syntax/raise_error_spec.rb +0 -354
data/spec/transpec/syntax/receive_spec.rb +0 -499
data/spec/transpec/syntax/rspec_configure_spec.rb +0 -870
data/spec/transpec/syntax/should_receive_spec.rb +0 -1108
data/spec/transpec/syntax/should_spec.rb +0 -497
data/spec/transpec/util_spec.rb +0 -115
data/spec/transpec_spec.rb +0 -22

data/spec/transpec/syntax/example_spec.rb DELETED Viewed

@@ -1,301 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-require 'transpec/syntax/example'
-require 'ast'
-module Transpec
-  class Syntax
-    describe Example do
-      include ::AST::Sexp
-      include_context 'parsed objects'
-      include_context 'syntax object', Example, :example_object
-      let(:record) { example_object.report.records.last }
-      describe '#conversion_target?' do
-        let(:target_node) do
-          ast.each_node(:send).find do |send_node|
-            method_name = send_node.children[1]
-            method_name == :pending
-          end
-        end
-        let(:example_object) do
-          Example.new(target_node, runtime_data)
-        end
-        subject { example_object.conversion_target? }
-        context 'when #pending example node is passed' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                pending 'will be skipped' do
-                end
-              end
-            END
-          end
-          context 'without runtime information' do
-            it { should be_true }
-          end
-          context 'with runtime information' do
-            include_context 'dynamic analysis objects'
-            it { should be_true }
-          end
-        end
-        context 'when #pending specification node inside of an example is passed' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'will be skipped' do
-                  pending
-                end
-              end
-            END
-          end
-          context 'without runtime information' do
-            it { should be_false }
-          end
-          context 'with runtime information' do
-            include_context 'dynamic analysis objects'
-            it { should be_false }
-          end
-        end
-      end
-      describe '#metadata_key_nodes' do
-        subject { example_object.metadata_key_nodes }
-        context 'with expression `it { }`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it { do_something }
-              end
-            END
-          end
-          it 'returns empty array' do
-            should be_empty
-          end
-        end
-        context "with expression `it 'description' { }`" do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is an example' do
-                  do_something
-                end
-              end
-            END
-          end
-          it 'returns empty array' do
-            should be_empty
-          end
-        end
-        context "with expression `it 'description', :foo { }`" do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is an example', :foo do
-                  do_something
-                end
-              end
-            END
-          end
-          it 'returns [(sym :foo)]' do
-            should == [s(:sym, :foo)]
-          end
-        end
-        context "with expression `it 'description', foo: true { }`" do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is an example', foo: true do
-                  do_something
-                end
-              end
-            END
-          end
-          it 'returns [(sym :foo)]' do
-            should == [s(:sym, :foo)]
-          end
-        end
-        context "with expression `it 'description', :foo, :bar, baz: true { }`" do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is an example', :foo, :bar, baz: true do
-                  do_something
-                end
-              end
-            END
-          end
-          it 'returns [s(:sym, :foo), s(:sym, :bar), s(:sym, :baz)]' do
-            should == [s(:sym, :foo), s(:sym, :bar), s(:sym, :baz)]
-          end
-        end
-      end
-      describe '#convert_pending_to_skip!' do
-        before do
-          example_object.convert_pending_to_skip!
-        end
-        context "with expression `pending 'is an example' { }`" do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                pending 'will be skipped' do
-                  do_something
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                skip 'will be skipped' do
-                  do_something
-                end
-              end
-            END
-          end
-          it "converts to `skip 'is an example' { }` form" do
-            rewritten_source.should == expected_source
-          end
-          it "adds record `pending 'is an example' { }` -> `skip 'is an example' { }`" do
-            record.old_syntax.should == "pending 'is an example' { }"
-            record.new_syntax.should == "skip 'is an example' { }"
-          end
-        end
-        context "with expression `it 'is an example' { }`" do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is normal example' do
-                  do_something
-                end
-              end
-            END
-          end
-          it 'does nothing' do
-            rewritten_source.should == source
-          end
-        end
-        context "with expression `it 'is an example', :pending { }`" do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'will be skipped', :pending do
-                  do_something
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'will be skipped', :skip do
-                  do_something
-                end
-              end
-            END
-          end
-          it "converts to `it 'is an example', :skip { }` form" do
-            rewritten_source.should == expected_source
-          end
-          it "adds record `it 'is an example', :pending { }` -> `it 'is an example', :skip { }`" do
-            record.old_syntax.should == "it 'is an example', :pending { }"
-            record.new_syntax.should == "it 'is an example', :skip { }"
-          end
-        end
-        context "with expression `it 'description', :pending => true { }`" do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'will be skipped', :pending => true do
-                  do_something
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'will be skipped', :skip => true do
-                  do_something
-                end
-              end
-            END
-          end
-          it "converts to `it 'description', :skip => true { }` form" do
-            rewritten_source.should == expected_source
-          end
-          it "adds record `it 'is an example', :pending => value { }` -> `it 'is an example', :skip => value { }`" do
-            record.old_syntax.should == "it 'is an example', :pending => value { }"
-            record.new_syntax.should == "it 'is an example', :skip => value { }"
-          end
-        end
-        context "with expression `it 'description', pending: true { }`" do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'will be skipped', pending: true do
-                  do_something
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'will be skipped', skip: true do
-                  do_something
-                end
-              end
-            END
-          end
-          it "converts to `it 'description', skip: true { }` form" do
-            rewritten_source.should == expected_source
-          end
-          it "adds record `it 'is an example', :pending => value { }` -> `it 'is an example', :skip => value { }`" do
-            record.old_syntax.should == "it 'is an example', :pending => value { }"
-            record.new_syntax.should == "it 'is an example', :skip => value { }"
-          end
-        end
-      end
-    end
-  end
-end

data/spec/transpec/syntax/expect_spec.rb DELETED Viewed

@@ -1,313 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-require 'transpec/syntax/expect'
-module Transpec
-  class Syntax
-    describe Expect do
-      include_context 'parsed objects'
-      include_context 'syntax object', Expect, :expect_object
-      describe '#conversion_target?' do
-        let(:target_node) do
-          ast.each_node(:send).find do |send_node|
-            method_name = send_node.children[1]
-            method_name == :expect
-          end
-        end
-        let(:expect_object) do
-          Expect.new(target_node)
-        end
-        subject { expect_object.conversion_target? }
-        context 'when the #expect node is chained by #to' do
-          context 'and taking a matcher properly' do
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  it 'is valid expectation' do
-                    expect(obj).to matcher
-                  end
-                end
-              END
-            end
-            it { should be_true }
-          end
-          context 'but taking no matcher' do
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  it 'is invalid expectation' do
-                    expect(obj).to
-                  end
-                end
-              END
-            end
-            it { should be_false }
-          end
-        end
-        context 'when the #expect node is chained by #not_to' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is valid expectation' do
-                  expect(obj).not_to matcher
-                end
-              end
-            END
-          end
-          it { should be_true }
-        end
-        context 'when the #expect node is not chained' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is invalid expectation' do
-                  expect(obj)
-                end
-              end
-            END
-          end
-          it { should be_false }
-        end
-        context 'when the #expect node is not chained and taken as a argument by another method' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is invalid expectation' do
-                  do_something(expect(obj))
-                end
-              end
-            END
-          end
-          it { should be_false }
-        end
-      end
-      describe '#subject_node' do
-        context 'when the subject is a normal argument' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is empty' do
-                  expect(subject).to be_empty
-                end
-              end
-            END
-          end
-          it 'returns the subject node' do
-            method_name = expect_object.subject_node.children[1]
-            method_name.should == :subject
-          end
-        end
-        context 'when the subject is a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'raises error' do
-                  expect { do_something }.to raise_error
-                end
-              end
-            END
-          end
-          it 'returns the block node' do
-            expect_object.subject_node.should be_block_type
-          end
-        end
-      end
-      describe '#to_node' do
-        context 'when the subject is a normal argument' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is empty' do
-                  expect(subject).to be_empty
-                end
-              end
-            END
-          end
-          it 'returns #to node' do
-            method_name = expect_object.to_node.children[1]
-            method_name.should == :to
-          end
-        end
-        context 'when the subject is a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'raises error' do
-                  expect { do_something }.to raise_error
-                end
-              end
-            END
-          end
-          it 'returns #to node' do
-            method_name = expect_object.to_node.children[1]
-            method_name.should == :to
-          end
-        end
-      end
-      describe '#matcher_node' do
-        let(:matcher_name) { expect_object.matcher_node.children[1] }
-        context 'when the matcher is not taking a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is empty' do
-                  expect(subject).to be_empty
-                end
-              end
-            END
-          end
-          it 'returns send node of the matcher' do
-            matcher_name.should == :be_empty
-          end
-        end
-        context 'when the matcher is taking a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'receives :foo' do
-                  expect(subject).to receive(:foo) { }
-                end
-              end
-            END
-          end
-          it 'returns send node of the matcher' do
-            matcher_name.should == :receive
-          end
-        end
-        context 'when the matcher is chained by another method' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'receives :foo twice' do
-                  expect(subject).to receive(:foo).twice
-                end
-              end
-            END
-          end
-          it 'returns the first node of the chain' do
-            matcher_name.should == :receive
-          end
-        end
-        context 'when the matcher is chained by another method that is taking a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'receives :foo twice' do
-                  expect(subject).to receive(:foo).twice { }
-                end
-              end
-            END
-          end
-          it 'returns the first node of the chain' do
-            matcher_name.should == :receive
-          end
-        end
-      end
-      describe '#have_matcher' do
-        subject { expect_object.have_matcher }
-        let(:source) do
-          <<-END
-            describe 'example' do
-              it 'has 2 items' do
-                expect(subject).to have(2).items
-              end
-            end
-          END
-        end
-        it 'returns an instance of Have' do
-          should be_an(Have)
-        end
-      end
-      describe '#receive_matcher' do
-        subject { expect_object.receive_matcher }
-        let(:source) do
-          <<-END
-            describe 'example' do
-              it 'receives :foo' do
-                expect(subject).to receive(:foo)
-              end
-            end
-          END
-        end
-        it 'returns an instance of Receive' do
-          should be_an(Receive)
-        end
-      end
-      describe '#block_node' do
-        subject { expect_object.block_node }
-        context 'when the #to is taking a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'receives :foo' do
-                  expect(subject).to receive(:foo) do |arg|
-                  end
-                end
-              end
-            END
-          end
-          it 'returns the block node' do
-            should be_block_type
-          end
-        end
-        context 'when the #to is not taking a block' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'receives :foo' do
-                  expect(subject).to receive(:foo) { |arg|
-                  }
-                end
-              end
-            END
-          end
-          it 'returns nil' do
-            should be_nil
-          end
-        end
-      end
-    end
-  end
-end