transpec 0.0.1 → 0.0.2

data/lib/transpec/syntax/any_instanceable.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+require 'transpec/syntax/send_node_syntax'
+
+module Transpec
+  class Syntax
+    module AnyInstanceable
+      include SendNodeSyntax
+
+      def any_instance?
+        !class_node_of_any_instance.nil?
+      end
+
+      def class_node_of_any_instance
+        return nil unless subject_node.type == :send
+        return nil unless subject_node.children.count == 2
+        receiver_node, method_name = *subject_node
+        return nil unless method_name == :any_instance
+        return nil unless receiver_node.type == :const
+        receiver_node
+      end
+    end
+  end
+end

data/lib/transpec/syntax/be_close.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+require 'transpec/syntax'
+require 'transpec/syntax/send_node_syntax'
+
+module Transpec
+  class Syntax
+    class BeClose < Syntax
+      def convert_to_be_within!
+        _receiver_node, _method_name, expected_node, delta_node = *node
+
+        be_within_source = 'be_within('
+        be_within_source << delta_node.loc.expression.source
+        be_within_source << ').of('
+        be_within_source << expected_node.loc.expression.source
+        be_within_source << ')'
+
+        replace(expression_range, be_within_source)
+      end
+
+      private
+
+      def self.target_receiver_node?(node)
+        node.nil?
+      end
+
+      def self.target_method_names
+        [:be_close]
+      end
+    end
+  end
+end

data/lib/transpec/syntax/double.rb

@@ -1,20 +1,26 @@
 # coding: utf-8
 
+require 'transpec/syntax'
+require 'transpec/syntax/send_node_syntax'
+
 module Transpec
   class Syntax
     class Double < Syntax
       include SendNodeSyntax
 
-      def self.target_node?(node)
-        return false unless node.type == :send
-        receiver_node, method_name, *_ = *node
-        return false if receiver_node
-        [:double, :mock, :stub].include?(method_name)
+      def convert_to_double!
+        return if method_name == :double
+        replace(selector_range, 'double')
       end
 
-      def replace_deprecated_method!
-        return if method_name == :double
-        @source_rewriter.replace(selector_range, 'double')
+      private
+
+      def self.target_receiver_node?(node)
+        node.nil?
+      end
+
+      def self.target_method_names
+        [:double, :mock, :stub]
       end
     end
   end

data/lib/transpec/syntax/expectizable.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+require 'transpec/syntax/send_node_syntax'
+
+module Transpec
+  class Syntax
+    module Expectizable
+      include SendNodeSyntax
+
+      def wrap_subject_in_expect!
+        if subject_range.source[0] == '('
+          insert_before(subject_range, 'expect')
+        else
+          insert_before(subject_range, 'expect(')
+          insert_after(subject_range, ')')
+        end
+      end
+    end
+  end
+end

data/lib/transpec/syntax/matcher.rb

@@ -1,10 +1,18 @@
 # coding: utf-8
 
+require 'transpec/syntax'
+require 'transpec/syntax/send_node_syntax'
+require 'transpec/util'
+
 module Transpec
   class Syntax
     class Matcher < Syntax
       include SendNodeSyntax, Util
 
+      def self.target_node?(node)
+        false
+      end
+
       def initialize(node, in_example_group_context, source_rewriter)
         @node = node
         @in_example_group_context = in_example_group_context
@@ -14,15 +22,15 @@ module Transpec
       def correct_operator!(parenthesize_arg = true)
         case method_name
         when :==
-          @source_rewriter.replace(selector_range, 'eq')
+          replace(selector_range, 'eq')
           parenthesize!(parenthesize_arg)
         when :===, :<, :<=, :>, :>=
-          @source_rewriter.insert_before(selector_range, 'be ')
+          insert_before(selector_range, 'be ')
         when :=~
           if arg_node.type == :array
-            @source_rewriter.replace(selector_range, 'match_array')
+            replace(selector_range, 'match_array')
           else
-            @source_rewriter.replace(selector_range, 'match')
+            replace(selector_range, 'match')
           end
           parenthesize!(parenthesize_arg)
         end
@@ -34,15 +42,15 @@ module Transpec
         case left_parenthesis_range.source
         when ' '
           if always || arg_node.type == :hash
-            @source_rewriter.replace(left_parenthesis_range, '(')
-            @source_rewriter.insert_after(expression_range, ')')
+            replace(left_parenthesis_range, '(')
+            insert_after(expression_range, ')')
           end
         when "\n", "\r"
-          @source_rewriter.insert_before(left_parenthesis_range, '(')
+          insert_before(left_parenthesis_range, '(')
           linefeed = left_parenthesis_range.source
           matcher_line_indentation = indentation_of_line(@node)
           right_parenthesis = "#{linefeed}#{matcher_line_indentation})"
-          @source_rewriter.insert_after(expression_range, right_parenthesis)
+          insert_after(expression_range, right_parenthesis)
         end
       end
 

