transpec 0.2.6 → 1.0.0

data/lib/transpec/syntax/should_receive.rb

@@ -1,22 +1,58 @@
 # coding: utf-8
 
 require 'transpec/syntax'
-require 'transpec/syntax/expectizable'
-require 'transpec/syntax/able_to_allow_no_message'
-require 'transpec/syntax/able_to_target_any_instance'
+require 'transpec/syntax/mixin/send'
+require 'transpec/syntax/mixin/monkey_patch'
+require 'transpec/syntax/mixin/expectizable'
+require 'transpec/syntax/mixin/allow_no_message'
+require 'transpec/syntax/mixin/any_instance'
 
 module Transpec
   class Syntax
     class ShouldReceive < Syntax
-      include Expectizable, AbleToAllowNoMessage, AbleToTargetAnyInstance
+      include Mixin::Send
+      include Mixin::MonkeyPatch
+      include Mixin::Expectizable
+      include Mixin::AllowNoMessage
+      include Mixin::AnyInstance
 
       alias_method :useless_expectation?, :allow_no_message?
 
+      def self.target_method?(receiver_node, method_name)
+        !receiver_node.nil? && [:should_receive, :should_not_receive].include?(method_name)
+      end
+
+      def register_request_for_dynamic_analysis(rewriter)
+        register_request_of_syntax_availability_inspection(
+          rewriter,
+          :expect_to_receive_available?,
+          [:expect, :receive]
+        )
+
+        register_request_of_syntax_availability_inspection(
+          rewriter,
+          :allow_to_receive_available?,
+          [:allow, :receive]
+        )
+      end
+
+      def expect_to_receive_available?
+        check_syntax_availability(__method__)
+      end
+
+      def allow_to_receive_available?
+        check_syntax_availability(__method__)
+      end
+
       def positive?
         method_name == :should_receive
       end
 
       def expectize!(negative_form = 'not_to')
+        unless expect_to_receive_available?
+          fail InvalidContextError.new(selector_range, "##{method_name}", '#expect')
+        end
+
         convert_to_syntax!('expect', negative_form)
         register_record(:expect, negative_form)
       end
@@ -24,6 +60,10 @@ module Transpec
       def allowize_useless_expectation!(negative_form = 'not_to')
         return unless useless_expectation?
 
+        unless allow_to_receive_available?
+          fail InvalidContextError.new(selector_range, "##{method_name}", '#allow')
+        end
+
         convert_to_syntax!('allow', negative_form)
         remove_allowance_for_no_message!
 
@@ -42,10 +82,6 @@ module Transpec
       private
 
       def convert_to_syntax!(syntax, negative_form)
-        unless context.non_monkey_patch_mock_available?
-          fail InvalidContextError.new(selector_range, "##{method_name}", "##{syntax}")
-        end
-
         if any_instance?
           wrap_class_with_any_instance_of!(syntax)
         else
@@ -68,14 +104,6 @@ module Transpec
         end
       end
 
-      def self.target_receiver_node?(node)
-        !node.nil?
-      end
-
-      def self.target_method_names
-        [:should_receive, :should_not_receive]
-      end
-
       def wrap_class_with_any_instance_of!(syntax)
         insert_before(subject_range, "#{syntax}_any_instance_of(")
         map = subject_node.loc

data/lib/transpec/syntax.rb

@@ -1,19 +1,27 @@
 # coding: utf-8
 
-require 'transpec/context'
-require 'transpec/report'
+require 'transpec/static_context_inspector'
 require 'transpec/record'
+require 'transpec/report'
 
 module Transpec
   class Syntax
-    attr_reader :node, :ancestor_nodes, :source_rewriter, :report
+    attr_reader :node, :ancestor_nodes, :source_rewriter, :runtime_data, :report
+
+    def self.inherited(subclass)
+      all_syntaxes << subclass
+    end
 
-    def self.all
+    def self.all_syntaxes
       @subclasses ||= []
     end
 
-    def self.inherited(subclass)
-      all << subclass
+    def self.standalone_syntaxes
+      @standalone_syntaxes ||= all_syntaxes.select(&:standalone?)
+    end
+
+    def self.standalone?
+      true
     end
 
     def self.snake_case_name
@@ -23,22 +31,26 @@ module Transpec
       end
     end
 
