transpec 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9a3e260298c65e466e7a7460347e7f30c0a21756
-  data.tar.gz: 2c1638289bf22ca3478ffe62c22419451ffe4dcd
+  metadata.gz: 007748d38ffe681cd54d6fb29dd4da70bffccf38
+  data.tar.gz: 5b5a23a5033dbcbfec53203adb25ced1cd416a26
 SHA512:
-  metadata.gz: cf8a5e86460c68c9a5de1148dadab3af4edc88d775992e49069de3f17f689ececc22494c2e9c0ae52f5d4c73813c3d5beb3b7324faed94cd9163f0406d513e63
-  data.tar.gz: a0b827f6aa1aa0101a459440f2325f362509e6a8c5de0e88c741c93482ecb005d539ac2e61ee0312023ac6a6836589792d29de5f95b4bae616be917fca7b555a
+  metadata.gz: 64b41185ba3851b1597ac8c4698674ff92d5b4111169d8f9d3ac2f5afe6a101ceeda41c3cea2c62042f936397b85afb7e8d669868ccd67e0af7db8868d29df2b
+  data.tar.gz: 65a49706d64224c8f6f4421b6db6def9f2e727ff01e04b82ec9f2240e21c0ef75903a63b355850235e5522ba1f5beb1c3b16710af507205cf49b6e27a6c25712

data/.rubocop.yml

@@ -1,5 +1,7 @@
 
 AllCops:
+  Includes:
+    - tasks/*.rake
   Excludes:
     - tmp/*
 

data/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ## Master
 
+## v0.1.3
+
+* Avoid confusing `Excon.stub` with RSpec's `stub` ([#4](https://github.com/yujinakayama/transpec/issues/4))
+* Fix a bug where `be == 1` was converted into `be eq(1)` (now it's converted into `eq(1)`)
+* Fix a bug where `obj.should==1` was converted into `obj.toeq1` (now it's converted into `obj.to eq(1)`)
+
 ## v0.1.2
 
 * Continue processing files even if a file has invalid syntax

data/Guardfile

@@ -10,6 +10,7 @@ end
 
 guard :rubocop do
   watch(%r{.+\.rb$})
+  watch(%r{.+\.rake$})
   watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
 end
 

data/Rakefile

@@ -5,144 +5,8 @@ require 'rubocop/rake_task'
 RSpec::Core::RakeTask.new(:spec)
 Rubocop::RakeTask.new(:style)
 
-namespace :ci do
-  desc "#{Rake::Task['spec'].comment} for CI environment"
-  task :spec do
-    ENV['CI'] = 'true'
-
-    ENV['CI_REPORTS'] = 'spec/reports'
-    require 'ci/reporter/rake/rspec'
-    Rake::Task['ci:setup:rspec'].invoke
-
-    Rake::Task['spec'].invoke
-  end
-end
-
-desc 'Generate README.md'
-task :readme do
-  require 'erb'
-  require 'transpec/cli'
-
-  gem_specification = Gem::Specification.load('transpec.gemspec')
-  rspec_dependency = gem_specification.dependencies.find { |d| d.name == 'rspec' }
-  rspec_requirement = rspec_dependency.requirement
-  rspec_version = rspec_requirement.requirements.first.find { |r| r.is_a?(Gem::Version) }
-
-  erb = ERB.new(File.read('README.md.erb'), nil, '-')
-  content = erb.result(binding)
-  File.write('README.md', content)
-end
-
-task :abort_unless_latest_readme_is_committed => :readme do
-  unless Transpec::Git.clean?
-    warn 'Commit README.md before release.'
-    exit 1
-  end
-end
-
-Rake::Task[:release].enhance([:abort_unless_latest_readme_is_committed])
-
-namespace :test do
-  projects = [
-    [:twitter, 'https://github.com/sferik/twitter.git',     'v4.1.0'],
-    [:guard,   'https://github.com/yujinakayama/guard.git', 'transpec', %w(--without development)],
-    [:mail,    'https://github.com/yujinakayama/mail.git', 'transpec']
-  ]
-
-  desc 'Test Transpec on all projects'
-  task :all => projects.map(&:first)
-
-  projects.each do |name, url, ref, bundler_args|
-    desc "Test Transpec on #{name.to_s.capitalize} project"
-    task name do
-      tmpdir = File.join('tmp', 'projects')
-
-      unless Dir.exist?(tmpdir)
-        require 'fileutils'
-        FileUtils.mkdir_p(tmpdir)
-      end
-
-      Dir.chdir(tmpdir) do
-        test_on_project(name.to_s.capitalize, url, ref, bundler_args)
-      end
-    end
-  end
-
-  def test_on_project(name, url, ref, bundler_args = nil)
-    require 'transpec'
-
-    puts " Testing on #{name} Project ".center(80, '=')
-
-    repo_dir = prepare_git_repo(url, ref)
-
-    bundler_args ||= []
-    # On Travis CI, reuse system gems to speed up build.
-    bundler_args.concat(%w(--path vendor/bundle)) unless ENV['TRAVIS']
-
-    Dir.chdir(repo_dir) do
-      with_clean_bundler_env do
-        sh 'bundle', 'install', *bundler_args
-        sh File.join(Transpec.root, 'bin', 'transpec'), '--force'
-        sh 'bundle exec rspec'
-      end
-    end
-  end
-
-  def prepare_git_repo(url, ref)
-    repo_dir = File.basename(url, '.git')
-
-    needs_clone = false
-
-    if Dir.exist?(repo_dir)
-      current_ref = nil
-
-      Dir.chdir(repo_dir) do
-        current_ref = `git describe --all`.chomp.sub(/\Aheads\//, '')
-      end
-
-      if current_ref == ref
-        Dir.chdir(repo_dir) do
-          sh 'git reset --hard'
-        end
-      else
-        require 'fileutils'
-        FileUtils.rm_rf(repo_dir)
-        needs_clone = true
-      end
-    else
-      needs_clone = true
-    end
-
-    if needs_clone
-      # Disabling checkout here to suppress "detached HEAD" warning.
-      sh "git clone --no-checkout --depth 1 --branch #{ref} #{url}"
-
-      Dir.chdir(repo_dir) do
-        sh "git checkout --quiet #{ref}"
-      end
-    end
-
-    repo_dir
-  end
-
-  def with_clean_bundler_env
-    if defined?(Bundler)
-      Bundler.with_clean_env do
-        # Bundler.with_clean_env cleans environment variables
-        # which are set after bundler is loaded.
-        prepare_env
-        yield
-      end
-    else
-      prepare_env
-      yield
-    end
-  end
-
-  def prepare_env
-    # Disable Coveralls in other projects.
-    ENV['CI'] = ENV['JENKINS_URL'] = ENV['COVERALLS_RUN_LOCALLY'] = nil
-  end
+Dir['tasks/**/*.rake'].each do |path|
+  load(path)
 end
 
 task default: [:spec, :style, :readme]

