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

transpec 3.0.0 → 3.0.1

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/operator_spec.rb DELETED Viewed

@@ -1,871 +0,0 @@
-# coding: utf-8
-require 'spec_helper'
-require 'transpec/syntax/operator'
-require 'transpec/syntax/should'
-module Transpec
-  class Syntax
-    describe Operator do
-      include ::AST::Sexp
-      include_context 'parsed objects'
-      include_context 'syntax object', Should, :should_object
-      subject(:matcher) { should_object.operator_matcher }
-      let(:record) { matcher.report.records.first }
-      describe '#method_name' do
-        let(:source) do
-          <<-END
-            describe 'example' do
-              it 'is 1' do
-                subject.should == 1
-              end
-            end
-          END
-        end
-        it 'returns the method name' do
-          matcher.method_name.should == :==
-        end
-      end
-      describe '#convert_operator!' do
-        before do
-          matcher.convert_operator!(parenthesize_arg)
-        end
-        let(:parenthesize_arg) { true }
-        context 'with expression `== 1`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should == 1
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should eq(1)
-                end
-              end
-            END
-          end
-          it 'converts to `eq(1)` form' do
-            rewritten_source.should == expected_source
-          end
-          it 'adds record `== expected` -> `eq(expected)`' do
-            record.old_syntax.should == '== expected'
-            record.new_syntax.should == 'eq(expected)'
-            record.annotation.should be_nil
-          end
-          # Operator methods allow their argument to be in the next line,
-          # but non-operator methods do not.
-          #
-          # [1] pry(main)> 1 ==
-          # [1] pry(main)* 1
-          # => true
-          # [2] pry(main)> 1.eql?
-          # ArgumentError: wrong number of arguments (0 for 1)
-          context 'and its argument is in the next line' do
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  it 'is 1' do
-                    subject.should ==
-                      1
-                  end
-                end
-              END
-            end
-            let(:expected_source) do
-              <<-END
-                describe 'example' do
-                  it 'is 1' do
-                    subject.should eq(
-                      1
-                    )
-                  end
-                end
-              END
-            end
-            it 'inserts parentheses properly' do
-              rewritten_source.should == expected_source
-            end
-            context 'and false is passed as `parenthesize_arg` argument' do
-              let(:parenthesize_arg) { false }
-              it 'inserts parentheses properly because they are necessary' do
-                rewritten_source.should == expected_source
-              end
-            end
-          end
-        end
-        context 'with expression `==1`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should==1
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should eq(1)
-                end
-              end
-            END
-          end
-          it 'converts to `eq(1)` form' do
-            rewritten_source.should == expected_source
-          end
-          context 'and false is passed as `parenthesize_arg` argument' do
-            let(:parenthesize_arg) { false }
-            let(:expected_source) do
-              <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should eq 1
-                end
-              end
-              END
-            end
-            it 'converts to `eq 1` form' do
-              rewritten_source.should == expected_source
-            end
-          end
-        end
-        context 'with expression `be == 1`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should be == 1
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should eq(1)
-                end
-              end
-            END
-          end
-          it 'converts to `eq(1)` form' do
-            rewritten_source.should == expected_source
-          end
-          it 'adds record `== expected` -> `eq(expected)`' do
-            record.old_syntax.should == '== expected'
-            record.new_syntax.should == 'eq(expected)'
-            record.annotation.should be_nil
-          end
-        end
-        context 'with expression `be.==(1)`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should be.==(1)
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should eq(1)
-                end
-              end
-            END
-          end
-          it 'converts to `eq(1)` form' do
-            rewritten_source.should == expected_source
-          end
-        end
-        context 'with expression `== (2 - 1)`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should == (2 - 1)
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should eq(2 - 1)
-                end
-              end
-            END
-          end
-          it 'converts to `eq(2 - 1)` form without superfluous parentheses' do
-            rewritten_source.should == expected_source
-          end
-        end
-        context 'with expression `== (5 - 3) / (4 - 2)`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should == (5 - 3) / (4 - 2)
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should eq((5 - 3) / (4 - 2))
-                end
-              end
-            END
-          end
-          it 'converts to `eq((5 - 3) / (4 - 2))` form' do
-            rewritten_source.should == expected_source
-          end
-        end
-        context "with expression `== { 'key' => 'value' }`" do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is the hash' do
-                  subject.should == { 'key' => 'value' }
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'is the hash' do
-                  subject.should eq({ 'key' => 'value' })
-                end
-              end
-            END
-          end
-          it "converts to `eq({ 'key' => 'value' })` form" do
-            rewritten_source.should == expected_source
-          end
-          context 'and false is passed as `parenthesize_arg` argument' do
-            let(:parenthesize_arg) { false }
-            it 'inserts parentheses to avoid the hash from be interpreted as a block' do
-              rewritten_source.should == expected_source
-            end
-          end
-        end
-        [
-          [:===, 'case-equals to'],
-          [:<,   'is less than'],
-          [:<=,  'is less than or equals to'],
-          [:>,   'is greater than'],
-          [:>=,  'is greater than or equals to']
-        ].each do |operator, description|
-          context "with expression `#{operator} 1`" do
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  it '#{description} 1' do
-                    subject.should #{operator} 1
-                  end
-                end
-              END
-            end
-            let(:expected_source) do
-              <<-END
-                describe 'example' do
-                  it '#{description} 1' do
-                    subject.should be #{operator} 1
-                  end
-                end
-              END
-            end
-            it "converts to `be #{operator} 1` form" do
-              rewritten_source.should == expected_source
-            end
-            it "adds record `#{operator} expected` -> `be #{operator} expected`" do
-              record.old_syntax.should == "#{operator} expected"
-              record.new_syntax.should == "be #{operator} expected"
-              record.annotation.should be_nil
-            end
-          end
-          context "with expression `be #{operator} 1`" do
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  it '#{description} 1' do
-                    subject.should be #{operator} 1
-                  end
-                end
-              END
-            end
-            it 'does nothing' do
-              rewritten_source.should == source
-            end
-            it 'reports nothing' do
-              matcher.report.records.should be_empty
-            end
-          end
-        end
-        context 'with expression `=~ /pattern/`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'matches the pattern' do
-                  subject.should =~ /pattern/
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'matches the pattern' do
-                  subject.should match(/pattern/)
-                end
-              end
-            END
-          end
-          it 'converts to `match(/pattern/)` form' do
-            rewritten_source.should == expected_source
-          end
-          it 'adds record `=~ /pattern/` -> `match(/pattern/)` without annotation' do
-            record.old_syntax.should == '=~ /pattern/'
-            record.new_syntax.should == 'match(/pattern/)'
-            record.annotation.should be_nil
-          end
-        end
-        context 'with expression `=~/pattern/`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'matches the pattern' do
-                  subject.should=~/pattern/
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'matches the pattern' do
-                  subject.should match(/pattern/)
-                end
-              end
-            END
-          end
-          it 'converts to `match(/pattern/)` form' do
-            rewritten_source.should == expected_source
-          end
-        end
-        context 'with expression `be =~ /pattern/`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'matches the pattern' do
-                  subject.should be =~ /pattern/
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'matches the pattern' do
-                  subject.should match(/pattern/)
-                end
-              end
-            END
-          end
-          it 'converts to `match(/pattern/)` form' do
-            rewritten_source.should == expected_source
-          end
-        end
-        context 'with expression `=~ [1, 2]`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'contains 1 and 2' do
-                  subject.should =~ [1, 2]
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'contains 1 and 2' do
-                  subject.should match_array([1, 2])
-                end
-              end
-            END
-          end
-          it 'converts to `match_array([1, 2])` form' do
-            rewritten_source.should == expected_source
-          end
-          it 'adds record `=~ [1, 2]` -> `match_array([1, 2])` without annotation' do
-            record.old_syntax.should == '=~ [1, 2]'
-            record.new_syntax.should == 'match_array([1, 2])'
-            record.annotation.should be_nil
-          end
-        end
-        context 'with expression `=~[1, 2]`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'contains 1 and 2' do
-                  subject.should=~[1, 2]
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'contains 1 and 2' do
-                  subject.should match_array([1, 2])
-                end
-              end
-            END
-          end
-          it 'converts to `match_array([1, 2])` form' do
-            rewritten_source.should == expected_source
-          end
-        end
-        context 'with expression `be =~ [1, 2]`' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'contains 1 and 2' do
-                  subject.should be =~ [1, 2]
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it 'contains 1 and 2' do
-                  subject.should match_array([1, 2])
-                end
-              end
-            END
-          end
-          it 'converts to `match_array([1, 2])` form' do
-            rewritten_source.should == expected_source
-          end
-        end
-        context 'with expression `=~ variable`' do
-          context 'and runtime type of the variable is array' do
-            include_context 'dynamic analysis objects'
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  it 'contains 1 and 2' do
-                    variable = [1, 2]
-                    [2, 1].should =~ variable
-                  end
-                end
-              END
-            end
-            let(:expected_source) do
-              <<-END
-                describe 'example' do
-                  it 'contains 1 and 2' do
-                    variable = [1, 2]
-                    [2, 1].should match_array(variable)
-                  end
-                end
-              END
-            end
-            it 'converts to `match_array(variable)` form' do
-              rewritten_source.should == expected_source
-            end
-            it 'adds record `=~ [1, 2]` -> `match_array([1, 2])` without annotation' do
-              record.old_syntax.should == '=~ [1, 2]'
-              record.new_syntax.should == 'match_array([1, 2])'
-              record.annotation.should be_nil
-            end
-          end
-          context 'and runtime type of the variable is regular expression' do
-            include_context 'dynamic analysis objects'
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  it 'matches to the pattern' do
-                    variable = /^str/
-                    'string'.should =~ variable
-                  end
-                end
-              END
-            end
-            let(:expected_source) do
-              <<-END
-                describe 'example' do
-                  it 'matches to the pattern' do
-                    variable = /^str/
-                    'string'.should match(variable)
-                  end
-                end
-              END
-            end
-            it 'converts to `match(variable)` form' do
-              rewritten_source.should == expected_source
-            end
-            it 'adds record `=~ /pattern/` -> `match(/pattern/)` without annotation' do
-              record.old_syntax.should == '=~ /pattern/'
-              record.new_syntax.should == 'match(/pattern/)'
-              record.annotation.should be_nil
-            end
-          end
-          context 'and no runtime type information is provided' do
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  it 'matches the pattern' do
-                    subject.should =~ variable
-                  end
-                end
-              END
-            end
-            let(:expected_source) do
-              <<-END
-                describe 'example' do
-                  it 'matches the pattern' do
-                    subject.should match(variable)
-                  end
-                end
-              END
-            end
-            it 'converts to `match(variable)` form' do
-              rewritten_source.should == expected_source
-            end
-            it 'adds record `=~ /pattern/` -> `match(/pattern/)` with annotation' do
-              record.old_syntax.should == '=~ /pattern/'
-              record.new_syntax.should == 'match(/pattern/)'
-              record.annotation.message.should ==
-                'The `=~ variable` has been converted but it might possibly be incorrect ' \
-                "due to a lack of runtime information. It's recommended to review the change carefully."
-              record.annotation.source_range.source.should == '=~ variable'
-            end
-          end
-        end
-        context 'with expression `be =~ variable`' do
-          context 'and no runtime type information is provided' do
-            let(:source) do
-              <<-END
-                describe 'example' do
-                  it 'matches the pattern' do
-                    subject.should be =~ variable
-                  end
-                end
-              END
-            end
-            let(:expected_source) do
-              <<-END
-                describe 'example' do
-                  it 'matches the pattern' do
-                    subject.should match(variable)
-                  end
-                end
-              END
-            end
-            it 'converts to `match(variable)` form' do
-              rewritten_source.should == expected_source
-            end
-            it 'adds record `=~ /pattern/` -> `match(/pattern/)` with annotation' do
-              record.old_syntax.should == '=~ /pattern/'
-              record.new_syntax.should == 'match(/pattern/)'
-              record.annotation.message.should ==
-                'The `be =~ variable` has been converted but it might possibly be incorrect ' \
-                "due to a lack of runtime information. It's recommended to review the change carefully."
-              record.annotation.source_range.source.should == 'be =~ variable'
-            end
-          end
-        end
-      end
-      describe '#parenthesize!' do
-        before do
-          matcher.parenthesize!(always)
-        end
-        let(:always) { true }
-        context 'when its argument is already in parentheses' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should ==(1)
-                end
-              end
-            END
-          end
-          it 'does nothing' do
-            rewritten_source.should == source
-          end
-        end
-        context 'when its argument is not in parentheses' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should == 1
-                end
-              end
-            END
-          end
-          context 'and true is passed as `always` argument' do
-            let(:always) { true }
-            let(:expected_source) do
-              <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should ==(1)
-                end
-              end
-              END
-            end
-            it 'inserts parentheses' do
-              rewritten_source.should == expected_source
-            end
-          end
-          context 'and false is passed as `always` argument' do
-            let(:always) { false }
-            let(:expected_source) do
-              <<-END
-              describe 'example' do
-                it 'is 1' do
-                  subject.should == 1
-                end
-              end
-              END
-            end
-            it 'does not nothing' do
-              rewritten_source.should == expected_source
-            end
-          end
-        end
-        context 'when its argument is a string literal' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it "is 'string'" do
-                  subject.should == 'string'
-                end
-              end
-            END
-          end
-          let(:expected_source) do
-            <<-END
-              describe 'example' do
-                it "is 'string'" do
-                  subject.should ==('string')
-                end
-              end
-            END
-          end
-          it 'inserts parentheses' do
-            rewritten_source.should == expected_source
-          end
-        end
-        context 'when its argument is a here document' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'returns the document' do
-                  subject.should == <<-HEREDOC
-                  foo
-                  HEREDOC
-                end
-              end
-            END
-          end
-          # (block
-          #   (send nil :it
-          #     (str "returns the document"))
-          #   (args)
-          #   (send
-          #     (send nil :subject) :should
-          #     (send nil :eq
-          #       (str "                foo\n"))))
-          it 'does nothing' do
-            rewritten_source.should == source
-          end
-        end
-        context 'when its argument is a here document with chained method' do
-          let(:source) do
-            <<-END
-              describe 'example' do
-                it 'returns the document' do
-                  subject.should == <<-HEREDOC.gsub('foo', 'bar')
-                  foo
-                  HEREDOC
-                end
-              end
-            END
-          end
-          # (block
-          #   (send nil :it
-          #     (str "returns the document"))
-          #   (args)
-          #   (send
-          #     (send nil :subject) :should
-          #     (send nil :eq
-          #       (send
-          #         (str "                foo\n") :gsub
-          #         (str "foo")
-          #         (str "bar")))))
-          it 'does nothing' do
-            rewritten_source.should == source
-          end
-        end
-        context 'when its argument is a here document with interpolation' do
-          let(:source) do
-            <<-'END'
-              it 'returns the document' do
-                string = 'foo'
-                subject.should == <<-HEREDOC
-                #{string}
-                HEREDOC
-              end
-            END
-          end
-          # (block
-          #   (send nil :it
-          #     (str "returns the document"))
-          #   (args)
-          #   (begin
-          #     (lvasgn :string
-          #       (str "foo"))
-          #     (send
-          #       (send nil :subject) :should
-          #       (send nil :eq
-          #         (dstr
-          #           (str "                ")
-          #           (begin
-          #             (lvar :string))
-          #           (str "\n"))))))
-          it 'does nothing' do
-            rewritten_source.should == source
-          end
-        end
-      end
-    end
-  end
-end