-    def self.target_node?(node)
-      return false unless node.type == :send
-      receiver_node, method_name, *_ = *node
-      return false unless target_receiver_node?(receiver_node)
-      target_method_names.include?(method_name)
+    def self.register_request_for_dynamic_analysis(node, rewriter)
     end
 
-    def initialize(node, ancestor_nodes, source_rewriter, report = Report.new)
+    def self.target_node?(node, runtime_data = nil)
+      false
+    end
+
+    def initialize(node, ancestor_nodes, source_rewriter = nil, runtime_data = nil, report = nil)
       @node = node
       @ancestor_nodes = ancestor_nodes
       @source_rewriter = source_rewriter
-      @report = report
+      @runtime_data = runtime_data
+      @report = report || Report.new
+    end
+
+    def register_request_for_dynamic_analysis(rewriter)
     end
 
-    def context
-      @context ||= Context.new(@ancestor_nodes)
+    def static_context_inspector
+      @static_context_inspector ||= StaticContextInspector.new(@ancestor_nodes)
     end
 
     def parent_node
@@ -51,12 +63,8 @@ module Transpec
 
     private
 
-    def self.target_receiver_node?(node)
-      false
-    end
-
-    def self.target_method_names
-      []
+    def runtime_node_data(node)
+      @runtime_data && @runtime_data[node]
     end
 
     def remove(range)

data/lib/transpec/util.rb

@@ -44,14 +44,24 @@ module Transpec
       map.begin.source.start_with?('<<')
     end
 
+    def contain_here_document?(node)
+      here_document?(node) || node.each_descendent_node.any? { |n| here_document?(n) }
+    end
+
     def in_parentheses?(node)
       return false unless node.type == :begin
       source = node.loc.expression.source
       source[0] == '(' && source[-1] == ')'
     end
 
-    def indentation_of_line(node)
-      line = node.loc.expression.source_line
+    def indentation_of_line(arg)
+      range = case arg
+              when AST::Node             then arg.loc.expression
+              when Parser::Source::Range then arg
+              else fail ArgumentError, "Invalid argument #{arg}"
+              end
+
+      line = range.source_line
       /^(?<indentation>\s*)\S/ =~ line
       indentation
     end

data/lib/transpec/version.rb

@@ -3,9 +3,9 @@
 module Transpec
   # http://semver.org/
   module Version
-    MAJOR = 0
-    MINOR = 2
-    PATCH = 6
+    MAJOR = 1
+    MINOR = 0
+    PATCH = 0
 
     def self.to_s
       [MAJOR, MINOR, PATCH].join('.')

data/spec/spec_helper.rb

@@ -1,13 +1,15 @@
 # coding: utf-8
 
 RSpec.configure do |config|
-  # Yes, I'm writing specs in should syntax intentionally!
-  config.expect_with :rspec do |c|
-    c.syntax = :should
-  end
+  unless ENV['TRANSPEC_TEST']
+    # Yes, I'm writing specs in should syntax intentionally!
+    config.expect_with :rspec do |c|
+      c.syntax = :should
+    end
 
-  config.mock_with :rspec do |c|
-    c.syntax = :should
+    config.mock_with :rspec do |c|
+      c.syntax = :should
+    end
   end
 
   config.color_enabled = true

data/spec/support/cache_helper.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'digest/sha1'
+
+module CacheHelper
+  module_function
+
+  def with_cache(key)
+    cache_file_path = cache_file_path(key)
+
+    if File.exist?(cache_file_path)
+      load_cache(cache_file_path)
+    else
+      data = yield
+      save_cache(cache_file_path, data)
+      data
+    end
+  end
+
+  def load_cache(path)
+    File.open(path) do |file|
+      Marshal.load(file)
+    end
+  end
+
+  def save_cache(path, data)
+    File.open(path, 'w') do |file|
+      Marshal.dump(data, file)
+    end
+  end
+
+  def cache_file_path(key)
+    filename = Digest::SHA1.hexdigest(key)
+    File.join(cache_dir, filename)
+  end
+
+  def cache_dir
+    @cache_dir ||= begin
+      spec_dir = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+      cache_dir = File.join(spec_dir, 'cache')
+
+      unless Dir.exist?(cache_dir)
+        require 'fileutils'
+        FileUtils.mkdir_p(cache_dir)
+      end
+
+      cache_dir
+    end
+  end
+end