data/lib/transpec/syntax/method_stub.rb

@@ -1,26 +1,20 @@
 # coding: utf-8
 
+require 'transpec/syntax'
+require 'transpec/syntax/any_instanceable'
+require 'transpec/util'
 require 'English'
 
 module Transpec
   class Syntax
     class MethodStub < Syntax
-      include SendNodeSyntax, Util
-
-      def self.target_node?(node)
-        return false unless node.type == :send
-        receiver_node, method_name, *_ = *node
-        return false unless receiver_node
-        [:stub, :unstub, :stub!, :unstub!].include?(method_name)
-      end
+      include AnyInstanceable, Util
 
       def allowize!
         # There's no way of unstubbing in #allow syntax.
         return unless [:stub, :stub!].include?(method_name)
 
-        if @replaced_deprecated_method
-          fail 'Already replaced deprecated method, cannot allowize.'
-        end
+        fail 'Already replaced deprecated method, cannot allowize.' if @replaced_deprecated_method
 
         unless in_example_group_context?
           fail NotInExampleGroupContextError.new(expression_range, "##{method_name}", '#allow')
@@ -28,10 +22,10 @@ module Transpec
 
         if arg_node.type == :hash
           expressions = build_allow_expressions_from_hash_node(arg_node)
-          @source_rewriter.replace(expression_range, expressions)
+          replace(expression_range, expressions)
         else
           expression = build_allow_expression(arg_node)
-          @source_rewriter.replace(expression_range, expression)
+          replace(expression_range, expression)
         end
 
         @allowized = true
@@ -45,17 +39,23 @@ module Transpec
 
         return unless replacement_method_name
 
-        if @allowized
-          fail 'Already allowized, cannot replace deprecated method.'
-        end
+        fail 'Already allowized, cannot replace deprecated method.' if @allowized
 
-        @source_rewriter.replace(selector_range, replacement_method_name)
+        replace(selector_range, replacement_method_name)
 
         @replaced_deprecated_method = true
       end
 
       private
 
+      def self.target_receiver_node?(node)
+        !node.nil?
+      end
+
+      def self.target_method_names
+        [:stub, :unstub, :stub!, :unstub!]
+      end
+
       def build_allow_expressions_from_hash_node(hash_node)
         expressions = []
 
@@ -70,15 +70,7 @@ module Transpec
       end
 
       def build_allow_expression(message_node, return_value_node = nil, keep_form_around_arg = true)
-        expression = ''
-
-        expression << if any_instance?
-                        class_source = class_node_of_any_instance.loc.expression.source
-                        "allow_any_instance_of(#{class_source})"
-                      else
-                        "allow(#{subject_range.source})"
-                      end
-
+        expression =  allow_source
         expression << range_in_between_subject_and_selector.source
         expression << 'to receive'
         expression << (keep_form_around_arg ? range_in_between_selector_and_arg.source : '(')
@@ -93,24 +85,18 @@ module Transpec
         expression
       end
 
-      def class_node_of_any_instance
-        return nil unless subject_node.type == :send
-        return nil unless subject_node.children.count == 2
-        receiver_node, method_name = *subject_node
-        return nil unless method_name == :any_instance
-        return nil unless receiver_node.type == :const
-        receiver_node
-      end
-
-      def any_instance?
-        !class_node_of_any_instance.nil?
+      def allow_source
+        if any_instance?
+          class_source = class_node_of_any_instance.loc.expression.source
+          "allow_any_instance_of(#{class_source})"
+        else
+          "allow(#{subject_range.source})"
+        end
       end
 
       def message_source(node)
         message_source = node.loc.expression.source
-        if node.type == :sym && !message_source.start_with?(':')
-          message_source.prepend(':')
-        end
+        message_source.prepend(':') if node.type == :sym && !message_source.start_with?(':')
         message_source
       end
 

data/lib/transpec/syntax/send_node_syntax.rb

@@ -1,5 +1,7 @@
 # coding: utf-8
 
+require 'transpec/syntax'
+
 module Transpec
   class Syntax
     module SendNodeSyntax
@@ -17,10 +19,6 @@ module Transpec
         @node.children[2]
       end
 
-      def expression_range
-        @node.loc.expression
-      end
-
       def selector_range
         @node.loc.selector
       end

data/lib/transpec/syntax/should.rb

@@ -1,16 +1,14 @@
 # coding: utf-8
 
+require 'transpec/syntax'
+require 'transpec/syntax/expectizable'
+require 'transpec/syntax/matcher'
+require 'transpec/util'
+
 module Transpec
   class Syntax
     class Should < Syntax
-      include SendNodeSyntax, Util
-
-      def self.target_node?(node)
-        return false unless node.type == :send
-        receiver_node, method_name, *_ = *node
-        return false unless receiver_node
-        [:should, :should_not].include?(method_name)
-      end
+      include Expectizable, Util
 
       def positive?
         method_name == :should