data/lib/transpec/ast/scanner.rb

@@ -1,14 +1,9 @@
 # coding: utf-8
 
-require 'transpec/ast/scope_stack'
-require 'parser'
-
 module Transpec
   module AST
     class Scanner
-      SCOPE_TYPES = [:module, :class, :sclass, :def, :defs, :block].freeze
-
-      attr_reader :scope_stack
+      attr_reader :context
 
       def self.scan(origin_node, &block)
         instance = new(&block)
@@ -19,7 +14,6 @@ module Transpec
       def initialize(&block)
         @callback = block
         @ancestor_nodes = []
-        @scope_stack = ScopeStack.new
       end
 
       def scan(origin_node, yield_origin_node = false)
@@ -28,27 +22,19 @@ module Transpec
         yield_node(origin_node) if yield_origin_node
 
         @ancestor_nodes.push(origin_node)
-        @scope_stack.push_scope(origin_node) if scope_node?(origin_node)
 
-        origin_node.children.each_with_index do |child, index|
-          next unless child.is_a?(Parser::AST::Node)
-          node = child
-          yield_node(node)
-          scan(node)
+        origin_node.each_child_node do |child_node|
+          yield_node(child_node)
+          scan(child_node)
         end
 
-        @scope_stack.pop_scope if scope_node?(origin_node)
         @ancestor_nodes.pop
       end
 
       private
 
       def yield_node(node)
-        @callback.call(node, @ancestor_nodes, @scope_stack.in_example_group_context?)
-      end
-
-      def scope_node?(node)
-        SCOPE_TYPES.include?(node.type)
+        @callback.call(node, @ancestor_nodes)
       end
     end
   end

data/lib/transpec/context.rb

