transpec 0.0.1

data/spec/support/shared_context.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+require 'tmpdir'
+
+# This context requires `source` to be defined with #let.
+shared_context 'parsed objects' do
+  let(:source_buffer) do
+    buffer = Parser::Source::Buffer.new('(string)')
+    buffer.source = source
+    buffer
+  end
+
+  let(:ast) do
+    parser = Parser::CurrentRuby.new
+    ast = parser.parse(source_buffer)
+    ast
+  end
+
+  let(:source_rewriter) { Parser::Source::Rewriter.new(source_buffer) }
+
+  let(:rewritten_source) { source_rewriter.process }
+end
+
+shared_context 'should object' do
+  let(:should_object) do
+    Transpec::AST::Scanner.scan(ast) do |node, ancestor_nodes, in_example_group_context|
+      next unless Transpec::Syntax::Should.target_node?(node)
+      return Transpec::Syntax::Should.new(
+        node,
+        ancestor_nodes,
+        in_example_group_context?,
+        source_rewriter
+      )
+    end
+
+    fail 'No should node is found!'
+  end
+
+  let(:in_example_group_context?) { true }
+end
+
+shared_context 'isolated environment' do
+  around do |example|
+    Dir.mktmpdir do |tmpdir|
+      original_home = ENV['HOME']
+
+      begin
+        virtual_home = File.expand_path(File.join(tmpdir, 'home'))
+        Dir.mkdir(virtual_home)
+        ENV['HOME'] = virtual_home
+
+        working_dir = File.join(tmpdir, 'work')
+        Dir.mkdir(working_dir)
+
+        Dir.chdir(working_dir) do
+          example.run
+        end
+      ensure
+        ENV['HOME'] = original_home
+      end
+    end
+  end
+end

data/spec/transpec/ast/scanner_spec.rb

@@ -0,0 +1,177 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+module Transpec
+  module AST
+    describe Scanner do
+      include_context 'parsed objects'
+      include ::AST::Sexp
+
+      let(:source) do
+        <<-END
+          some_var = 1
+
+          RSpec.configure do |config|
+            config.before do
+              prepare_something
+            end
+          end
+
+          module SomeModule
+            SOME_CONST = 1
+
+            describe 'something' do
+              def some_method(some_arg)
+                do_something
+              end
+
+              it 'is 1' do
+                something.should == 1
+              end
+            end
+          end
+        END
+      end
+
+      # (begin
+      #   (lvasgn :some_var
+      #     (int 1))
+      #   (block
+      #     (send
+      #       (const nil :RSpec) :configure)
+      #     (args
+      #       (arg :config))
+      #     (block
+      #       (send
+      #         (lvar :config) :before)
+      #       (args)
+      #       (send nil :prepare_something)))
+      #   (module
+      #     (const nil :SomeModule)
+      #     (begin
+      #       (casgn nil :SOME_CONST
+      #         (int 1))
+      #       (block
+      #         (send nil :describe
+      #           (str "something"))
+      #         (args)
+      #         (begin
+      #           (def :some_method
+      #             (args
+      #               (arg :some_arg))
+      #             (send nil :do_something))
+      #           (block
+      #             (send nil :it
+      #               (str "is 1"))
+      #             (args)
+      #             (send
+      #               (send
+      #                 (send nil :something) :should) :==
+      #               (int 1))))))))
+
+      describe '.scan' do
+        it 'scans nodes with depth first order' do
+          expected_node_type_order = [
+            :begin,
+            :lvasgn,
+            :int,
+            :block,
+            :send,
+            :const,
+            :args
+          ]
+
+          index = 0
+
+          Scanner.scan(ast) do |node|
+            expected_node_type = expected_node_type_order[index]
+            node.type.should == expected_node_type if expected_node_type
+            index += 1
+          end
+
+          index.should_not == 0
+        end
+
+        it 'passes ancestor nodes of the current node to the block' do
+          each_expected_ancestor_nodes_types = [
+            [],
+            [:begin],
+            [:begin, :lvasgn],
+            [:begin],
+            [:begin, :block],
+            [:begin, :block, :send],
+            [:begin, :block],
+            [:begin, :block, :args]
+          ]
+
+          index = 0
+
+          Scanner.scan(ast) do |node, ancestor_nodes|
+            expected_ancestor_node_types = each_expected_ancestor_nodes_types[index]
+            if expected_ancestor_node_types
+              ancestor_node_types = ancestor_nodes.map(&:type)
+              ancestor_node_types.should == expected_ancestor_node_types
+            end
+            index += 1
+          end
+
+          index.should_not == 0
+        end
+      end
+
+      describe '#scope_stack' do
+        def brief_of_node(node)
+          brief = node.type.to_s
+          node.children.each do |child|
+            break if child.is_a?(Parser::AST::Node)
+            brief << " #{child.inspect}"
+          end
+          brief
+        end
+
+        it 'returns current scope stack' do
+          scanner = Scanner.new do |node|
+            expected_scope_stack = begin
+              case brief_of_node(node)
+              when 'lvasgn :some_var'
+                []
+              when 'send nil :prepare_something'
+                [:rspec_configure, :block]
+              when 'module'
+                []
+              when 'const nil :SomeModule'
+                # [:module] # TODO
+              when 'casgn nil :SOME_CONST'
+                [:module]
+              when 'send nil :describe'
+                # [:module] # TODO
+              when 'def :some_method'
+                [:module, :example_group]
+              when 'arg :some_arg'
+                # [:module, :example_group] # TODO
+              when 'send nil :do_something'
+                [:module, :example_group, :def]
+              when 'send nil :it'
+                # [:module, :example_group] # TODO
+              when 'str "is 1"'
+                # [:module, :example_group] # TODO
+              when 'send nil :something'
+                [:module, :example_group, :block]
+              end
+            end
+
+            # TODO: Some scope nodes have special child nodes
+            #   such as their arguments or their subject.
+            #   But from scope point of view, the child nodes are not in the parent's scope,
+            #   they should be in the next outer scope.
+
+            scanner.scope_stack.should == expected_scope_stack if expected_scope_stack
+          end
+
+          scanner.scan(ast, true)
+        end
+      end
+    end
+  end
+end

