transpec 0.2.6 → 1.0.0

data/spec/transpec/dynamic_analyzer/rewriter_spec.rb

@@ -0,0 +1,183 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'transpec/dynamic_analyzer/rewriter'
+
+module Transpec
+  class DynamicAnalyzer
+    describe Rewriter do
+      include ::AST::Sexp
+
+      subject(:rewriter) { Rewriter.new }
+
+      describe '#rewrite' do
+        subject { rewriter.rewrite(source) }
+
+        let(:source) do
+          <<-END
+            describe 'example' do
+              it 'is foo' do
+                subject.should be(foo)
+              end
+            end
+          END
+        end
+
+        # rubocop:disable LineLength
+        let(:expected_source) do
+          <<-END
+            describe 'example' do
+              it 'is foo' do
+                transpec_analysis((transpec_analysis((subject), self, { :should_source_location => [:object, "method(:should).source_location"] }, __FILE__, 79, 86).should be(foo)), self, { :expect_available? => [:context, "self.class.name.start_with?('RSpec::') && respond_to?(:expect)"] }, __FILE__, 79, 101)
+              end
+            end
+          END
+        end
+        # rubocop:enable LineLength
+
+        it 'wraps target object with analysis helper method' do
+          should == expected_source
+        end
+
+        context 'when the target includes here document' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'matches to foo' do
+                  subject.should =~ <<-HEREDOC.gsub('foo', 'bar')
+                  foo
+                  HEREDOC
+                end
+              end
+            END
+          end
+
+          # rubocop:disable LineLength
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'matches to foo' do
+                  transpec_analysis((transpec_analysis((subject), self, { :should_source_location => [:object, "method(:should).source_location"] }, __FILE__, 93, 100).should), self, { :expect_available? => [:context, "self.class.name.start_with?('RSpec::') && respond_to?(:expect)"] }, __FILE__, 93, 107) =~ transpec_analysis((<<-HEREDOC.gsub('foo', 'bar')
+                  foo
+                  HEREDOC
+                  ), self, { :arg_is_enumerable? => [:object, "is_a?(Enumerable)"] }, __FILE__, 111, 188)
+                end
+              end
+            END
+          end
+          # rubocop:enable LineLength
+
+          it 'wraps the here document properly' do
+            should == expected_source
+          end
+        end
+
+        context 'when the target takes block' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'raises error' do
+                  expect { do_something }.to throw_symbol
+                end
+              end
+            END
+          end
+
+          # rubocop:disable LineLength
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'raises error' do
+                  transpec_analysis((expect { do_something }), self, { :expect_source_location => [:context, "method(:expect).source_location"] }, __FILE__, 91, 97).to throw_symbol
+                end
+              end
+            END
+          end
+          # rubocop:enable LineLength
+
+          it 'wraps the block properly' do
+            should == expected_source
+          end
+        end
+
+        context 'when the target is only the expression in a block' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'raises error' do
+                  expect
+                end
+              end
+            END
+          end
+
+          # rubocop:disable LineLength
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'raises error' do
+                  transpec_analysis((expect), self, { :expect_source_location => [:context, "method(:expect).source_location"] }, __FILE__, 91, 97)
+                end
+              end
+            END
+          end
+          # rubocop:enable LineLength
+
+          it 'wraps the target properly' do
+            should == expected_source
+          end
+        end
+
+        context 'when the target is method invocation without parentheses' do
+          let(:source) do
+            <<-END
+              describe 'example' do
+                it 'raises error' do
+                  expect subject
+                end
+              end
+            END
+          end
+
+          # rubocop:disable LineLength
+          let(:expected_source) do
+            <<-END
+              describe 'example' do
+                it 'raises error' do
+                  transpec_analysis((expect subject), self, { :expect_source_location => [:context, "method(:expect).source_location"] }, __FILE__, 91, 105)
+                end
+              end
+            END
+          end
+          # rubocop:enable LineLength
+
+          it 'wraps the target properly' do
+            should == expected_source
+          end
+        end
+      end
+
+      describe '#register_request' do
+        let(:some_node) { s(:int, 1) }
+        let(:another_node) { s(:int, 2) }
+
+        it 'stores requests for each node' do
+          rewriter.register_request(some_node, :odd, 'odd?', :object)
+          rewriter.register_request(another_node, :even, 'even?', :object)
+          rewriter.requests.should == {
+            some_node    => { odd: [:object, 'odd?'] },
+            another_node => { even: [:object, 'even?'] }
+          }
+        end
+
+        it 'merges multiple requests for same node' do
+          rewriter.register_request(some_node, :odd, 'odd?', :object)
+          rewriter.register_request(some_node, :even, 'even?', :object)
+          rewriter.requests.should == {
+            some_node => { odd: [:object, 'odd?'], even: [:object, 'even?'] }
+          }
+        end
+      end
+    end
+  end
+end