@@ -0,0 +1,101 @@
+# coding: utf-8
+
+require 'transpec/util'
+
+module Transpec
+  class Context
+    include Util
+
+    SCOPE_TYPES = [:module, :class, :sclass, :def, :defs, :block].freeze
+
+    EXAMPLE_GROUP_METHOD_NAMES = [
+      :describe, :context,
+      :shared_examples, :shared_context, :share_examples_for, :shared_examples_for
+    ].freeze
+
+    attr_reader :nodes
+
+    # @param nodes [Array] An array containing from root node to the target node.
+    def initialize(nodes)
+      @nodes = nodes
+    end
+
+    def scopes
+      @scopes ||= begin
+        scopes = @nodes.map { |node| scope_type(node) }
+        scopes.compact
+      end
+    end
+
+    def in_example_group?
+      return @in_example_group if instance_variable_defined?(:@in_example_group)
+      @in_example_group = in_method_or_block_in_example_group?   ||
+                          in_method_or_block_in_rspec_configure? ||
+                          in_method_in_module?                   ||
+                          in_method_in_top_level?
+    end
+
+    private
+
+    def scope_type(node)
+      return nil unless SCOPE_TYPES.include?(node.type)
+      return node.type unless node.type == :block
+
+      send_node = node.children.first
+      receiver_node, method_name, *_ = *send_node
+
+      if const_name(receiver_node) == 'RSpec' && method_name == :configure
+        :rspec_configure
+      elsif receiver_node
+        node.type
+      elsif EXAMPLE_GROUP_METHOD_NAMES.include?(method_name)
+        :example_group
+      else
+        node.type
+      end
+    end
+
+    def in_method_or_block_in_example_group?
+      scopes_in_example_group = inner_scopes_of(:example_group)
+      return false unless scopes_in_example_group
+      return false if include_class_scope?(scopes_in_example_group)
+      include_method_or_block_scope?(scopes_in_example_group)
+    end
+
+    def in_method_or_block_in_rspec_configure?
+      scopes_in_rspec_configure = inner_scopes_of(:rspec_configure)
+      return false unless scopes_in_rspec_configure
+      return false if include_class_scope?(scopes_in_rspec_configure)
+      include_method_or_block_scope?(scopes_in_rspec_configure)
+    end
+
+    def in_method_in_module?
+      scopes_in_module = inner_scopes_of(:module)
+      return false unless scopes_in_module
+      return false if include_class_scope?(scopes_in_module)
+      scopes_in_module.include?(:def)
+    end
+
+    def in_method_in_top_level?
+      return false unless scopes.first == :def
+      scopes_in_method = scopes[1..-1]
+      !include_class_scope?(scopes_in_method)
+    end
+
+    def inner_scopes_of(scope_type)
+      index = scopes.rindex(scope_type)
+      return nil unless index
+      scopes[Range.new(index + 1, -1)]
+    end
+
+    def include_class_scope?(scopes)
+      !(scopes & [:class, :sclass]).empty?
+    end
+
+    def include_method_or_block_scope?(scopes)
+      # TODO: Should validate whether the method taking the block is RSpec's
+      #   special method. (e.g. #subject, #let, #before, #after)
+      !(scopes & [:def, :block]).empty?
+    end
+  end
+end

data/lib/transpec/rewriter.rb

@@ -37,8 +37,8 @@ module Transpec
       failed_overlapping_rewrite = false
       @source_rewriter.diagnostics.consumer = proc { failed_overlapping_rewrite = true }
 
-      AST::Scanner.scan(ast) do |node, ancestor_nodes, in_example_group_context|
-        dispatch_node(node, ancestor_nodes, in_example_group_context)
+      AST::Scanner.scan(ast) do |node, ancestor_nodes|
+        dispatch_node(node, ancestor_nodes)
       end
 
       rewritten_source = @source_rewriter.process
@@ -64,14 +64,13 @@ module Transpec
       ast
     end
 
-    def dispatch_node(node, ancestor_nodes, in_example_group_context)
+    def dispatch_node(node, ancestor_nodes)
       Syntax.all.each do |syntax_class|
         next unless syntax_class.target_node?(node)
 
         syntax = syntax_class.new(
           node,
           ancestor_nodes,
-          in_example_group_context,
           @source_rewriter
         )
 

data/lib/transpec/syntax.rb

@@ -1,5 +1,7 @@
 # coding: utf-8
 
+require 'transpec/context'
+
 module Transpec
   class Syntax
     class NotInExampleGroupContextError < StandardError
@@ -22,8 +24,7 @@ module Transpec
       end
     end
 
-    attr_reader :node, :ancestor_nodes, :in_example_group_context, :source_rewriter
-    alias_method :in_example_group_context?, :in_example_group_context
+    attr_reader :node, :ancestor_nodes, :source_rewriter
 
     def self.all
       @subclasses ||= []
@@ -47,13 +48,16 @@ module Transpec
       target_method_names.include?(method_name)
     end
 
-    def initialize(node, ancestor_nodes, in_example_group_context, source_rewriter)
+    def initialize(node, ancestor_nodes, source_rewriter)
       @node = node
       @ancestor_nodes = ancestor_nodes
-      @in_example_group_context = in_example_group_context
       @source_rewriter = source_rewriter
     end
 