data/spec/transpec/ast/scope_stack_spec.rb

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+module Transpec
+  module AST
+    describe ScopeStack do
+      describe '#in_example_group_context?' do
+        subject { ScopeStack.new(scopes).in_example_group_context? }
+
+        context 'when in top level' do
+          let(:scopes) { [] }
+          it { should be_false }
+        end
+
+        context 'when in an instance method in top level' do
+          let(:scopes) { [:def] }
+          it { should be_true }
+        end
+
+        context 'when in a block in an instance method in top level' do
+          let(:scopes) { [:def, :block] }
+          it { should be_true }
+        end
+
+        context 'when in #describe block in top level' do
+          let(:scopes) { [:example_group] }
+          it { should be_false }
+        end
+
+        context 'when in #describe block in a module' do
+          let(:scopes) { [:module, :example_group] }
+          it { should be_false }
+        end
+
+        context 'when in an instance method in #describe block' do
+          let(:scopes) { [:example_group, :def] }
+          it { should be_true }
+        end
+
+        context 'when in an instance method in #describe block in a module' do
+          let(:scopes) { [:module, :example_group, :def] }
+          it { should be_true }
+        end
+
+        context 'when in a block in #describe block' do
+          let(:scopes) { [:example_group, :block] }
+          it { should be_true }
+        end
+
+        context 'when in a block in #describe block in a module' do
+          let(:scopes) { [:module, :example_group, :block] }
+          it { should be_true }
+        end
+
+        context 'when in a class in a block in #describe block' do
+          let(:scopes) { [:example_group, :block, :class] }
+          it { should be_false }
+        end
+
+        context 'when in an instance method in a class in a block in #describe block' do
+          let(:scopes) { [:example_group, :block, :class, :def] }
+          it { should be_false }
+        end
+
+        context 'when in an instance method in a module' do
+          # Instance methods of module can be used by `include SomeModule` in #describe block.
+          let(:scopes) { [:module, :def] }
+          it { should be_true }
+        end
+
+        context 'when in an instance method in a class' do
+          let(:scopes) { [:class, :def] }
+          it { should be_false }
+        end
+
+        context 'when in RSpec.configure' do
+          let(:scopes) { [:rspec_configure] }
+          it { should be_false }
+        end
+
+        context 'when in a block in RSpec.configure' do
+          let(:scopes) { [:rspec_configure, :block] }
+          it { should be_true }
+        end
+
+        context 'when in an instance method in RSpec.configure' do
+          let(:scopes) { [:rspec_configure, :def] }
+          it { should be_true }
+        end
+      end
+    end
+  end
+end

