transpec 0.0.1

data/lib/transpec/syntax/matcher.rb

@@ -0,0 +1,60 @@
+# coding: utf-8
+
+module Transpec
+  class Syntax
+    class Matcher < Syntax
+      include SendNodeSyntax, Util
+
+      def initialize(node, in_example_group_context, 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 :==
+          @source_rewriter.replace(selector_range, 'eq')
+          parenthesize!(parenthesize_arg)
+        when :===, :<, :<=, :>, :>=
+          @source_rewriter.insert_before(selector_range, 'be ')
+        when :=~
+          if arg_node.type == :array
+            @source_rewriter.replace(selector_range, 'match_array')
+          else
+            @source_rewriter.replace(selector_range, 'match')
+          end
+          parenthesize!(parenthesize_arg)
+        end
+      end
+
+      def parenthesize!(always = true)
+        return if here_document?(arg_node)
+
+        case left_parenthesis_range.source
+        when ' '
+          if always || arg_node.type == :hash
+            @source_rewriter.replace(left_parenthesis_range, '(')
+            @source_rewriter.insert_after(expression_range, ')')
+          end
+        when "\n", "\r"
+          @source_rewriter.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)
+        end
+      end
+
+      private
+
+      def left_parenthesis_range
+        Parser::Source::Range.new(
+          selector_range.source_buffer,
+          selector_range.end_pos,
+          selector_range.end_pos + 1
+        )
+      end
+    end
+  end
+end

data/lib/transpec/syntax/method_stub.rb

@@ -0,0 +1,142 @@
+# coding: utf-8
+
+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
+
+      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
+
+        unless in_example_group_context?
+          fail NotInExampleGroupContextError.new(expression_range, "##{method_name}", '#allow')
+        end
+
+        if arg_node.type == :hash
+          expressions = build_allow_expressions_from_hash_node(arg_node)
+          @source_rewriter.replace(expression_range, expressions)
+        else
+          expression = build_allow_expression(arg_node)
+          @source_rewriter.replace(expression_range, expression)
+        end
+
+        @allowized = true
+      end
+
+      def replace_deprecated_method!
+        replacement_method_name = case method_name
+                                  when :stub!   then 'stub'
+                                  when :unstub! then 'unstub'
+                                  end
+
+        return unless replacement_method_name
+
+        if @allowized
+          fail 'Already allowized, cannot replace deprecated method.'
+        end
+
+        @source_rewriter.replace(selector_range, replacement_method_name)
+
+        @replaced_deprecated_method = true
+      end
+
+      private
+
+      def build_allow_expressions_from_hash_node(hash_node)
+        expressions = []
+
+        hash_node.children.each_with_index do |pair_node, index|
+          key_node, value_node = *pair_node
+          expression = build_allow_expression(key_node, value_node, false)
+          expression.prepend(indentation_of_line(@node)) if index > 0
+          expressions << expression
+        end
+
+        expressions.join($RS)
+      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 << range_in_between_subject_and_selector.source
+        expression << 'to receive'
+        expression << (keep_form_around_arg ? range_in_between_selector_and_arg.source : '(')
+        expression << message_source(message_node)
+        expression << (keep_form_around_arg ? range_after_arg.source : ')')
+
+        if return_value_node
+          return_value_source = return_value_node.loc.expression.source
+          expression << ".and_return(#{return_value_source})"
+        end
+
+        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?
+      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
+      end
+
+      def range_in_between_subject_and_selector
+        Parser::Source::Range.new(
+          subject_range.source_buffer,
+          subject_range.end_pos,
+          selector_range.begin_pos
+        )
+      end
+
+      def range_in_between_selector_and_arg
+        Parser::Source::Range.new(
+          selector_range.source_buffer,
+          selector_range.end_pos,
+          arg_range.begin_pos
+        )
+      end
+
+      def range_after_arg
+        Parser::Source::Range.new(
+          arg_range.source_buffer,
+          arg_range.end_pos,
+          expression_range.end_pos
+        )
+      end
+    end
+  end
+end

data/lib/transpec/syntax/send_node_syntax.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+
+module Transpec
+  class Syntax
+    module SendNodeSyntax
+      def receiver_node
+        @node.children[0]
+      end
+
+      alias_method :subject_node, :receiver_node
+
+      def method_name
+        @node.children[1]
+      end
+
+      def arg_node
+        @node.children[2]
+      end
+
+      def expression_range
+        @node.loc.expression
+      end
+
+      def selector_range
+        @node.loc.selector
+      end
+
+      def receiver_range
+        receiver_node.loc.expression
+      end
+
+      alias_method :subject_range, :receiver_range
+
+      def arg_range
+        arg_node.loc.expression
+      end
+    end
+  end
+end