data/spec/support/shared_context.rb

@@ -1,8 +1,10 @@
 # coding: utf-8
 
+require 'transpec/dynamic_analyzer'
 require 'transpec/ast/builder'
 require 'transpec/ast/scanner'
 require 'transpec/syntax/should'
+require 'transpec/syntax/expect'
 require 'parser'
 require 'parser/current'
 require 'tmpdir'
@@ -26,6 +28,31 @@ shared_context 'parsed objects' do
   let(:rewritten_source) { source_rewriter.process }
 end
 
+# This context requires `source` to be defined with #let.
+shared_context 'dynamic analysis objects' do
+  include_context 'isolated environment'
+
+  let(:source_path) { 'spec/example_spec.rb' }
+
+  let(:source_buffer) do
+    buffer = Parser::Source::Buffer.new(source_path)
+    buffer.source = source
+    buffer
+  end
+
+  runtime_data_cache = {}
+
+  let(:runtime_data) do
+    if runtime_data_cache[source]
+      runtime_data_cache[source]
+    else
+      FileHelper.create_file(source_path, source)
+      dynamic_analyzer = Transpec::DynamicAnalyzer.new(silent: true)
+      runtime_data_cache[source] = dynamic_analyzer.analyze
+    end
+  end
+end
+
 shared_context 'should object' do
   let(:should_object) do
     Transpec::AST::Scanner.scan(ast) do |node, ancestor_nodes|
@@ -33,12 +60,33 @@ shared_context 'should object' do
       return Transpec::Syntax::Should.new(
         node,
         ancestor_nodes,
-        source_rewriter
+        source_rewriter,
+        runtime_data
       )
     end
 
     fail 'No should node is found!'
   end
+
+  let(:runtime_data) { nil }
+end
+
+shared_context 'expect object' do
+  let(:expect_object) do
+    Transpec::AST::Scanner.scan(ast) do |node, ancestor_nodes|
+      next unless Transpec::Syntax::Expect.target_node?(node)
+      return Transpec::Syntax::Expect.new(
+        node,
+        ancestor_nodes,
+        source_rewriter,
+        runtime_data
+      )
+    end
+
+    fail 'No expect node is found!'
+  end
+
+  let(:runtime_data) { nil }
 end
 
 shared_context 'isolated environment' do

data/spec/transpec/ast/node_spec.rb

@@ -30,6 +30,71 @@ module Transpec
       #     (send nil :do_something
       #       (lvar :arg_a))))
 
+      describe '#parent_node' do
+        context 'when the node has parent' do
+          let(:target_node) do
+            ast.each_descendent_node do |node|
+              return node if node == s(:args)
+            end
+          end
+
+          it 'returns the parent node' do
+            target_node.parent_node.type.should == :block
+          end
+        end
+
+        context 'when the node has parent' do
+          it 'returns nil' do
+            ast.parent_node.should be_nil
+          end
+        end
+      end
+
+      describe '#each_ancestor_node' do
+        let(:target_node) do
+          ast.each_descendent_node do |node|
+            return node if node == s(:args)
+          end
+        end
+
+        let(:expected_types) { [:block, :def] }
+
+        context 'when a block is given' do
+          it 'yields each ancestor node' do
+            index = 0
+
+            target_node.each_ancestor_node do |node|
+              expected_type = expected_types[index]
+              node.type.should == expected_type
+              index += 1
+            end
+
+            index.should_not == 0
+          end
+
+          it 'returns itself' do
+            returned_value = target_node.each_ancestor_node { }
+            returned_value.should be(target_node)
+          end
+        end
+
+        context 'when no block is given' do
+          it 'returns enumerator' do
+            target_node.each_ancestor_node.should be_a(Enumerator)
+          end
+
+          describe 'the returned enumerator' do
+            it 'enumerates the ancestor nodes' do
+              enumerator = target_node.each_ancestor_node
+
+              expected_types.each do |expected_type|
+                enumerator.next.type.should == expected_type
+              end
+            end
+          end
+        end
+      end
+
       describe '#each_child_node' do
         let(:expected_types) { [:args, :block] }