@@ -22,17 +20,12 @@ module Transpec
         end
 
         if proc_literal?(subject_node)
-          send_node = subject_node.children.first
-          range_of_subject_method_taking_block = send_node.loc.expression
-          @source_rewriter.replace(range_of_subject_method_taking_block, 'expect')
-        elsif subject_range.source[0] == '('
-          @source_rewriter.insert_before(subject_range, 'expect')
+          replace_proc_selector_with_expect!
         else
-          @source_rewriter.insert_before(subject_range, 'expect(')
-          @source_rewriter.insert_after(subject_range, ')')
+          wrap_subject_in_expect!
         end
 
-        @source_rewriter.replace(selector_range, positive? ? 'to' : negative_form)
+        replace(selector_range, positive? ? 'to' : negative_form)
 
         matcher.correct_operator!(parenthesize_matcher_arg)
       end
@@ -44,6 +37,22 @@ module Transpec
       def matcher_node
         arg_node || parent_node
       end
+
+      private
+
+      def self.target_receiver_node?(node)
+        !node.nil?
+      end
+
+      def self.target_method_names
+        [:should, :should_not]
+      end
+
+      def replace_proc_selector_with_expect!
+        send_node = subject_node.children.first
+        range_of_subject_method_taking_block = send_node.loc.expression
+        replace(range_of_subject_method_taking_block, 'expect')
+      end
     end
   end
 end

data/lib/transpec/syntax/should_receive.rb

@@ -1,16 +1,13 @@
 # coding: utf-8
 
+require 'transpec/syntax'
+require 'transpec/syntax/expectizable'
+require 'transpec/syntax/any_instanceable'
+
 module Transpec
   class Syntax
     class ShouldReceive < Syntax
-      include SendNodeSyntax
-
-      def self.target_node?(node)
-        return false unless node.type == :send
-        receiver_node, method_name, *_ = *node
-        return false unless receiver_node
-        [:should_receive, :should_not_receive].include?(method_name)
-      end
+      include Expectizable, AnyInstanceable
 
       def positive?
         method_name == :should_receive
@@ -21,46 +18,50 @@ module Transpec
           fail NotInExampleGroupContextError.new(expression_range, "##{method_name}", '#expect')
         end
 
-        if any_instance?(subject_node)
-          @source_rewriter.insert_before(subject_range, 'expect_any_instance_of(')
-          map = subject_node.loc
-          dot_any_instance_range = map.dot.join(map.selector)
-          @source_rewriter.replace(dot_any_instance_range, ')')
+        if any_instance?
+          wrap_class_in_expect_any_instance_of!
         else
-          @source_rewriter.insert_before(subject_range, 'expect(')
-          @source_rewriter.insert_after(subject_range, ')')
+          wrap_subject_in_expect!
         end
 
-        to_receive = "#{positive? ? 'to' : negative_form} receive"
-        @source_rewriter.replace(selector_range, to_receive)
+        replace(selector_range, "#{positive? ? 'to' : negative_form} receive")
 
         correct_block_style!
       end
 
       def correct_block_style!
-        broken_block_nodes = [
-          block_node_taken_by_with_method_with_no_normal_args,
-          block_node_followed_by_message_expectation_method
-        ].compact.uniq
-
         return if broken_block_nodes.empty?
 
         broken_block_nodes.each do |block_node|
           map = block_node.loc
           next if map.begin.source == '{'
-          @source_rewriter.replace(map.begin, '{')
-          @source_rewriter.replace(map.end, '}')
+          replace(map.begin, '{')
+          replace(map.end, '}')
         end
       end
 
       private
 
-      def any_instance?(node)
-        return false unless node.type == :send
-        return false unless node.children.count == 2
-        receiver_node, method_name = *node
-        return false unless method_name == :any_instance
-        receiver_node.type == :const
+      def self.target_receiver_node?(node)
+        !node.nil?
+      end
+
+      def self.target_method_names
+        [:should_receive, :should_not_receive]
+      end
+
+      def wrap_class_in_expect_any_instance_of!
+        insert_before(subject_range, 'expect_any_instance_of(')
+        map = subject_node.loc
+        dot_any_instance_range = map.dot.join(map.selector)
+        replace(dot_any_instance_range, ')')
+      end
+
+      def broken_block_nodes
+        @broken_block_nodes ||= [
+          block_node_taken_by_with_method_with_no_normal_args,
+          block_node_followed_by_message_expectation_method
+        ].compact.uniq
       end
 
       # subject.should_receive(:method_name).once.with do |block_arg|
@@ -105,11 +106,7 @@ module Transpec
         @ancestor_nodes.reverse.reduce(@node) do |child_node, parent_node|
           return nil unless [:send, :block].include?(parent_node.type)
           return nil unless parent_node.children.first == child_node
-
-          if child_node.type == :block && parent_node.type == :send
-            return child_node
-          end
-
+          return child_node if child_node.type == :block && parent_node.type == :send
           parent_node
         end