data/lib/transpec/syntax/should.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+
+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
+
+      def positive?
+        method_name == :should
+      end
+
+      def expectize!(negative_form = 'not_to', parenthesize_matcher_arg = true)
+        unless in_example_group_context?
+          fail NotInExampleGroupContextError.new(expression_range, "##{method_name}", '#expect')
+        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')
+        else
+          @source_rewriter.insert_before(subject_range, 'expect(')
+          @source_rewriter.insert_after(subject_range, ')')
+        end
+
+        @source_rewriter.replace(selector_range, positive? ? 'to' : negative_form)
+
+        matcher.correct_operator!(parenthesize_matcher_arg)
+      end
+
+      def matcher
+        @matcher ||= Matcher.new(matcher_node, in_example_group_context?, @source_rewriter)
+      end
+
+      def matcher_node
+        arg_node || parent_node
+      end
+    end
+  end
+end

data/lib/transpec/syntax/should_receive.rb

@@ -0,0 +1,120 @@
+# coding: utf-8
+
+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
+
+      def positive?
+        method_name == :should_receive
+      end
+
+      def expectize!(negative_form = 'not_to')
+        unless in_example_group_context?
+          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, ')')
+        else
+          @source_rewriter.insert_before(subject_range, 'expect(')
+          @source_rewriter.insert_after(subject_range, ')')
+        end
+
+        to_receive = "#{positive? ? 'to' : negative_form} receive"
+        @source_rewriter.replace(selector_range, to_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, '}')
+        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
+      end
+
+      # subject.should_receive(:method_name).once.with do |block_arg|
+      # end
+      #
+      # (block
+      #   (send
+      #     (send
+      #       (send
+      #         (send nil :subject) :should_receive
+      #         (sym :method_name)) :once) :with)
+      #   (args
+      #     (arg :block_arg)) nil)
+      def block_node_taken_by_with_method_with_no_normal_args
+        @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 parent_node.type == :block
+            return nil unless child_node.children[1] == :with
+            return nil if child_node.children[2]
+            return parent_node
+          end
+
+          parent_node
+        end
+
+        nil
+      end
+
+      # subject.should_receive(:method_name) do |block_arg|
+      # end.once
+      #
+      # (send
+      #   (block
+      #     (send
+      #       (send nil :subject) :should_receive
+      #       (sym :method_name))
+      #     (args
+      #       (arg :block_arg)) nil) :once)
+      def block_node_followed_by_message_expectation_method
+        @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
+
+          parent_node
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/transpec/syntax.rb

@@ -0,0 +1,58 @@
+# coding: utf-8
+
+module Transpec
+  class Syntax
+    class NotInExampleGroupContextError < StandardError
+      attr_reader :message, :source_range
+
+      def initialize(source_range, original_syntax, target_syntax)
+        @source_range = source_range
+        @message = build_message(original_syntax, target_syntax)
+      end
+
+      def source_buffer
+        @source_range.source_buffer
+      end
+
+      private
+
+      def build_message(original_syntax, target_syntax)
+        "Cannot convert #{original_syntax} into #{target_syntax} " +
+        "since #{target_syntax} is not available in the context."
+      end
+    end
+
+    attr_reader :node, :ancestor_nodes, :in_example_group_context, :source_rewriter
+    alias_method :in_example_group_context?, :in_example_group_context
+
+    def self.all
+      @subclasses ||= []
+    end
+
+    def self.inherited(subclass)
+      all << subclass
+    end
+
+    def self.snake_case_name
+      @snake_cake_name ||= begin
+        class_name = name.split('::').last
+        class_name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+      end
+    end
+
+    def self.target_node?(node)
+      false
+    end
+
+    def initialize(node, ancestor_nodes, in_example_group_context, source_rewriter)
+      @node = node
+      @ancestor_nodes = ancestor_nodes
+      @in_example_group_context = in_example_group_context
+      @source_rewriter = source_rewriter
+    end
+
+    def parent_node
+      @ancestor_nodes.last
+    end
+  end
+end

data/lib/transpec/util.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+
+module Transpec
+  module Util
+    module_function
+
+    def proc_literal?(node)
+      return false unless node.type == :block
+
+      send_node = node.children.first
+      receiver_node, method_name, *_ = *send_node
+
+      if receiver_node.nil? || const_name(receiver_node) == 'Kernel'
+        [:lambda, :proc].include?(method_name)
+      elsif const_name(receiver_node) == 'Proc'
+        method_name == :new
+      else
+        false
+      end
+    end
+
+    def const_name(node)
+      return nil if node.nil? || node.type != :const
+
+      const_names = []
+      const_node = node
+
+      loop do
+        namespace_node, name = *const_node
+        const_names << name
+        break unless namespace_node
+        break if namespace_node.type == :cbase
+        const_node = namespace_node
+      end
+
+      const_names.reverse.join('::')
+    end
+
+    def here_document?(node)
+      return false unless [:str, :dstr].include?(node.type)
+      node.loc.begin.source.start_with?('<<')
+    end
+
+    def indentation_of_line(node)
+      line = node.loc.expression.source_line
+      /^(?<indentation>\s*)\S/ =~ line
+      indentation
+    end
+  end
+end