data/spec/transpec/cli_spec.rb

@@ -0,0 +1,290 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+module Transpec
+  describe CLI do
+    subject(:cli) { CLI.new }
+
+    describe '.run' do
+      it 'invokes #run' do
+        args = ['foo', 'bar']
+        CLI.any_instance.should_receive(:run).with(args)
+        CLI.run(args)
+      end
+    end
+
+    describe '#forced?' do
+      subject { cli.forced? }
+
+      context 'by default' do
+        it { should be_false }
+      end
+    end
+
+    describe '#run' do
+      before do
+        cli.stub(:puts)
+        cli.stub(:warn)
+        cli.stub(:target_files).and_return(args)
+        Rewriter.stub(:new).and_return(rewriter)
+      end
+
+      subject { cli.run(args) }
+      let(:args) { ['some_file.rb'] }
+      let(:rewriter) { double('rewriter').as_null_object }
+
+      shared_examples 'rewrites files' do
+        it 'rewrites files' do
+          rewriter.should_receive(:rewrite_file!)
+          cli.run(args)
+        end
+
+        it 'returns true' do
+          should be_true
+        end
+      end
+
+      context 'when git is available' do
+        before { Git.stub(:command_available?).and_return(true) }
+
+        context 'and inside of a repository' do
+          before { Git.stub(:inside_of_repository?).and_return(true) }
+
+          context 'and the repository is not clean' do
+            before { Git.stub(:clean?).and_return(false) }
+
+            context '#forced? is false' do
+              before { cli.stub(:forced?).and_return(false) }
+
+              it 'aborts processing' do
+                rewriter.should_not_receive(:rewrite_file!)
+                cli.run(args).should be_false
+              end
+
+              it 'warns to the user' do
+                cli.should_receive(:warn) do |arg|
+                  arg.should include('clean')
+                end
+
+                cli.run(args)
+              end
+            end
+
+            context '#forced? is true' do
+              before { cli.stub(:forced?).and_return(true) }
+              include_examples 'rewrites files'
+            end
+          end
+
+          context 'and the repository is clean' do
+            before { Git.stub(:clean?).and_return(true) }
+            include_examples 'rewrites files'
+          end
+        end
+
+        context 'and not inside of a repository' do
+          before { Git.stub(:inside_of_repository?).and_return(false) }
+          include_examples 'rewrites files'
+        end
+      end
+
+      context 'when git is not available' do
+        before { Git.stub(:command_available?).and_return(false) }
+        include_examples 'rewrites files'
+      end
+
+      context 'when an exception is raised while running' do
+        before do
+          cli.stub(:parse_options).and_raise(ArgumentError, 'No such file or directory - non-existent-file')
+        end
+
+        it 'return false' do
+          should be_false
+        end
+
+        it 'prints message of the exception' do
+          cli.should_receive(:warn).with('No such file or directory - non-existent-file')
+          cli.run([])
+        end
+      end
+
+      context 'when no target paths are specified' do
+        include_context 'isolated environment'
+
+        let(:args) { [] }
+
+        context 'and there is "spec" directory' do
+          before { Dir.mkdir('spec') }
+
+          it 'targets files in the "spec" directoy' do
+            cli.should_receive(:target_files).with(['spec'])
+            cli.run(args)
+          end
+        end
+
+        context 'and there is not "spec" directory' do
+          it 'aborts' do
+            should be_false
+          end
+        end
+      end
+    end
+
+    describe '#parse_options' do
+      subject { cli.parse_options(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
+        cli.parse_options(args)
+        args.should == ['some_file', '--negative-form', 'to_not', 'some_dir']
+      end
+
+      describe '--force option' do
+        let(:args) { ['--force'] }
+
+        it 'sets #forced? true' do
+          cli.parse_options(args)
+          cli.should be_forced
+        end
+      end
+
+      describe '-d/--disable option' do
+        [
+          ['expect_to_matcher', :convert_to_expect_to_matcher?],
+          ['expect_to_receive', :convert_to_expect_to_receive?],
+          ['allow_to_receive',  :convert_to_allow_to_receive?],
+          ['deprecated',        :replace_deprecated_method?]
+        ].each do |cli_type, config_attr|
+          context "when #{cli_type.inspect} is specified" do
+            let(:args) { ['--disable', cli_type] }
+
+            it "sets configuration ##{config_attr} false" do
+              cli.parse_options(args)
+              cli.configuration.send(config_attr).should be_false
+            end
+          end
+        end
+
+        context 'when multiple types are specified with comma' do
+          let(:args) { ['--disable', 'allow_to_receive,deprecated'] }
+
+          it 'handles all of them' do
+            cli.parse_options(args)
+            cli.configuration.convert_to_allow_to_receive?.should be_false
+            cli.configuration.replace_deprecated_method?.should be_false
+          end
+        end
+
+        context 'when unknown type is specified' do
+          let(:args) { ['--disable', 'unknown'] }
+
+          it 'raises error' do
+            -> { cli.parse_options(args) }.should raise_error(ArgumentError) { |error|
+              error.message.should == 'Unknown conversion 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
+              cli.parse_options(args)
+              cli.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
+          cli.parse_options(args)
+          cli.configuration.parenthesize_matcher_arg.should be_false
+        end
+      end
+
+      describe '--version option' do
+        before do
+          cli.stub(:puts)
+          cli.stub(:exit)
+        end
+
+        let(:args) { ['--version'] }
+
+        it 'shows version' do
+          cli.should_receive(:puts).with(Version.to_s)
+          cli.parse_options(args)
+        end
+
+        it 'exits' do
+          cli.should_receive(:exit)
+          cli.parse_options(args)
+        end
+      end
+    end
+
+    describe '#target_files' do
+      include_context 'isolated environment'
+
+      before do
+        ['file', 'file.rb', 'dir/file', 'dir/file.rb'].each do |path|
+          FileHelper.create_file(path, '')
+        end
+      end
+
+      subject(:target_files) { cli.target_files(paths) }
+
+      context 'when no path is passed' do
+        let(:paths) { [] }
+
+        it 'returns empty array' do
+          should be_empty
+        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
+          -> { target_files }.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' do
+          should == ['dir/file.rb']
+        end
+      end
+    end
+  end
+end

data/spec/transpec/configuration_spec.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+require 'spec_helper'
+
+module Transpec
+  describe Configuration do
+    subject(:configuration) { Configuration.new }
+
+    context 'by default' do
+      [
+        :convert_to_expect_to_matcher?,
+        :convert_to_expect_to_receive?,
+        :convert_to_allow_to_receive?,
+        :replace_deprecated_method?,
+        :parenthesize_matcher_arg?
+      ].each do |attribute|
+        describe "##{attribute}" do
+          subject { configuration.send(attribute) }
+
+          it 'is true' do
+            should be_true
+          end
+        end
+      end
+
+      describe '#negative_form_of_to' do
+        it 'is "not_to"' do
+          configuration.negative_form_of_to.should == 'not_to'
+        end
+      end
+    end
+
+    describe '#negative_form_of_to=' do
+      ['not_to', 'to_not'] .each do |form|
+        context "when #{form.inspect} is passed" do
+          it "sets #{form.inspect}" do
+            configuration.negative_form_of_to = form
+            configuration.negative_form_of_to.should == form
+          end
+        end
+      end
+
+      context 'when a form other than "not_to" or "to_not" is passed' do
+        it 'raises error' do
+          proc do
+            configuration.negative_form_of_to = 'foo'
+          end.should raise_error(ArgumentError)
+        end
+      end
+    end
+  end
+end