data/spec/transpec/dynamic_analyzer_spec.rb

@@ -0,0 +1,164 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'transpec/dynamic_analyzer'
+
+module Transpec
+  describe DynamicAnalyzer do
+    include FileHelper
+    include ::AST::Sexp
+    include_context 'isolated environment'
+
+    subject(:dynamic_analyzer) { DynamicAnalyzer.new(rspec_command: rspec_command, silent: true) }
+    let(:rspec_command) { nil }
+
+    describe '.new' do
+      context 'when when block is passed' do
+        it 'yields instance' do
+          yielded = false
+
+          DynamicAnalyzer.new(silent: true) do |analyzer|
+            yielded = true
+            analyzer.should be_a(DynamicAnalyzer)
+          end
+
+          yielded.should be_true
+        end
+
+        it 'changes working directory to copied project directory' do
+          initial_directory = Dir.pwd
+          DynamicAnalyzer.new(silent: true) do |analyzer|
+            Dir.pwd.should_not == initial_directory
+          end
+        end
+      end
+    end
+
+    describe '#rspec_command' do
+      subject { dynamic_analyzer.rspec_command }
+
+      context 'when command is specified' do
+        let(:rspec_command) { 'rspec some_argument' }
+
+        it 'returns the specified command' do
+          should == rspec_command
+        end
+      end
+
+      context 'when command is not specified' do
+        context 'and there is a Gemfile' do
+          before do
+            create_file('Gemfile', '')
+          end
+
+          it 'returns "bundle exec rspec"' do
+            should == 'bundle exec rspec'
+          end
+        end
+
+        context 'and there is no Gemfile' do
+          it 'returns "rspec"' do
+            should == 'rspec'
+          end
+        end
+      end
+    end
+
+    describe '#analyze' do
+      let(:source) do
+        <<-END
+          describe [1, 2] do
+            it 'has 2 items' do
+              expect(subject).to have(2).items
+            end
+          end
+        END
+      end
+
+      let(:file_path) { 'spec/example_spec.rb' }
+
+      before do
+        create_file(file_path, source)
+      end
+
+      context 'when already in copied project directory' do
+        it 'does not change working directory' do
+          DynamicAnalyzer.new(silent: true) do |analyzer|
+            Dir.should_not_receive(:chdir)
+            analyzer.analyze
+          end
+        end
+      end
+
+      context 'when no path is passed' do
+        it 'rewrites all files in the "spec" directory' do
+          DynamicAnalyzer::Rewriter.any_instance.should_receive(:rewrite_file!).with(file_path)
+          dynamic_analyzer.analyze
+        end
+      end
+
+      context 'when some paths are passed' do
+        before do
+          create_file('spec/another_spec.rb', '')
+        end
+
+        it 'rewrites only files in the passed paths' do
+          DynamicAnalyzer::Rewriter.any_instance.should_receive(:rewrite_file!).with(file_path)
+          dynamic_analyzer.analyze([file_path])
+        end
+      end
+
+      context 'when there is invalid syntax source file' do
+        before do
+          create_file('spec/fixtures/invalid.rb', 'This is invalid syntax <')
+        end
+
+        it 'does not raise error' do
+          -> { dynamic_analyzer.analyze }.should_not raise_error
+        end
+      end
+
+      runtime_data_cache = {}
+
+      subject(:runtime_data) do
+        if runtime_data_cache[source]
+          runtime_data_cache[source]
+        else
+          runtime_data_cache[source] = dynamic_analyzer.analyze
+        end
+      end
+
+      it 'returns an instance of DynamicAnalyzer::RuntimeData' do
+        runtime_data.should be_an(DynamicAnalyzer::RuntimeData)
+      end
+
+      describe 'its element' do
+        let(:ast) do
+          source_buffer = Parser::Source::Buffer.new(file_path)
+          source_buffer.source = source
+
+          builder = AST::Builder.new
+
+          parser = Parser::CurrentRuby.new(builder)
+          parser.parse(source_buffer)
+        end
+
+        let(:target_node) do
+          ast.each_descendent_node do |node|
+            return node if node == s(:send, nil, :subject)
+          end
+        end
+
+        subject(:element) { runtime_data[target_node] }
+
+        it 'is a hash' do
+          should be_a(Hash)
+        end
+
+        it 'has result of requested analysis' do
+          element[:available_query_methods].result.should =~ [:size, :count, :length]
+        end
+      end
+    end
+  end
+end