data/lib/transpec/version.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+module Transpec
+  # http://semver.org/
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 1
+
+    def self.to_s
+      [MAJOR, MINOR, PATCH].join('.')
+    end
+  end
+end

data/lib/transpec.rb

@@ -0,0 +1,17 @@
+# coding: utf-8
+
+require 'transpec/configuration'
+require 'transpec/cli'
+require 'transpec/git'
+require 'transpec/rewriter'
+require 'transpec/util'
+require 'transpec/version'
+require 'transpec/ast/scanner'
+require 'transpec/ast/scope_stack'
+require 'transpec/syntax'
+require 'transpec/syntax/send_node_syntax'
+require 'transpec/syntax/double'
+require 'transpec/syntax/matcher'
+require 'transpec/syntax/method_stub'
+require 'transpec/syntax/should'
+require 'transpec/syntax/should_receive'

data/spec/.rubocop.yml

@@ -0,0 +1,19 @@
+
+inherit_from: ../.rubocop.yml
+
+# Avoid warning "Possibly useless use of == in void context"
+# for `should ==`
+Void:
+  Enabled: false
+
+# Lengthen for long descriptions.
+LineLength:
+  Max: 110
+
+# raise_error matcher always requires {} form block.
+Blocks:
+  Enabled: false
+
+# Sometimes block alignment does not suit RSpec syntax.
+BlockAlignment:
+  Enabled: false

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    # Yes, I'm writing specs in should syntax intentionally!
+    c.syntax = :should
+  end
+
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run_excluding do_not_run_in_transpeced_spec: ENV['TRANSPECED_SPEC']
+end
+
+Dir[File.join(File.dirname(__FILE__), 'support', '*')].each do |path|
+  require path
+end
+
+require 'simplecov'
+SimpleCov.coverage_dir(File.join('spec', 'coverage'))
+
+if ENV['TRAVIS']
+  require 'coveralls'
+  SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+elsif ENV['CI']
+  require 'simplecov-rcov'
+  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
+end
+
+SimpleCov.start do
+  add_filter '/spec/'
+  add_filter '/vendor/bundle/'
+end
+
+require 'transpec'

data/spec/spec_spec.rb

@@ -0,0 +1,54 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'tmpdir'
+require 'English'
+
+describe 'Transpec project spec', :do_not_run_in_transpeced_spec do
+  around do |example|
+    Dir.chdir(project_root) do
+      example.run
+    end
+  end
+
+  let(:project_root) do
+    File.expand_path('..', File.dirname(__FILE__))
+  end
+
+  let(:spec_dir) do
+    File.join(project_root, 'spec')
+  end
+
+  TRANSPECED_SPEC_DIR = File.join(Dir.mktmpdir, 'transpeced_spec')
+
+  def silent_system(*args)
+    original_env = ENV.to_hash
+
+    if args.first.is_a?(Hash)
+      custom_env = args.shift
+      ENV.update(custom_env)
+    end
+
+    command = args.shelljoin
+    `#{command}`
+
+    ENV.replace(original_env)
+    $CHILD_STATUS.success?
+  rescue
+    ENV.replace(original_env)
+    false
+  end
+
+  it 'can be converted by Transpec itself without error' do
+    FileUtils.cp_r(spec_dir, TRANSPECED_SPEC_DIR)
+    silent_system('./bin/transpec', '--force', TRANSPECED_SPEC_DIR).should be_true
+  end
+
+  describe 'converted spec' do
+    it 'passes all' do
+      pending 'Need to rewrite syntax configuration in RSpec.configure'
+      env = { 'TRANSPECED_SPEC' => 'true' }
+      silent_system(env, 'rspec', TRANSPECED_SPEC_DIR).should be_true
+    end
+  end
+end

data/spec/support/file_helper.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'fileutils'
+
+module FileHelper
+  module_function
+
+  def create_file(file_path, content)
+    file_path = File.expand_path(file_path)
+
+    dir_path = File.dirname(file_path)
+    FileUtils.makedirs(dir_path) unless File.exists?(dir_path)
+
+    File.open(file_path, 'w') do |file|
+      case content
+      when String
+        file.puts content
+      when Array
+        file.puts content.join("\n")
+      else
+        fail 'Unsupported type!'
+      end
+    end
+  end
+end