+    def context
+      @context ||= Context.new(@ancestor_nodes)
+    end
+
     def parent_node
       @ancestor_nodes.last
     end

data/lib/transpec/syntax/matcher.rb

@@ -13,67 +13,105 @@ module Transpec
         false
       end
 
-      def initialize(node, in_example_group_context, source_rewriter)
+      def initialize(node, source_rewriter)
         @node = node
-        @in_example_group_context = in_example_group_context
         @source_rewriter = source_rewriter
       end
 
       def correct_operator!(parenthesize_arg = true)
         case method_name
         when :==
-          replace(selector_range, 'eq')
-          parenthesize!(parenthesize_arg)
+          convert_to_eq!(parenthesize_arg)
         when :===, :<, :<=, :>, :>=
-          return if prefixed_with_be?
-          insert_before(selector_range, 'be ')
+          convert_to_be_operator!
         when :=~
-          if arg_node.type == :array
-            replace(selector_range, 'match_array')
-          else
-            replace(selector_range, 'match')
-          end
-          parenthesize!(parenthesize_arg)
+          convert_to_match!(parenthesize_arg)
         end
       end
 
       def parenthesize!(always = true)
         return if argument_is_here_document?
 
-        case left_parenthesis_range.source
-        when ' '
-          if in_parentheses?(arg_node)
-            remove(left_parenthesis_range)
-          elsif always || arg_node.type == :hash
-            replace(left_parenthesis_range, '(')
-            insert_after(expression_range, ')')
-          end
-        when "\n", "\r"
-          insert_before(left_parenthesis_range, '(')
-          linefeed = left_parenthesis_range.source
-          matcher_line_indentation = indentation_of_line(@node)
-          right_parenthesis = "#{linefeed}#{matcher_line_indentation})"
-          insert_after(expression_range, right_parenthesis)
+        left_of_arg_source = range_in_between_selector_and_arg.source
+
+        if left_of_arg_source.match(/\A *\Z/)
+          parenthesize_single_line!(always)
+        elsif left_of_arg_source.match(/\n|\r/)
+          parenthesize_multi_line!(Regexp.last_match(0))
         end
       end
 
       private
 
-      def argument_is_here_document?
-        here_document?(arg_node) ||
-          arg_node.each_descendent_node.any? { |n| here_document?(n) }
+      def convert_to_eq!(parenthesize_arg)
+        handle_anterior_of_operator!
+        replace(selector_range, 'eq')
+        parenthesize!(parenthesize_arg)
+      end
+
+      def convert_to_be_operator!
+        return if prefixed_with_be?
+        insert_before(selector_range, 'be ')
+      end
+
+      def convert_to_match!(parenthesize_arg)
+        handle_anterior_of_operator!
+
+        if arg_node.type == :array
+          replace(selector_range, 'match_array')
+        else
+          replace(selector_range, 'match')
+        end
+
+        parenthesize!(parenthesize_arg)
+      end
+
+      def handle_anterior_of_operator!
+        if prefixed_with_be?
+          remove_be!
+        elsif range_in_between_receiver_and_selector.source.empty?
+          insert_before(selector_range, ' ')
+        end
+      end
+
+      def parenthesize_single_line!(always)
+        if in_parentheses?(arg_node)
+          remove(range_in_between_selector_and_arg)
+        elsif always || arg_node.type == :hash
+          replace(range_in_between_selector_and_arg, '(')
+          insert_after(expression_range, ')')
+        elsif range_in_between_selector_and_arg.source.empty?
+          insert_after(selector_range, ' ')
+        end
+      end
+
+      def parenthesize_multi_line!(linefeed)
+        insert_before(range_in_between_selector_and_arg, '(')
+        matcher_line_indentation = indentation_of_line(@node)
+        right_parenthesis = "#{linefeed}#{matcher_line_indentation})"
+        insert_after(expression_range, right_parenthesis)
       end
 
       def prefixed_with_be?
-        receiver_node == s(:send, nil, :be)
+        !be_node.nil?
+      end
+
+      def remove_be!
+        be_range = be_node.loc.expression.join(selector_range.begin)
+        remove(be_range)
       end
 
-      def left_parenthesis_range
-        Parser::Source::Range.new(
-          selector_range.source_buffer,
-          selector_range.end_pos,
-          selector_range.end_pos + 1
-        )
+      def be_node
+        if receiver_node == s(:send, nil, :be)
+          receiver_node
+        else
+          nil
+        end
+      end
+
+      def argument_is_here_document?
+        here_document?(arg_node) ||
+          arg_node.each_descendent_node.any? { |n| here_document?(n) }
       end
     end
   end