data/spec/transpec/file_finder_spec.rb

@@ -0,0 +1,118 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'transpec/file_finder'
+
+module Transpec
+  describe FileFinder do
+    include FileHelper
+
+    describe '.find' do
+      include_context 'isolated environment'
+
+      before do
+        ['file', 'file.rb', 'dir/file', 'dir/file.rb'].each do |path|
+          create_file(path, '')
+        end
+      end
+
+      subject { FileFinder.find(paths) }
+
+      context 'when no path is passed' do
+        let(:paths) { [] }
+
+        context 'and there is "spec" directory' do
+          before do
+            create_file('spec/file.rb', '')
+          end
+
+          it 'returns file paths with .rb extension in the "spec" directory recursively' do
+            should == ['spec/file.rb']
+          end
+        end
+
+        context 'and there is not "spec" directory' do
+          it 'raises error' do
+            -> { FileFinder.find(paths) }.should raise_error(ArgumentError)
+          end
+        end
+      end
+
+      context 'when a file path with .rb extension is passed' do
+        let(:paths) { ['file.rb'] }
+
+        it 'returns the path' do
+          should == ['file.rb']
+        end
+      end
+
+      context 'when a file path without extension is passed' do
+        let(:paths) { ['file'] }
+
+        it 'returns the path' do
+          should == ['file']
+        end
+      end
+
+      context 'when a non-existent path is passed' do
+        let(:paths) { ['non-existent-file'] }
+
+        it 'raises error' do
+          -> { FileFinder.find(paths) }.should raise_error(ArgumentError) { |error|
+            error.message.should == 'No such file or directory "non-existent-file"'
+          }
+        end
+      end
+
+      context 'when a directory path is passed' do
+        let(:paths) { ['dir'] }
+
+        it 'returns file paths with .rb extension in the directory recursively' do
+          should == ['dir/file.rb']
+        end
+      end
+    end
+
+    describe '.base_paths' do
+      include_context 'isolated environment'
+
+      subject { FileFinder.base_paths(paths) }
+
+      context 'when target paths are specified' do
+        let(:paths) { ['foo_spec.rb', 'spec/bar_spec.rb'] }
+
+        it 'returns the passed paths' do
+          should == paths
+        end
+      end
+
+      context 'when paths outside of the current working directory are specified' do
+        let(:paths) { ['../foo_spec.rb', 'spec/bar_spec.rb'] }
+
+        it 'raises error' do
+          -> { FileFinder.base_paths(paths) }.should raise_error(ArgumentError)
+        end
+      end
+
+      context 'when no target paths are specified' do
+        let(:paths) { [] }
+
+        context 'and there is "spec" directory' do
+          before do
+            Dir.mkdir('spec')
+          end
+
+          it 'returns ["spec"]' do
+            should == ['spec']
+          end
+        end
+
+        context 'and there is not "spec" directory' do
+          it 'raises error' do
+            -> { FileFinder.base_paths(paths) }.should raise_error(ArgumentError)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/transpec/option_parser_spec.rb

@@ -0,0 +1,185 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'transpec/option_parser'
+
+module Transpec
+  describe OptionParser do
+    subject(:parser) { OptionParser.new(configuration) }
+    let(:configuration) { Configuration.new }
+
+    describe '#parse' do
+      subject { parser.parse(args) }
+      let(:args) { ['some_file', '--negative-form', 'to_not', 'some_dir'] }
+
+      it 'return non-option arguments' do
+        should == ['some_file', 'some_dir']
+      end
+
+      it 'does not mutate the passed array' do
+        parser.parse(args)
+        args.should == ['some_file', '--negative-form', 'to_not', 'some_dir']
+      end
+
+      describe '-f/--force option' do
+        let(:args) { ['--force'] }
+
+        it 'sets Configuration#forced? true' do
+          parser.parse(args)
+          configuration.forced?.should be_true
+        end
+      end
+
+      describe '-s/--skip-dynamic-analysis option' do
+        let(:args) { ['--skip-dynamic-analysis'] }
+
+        it 'sets Configuration#skip_dynamic_analysis? true' do
+          parser.parse(args)
+          configuration.skip_dynamic_analysis?.should be_true
+        end
+      end
+
+      describe '-m/--generate-commit-message option' do
+        include_context 'isolated environment'
+
+        let(:args) { ['--generate-commit-message'] }
+
+        context 'when inside of git repository' do
+          include_context 'inside of git repository'
+
+          it 'sets Configuration#generate_commit_message? true' do
+            parser.parse(args)
+            configuration.generate_commit_message?.should be_true
+          end
+        end
+
+        context 'when not inside of git repository' do
+          it 'raises error' do
+            -> { parser.parse(args) }.should raise_error(/not in a Git repository/)
+          end
+        end
+      end
+
+      describe '-k/--keep option' do
+        [
+          ['should',         :convert_should?],
+          ['should_receive', :convert_should_receive?],
+          ['stub',           :convert_stub?],
+          ['have_items',     :convert_have_items],
+          ['deprecated',     :convert_deprecated_method?]
+        ].each do |cli_type, config_attr|
+          context "when #{cli_type.inspect} is specified" do
+            let(:args) { ['--keep', cli_type] }
+
+            it "sets Configuration##{config_attr} false" do
+              parser.parse(args)
+              configuration.send(config_attr).should be_false
+            end
+          end
+        end
+
+        context 'when multiple types are specified with comma' do
+          let(:args) { ['--keep', 'should_receive,deprecated'] }
+
+          it 'handles all of them' do
+            parser.parse(args)
+            configuration.convert_should_receive?.should be_false
+            configuration.convert_deprecated_method?.should be_false
+          end
+        end
+
+        context 'when unknown type is specified' do
+          let(:args) { ['--keep', 'unknown'] }
+
+          it 'raises error' do
+            -> { parser.parse(args) }.should raise_error(ArgumentError) { |error|
+              error.message.should == 'Unknown syntax type "unknown"'
+            }
+          end
+        end
+      end
+
+      describe '-n/--negative-form option' do
+        ['not_to', 'to_not'].each do |form|
+          context "when #{form.inspect} is specified" do
+            let(:args) { ['--negative-form', form] }
+
+            it "sets Configuration#negative_form_of_to? #{form.inspect}" do
+              parser.parse(args)
+              configuration.negative_form_of_to.should == form
+            end
+          end
+        end
+      end
+
+      describe '-p/--no-parentheses-matcher-arg option' do
+        let(:args) { ['--no-parentheses-matcher-arg'] }
+
+        it 'sets Configuration#parenthesize_matcher_arg? false' do
+          parser.parse(args)
+          configuration.parenthesize_matcher_arg.should be_false
+        end
+      end
+
+      describe '--no-color option' do
+        before do
+          Sickill::Rainbow.enabled = true
+        end
+
+        let(:args) { ['--no-color'] }
+
+        it 'disables color in the output' do
+          parser.parse(args)
+          Sickill::Rainbow.enabled.should be_false
+        end
+      end
+
+      describe '--version option' do
+        before do
+          parser.stub(:puts)
+          parser.stub(:exit)
+        end
+
+        let(:args) { ['--version'] }
+
+        it 'shows version' do
+          parser.should_receive(:puts).with(Version.to_s)
+          parser.parse(args)
+        end
+
+        it 'exits' do
+          parser.should_receive(:exit)
+          parser.parse(args)
+        end
+      end
+    end
+
+    describe 'help text' do
+      subject(:help_text) do
+        parser.help
+      end
+
+      it 'does not exceed 80 characters in each line' do
+        help_text.each_line do |line|
+          line.chomp.length.should <= 80
+        end
+      end
+
+      it 'describes all conversion types for -k/--keep option' do
+        option_sections = help_text.lines.slice_before(/^\s*-/)
+
+        keep_section = option_sections.find do |lines|
+          lines.first =~ /^\s*-k/
+        end
+
+        conversion_types = keep_section.reduce([]) do |types, line|
+          match = line.match(/^[ ]{37}([a-z_]+)/)
+          next types unless match
+          types << match.captures.first
+        end
+
+        conversion_types.should =~ OptionParser.available_conversion_types.map(&:to_s)
+      end
+    end
+  end
+end