minitest_to_rspec 0.11.0 → 0.12.0

data/lib/minitest_to_rspec/model/calls/once.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../call'
-require_relative '../../errors'
-
-module MinitestToRspec
-  module Model
-    module Calls
-      class Once < Call
-      end
-    end
-  end
-end

data/lib/minitest_to_rspec/model/calls/twice.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../call'
-require_relative '../../errors'
-
-module MinitestToRspec
-  module Model
-    module Calls
-      class Twice < Call
-      end
-    end
-  end
-end

data/lib/minitest_to_rspec/model/defn.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module MinitestToRspec
-  module Model
-    # Data object.  Represents a `:defn` s-expression.
-    class Defn < Base
-      def initialize(exp)
-        assert_sexp_type(:defn, exp)
-        @exp = exp.dup
-      end
-
-      def body
-        @exp[3..-1]
-      end
-
-      def method_name
-        @exp[1].to_s
-      end
-
-      def test_method?
-        method_name.start_with?('test_')
-      end
-    end
-  end
-end

data/lib/minitest_to_rspec/model/hash_exp.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-module MinitestToRspec
-  module Model
-    # Data object.  Represents a `:hash` S-expression.
-    class HashExp < Base
-      def initialize(sexp)
-        assert_sexp_type(:hash, sexp)
-        @exp = sexp.dup
-      end
-
-      # A slightly nicer implementation would be:
-      # `@exp[1..-1].each_slice(2).to_h`
-      # but that would require ruby >= 2.1
-      def to_h
-        Hash[@exp[1..-1].each_slice(2).to_a]
-      end
-    end
-  end
-end

data/lib/minitest_to_rspec/model/iter.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module MinitestToRspec
-  module Model
-    # Data object.  Represents an `:iter` s-expression.
-    class Iter < Base
-      def initialize(exp)
-        assert_sexp_type(:iter, exp)
-        @exp = exp.dup
-      end
-
-      def [](*args)
-        @exp[*args]
-      end
-
-      def assert_difference?
-        !empty? && Model::Call.assert_difference?(@exp[1])
-      end
-
-      def assert_no_difference?
-        !empty? && Model::Call.assert_no_difference?(@exp[1])
-      end
-
-      def assert_nothing_raised?
-        !empty? && Model::Call.assert_nothing_raised?(@exp[1])
-      end
-
-      def assert_raise?
-        !empty? && Model::Call.assert_raise?(@exp[1])
-      end
-
-      def assert_raises?
-        !empty? && Model::Call.assert_raises?(@exp[1])
-      end
-
-      def block
-        @exp[3]
-      end
-
-      def call
-        @exp[1]
-      end
-
-      # Not to be confused with block arguments.
-      def call_arguments
-        call_obj.arguments
-      end
-
-      def call_obj
-        Model::Call.new(call)
-      end
-
-      # Enumerates children, skipping the base `call` and
-      # starting with the block arguments, then each `:call` in
-      # the block.
-      def each
-        @exp[2..-1].each do |e| yield(e) end
-      end
-
-      def empty?
-        @exp.length == 1 # just the sexp_type
-      end
-
-      def setup?
-        !empty? && Model::Call.method_name?(@exp[1], :setup)
-      end
-
-      def teardown?
-        !empty? && Model::Call.method_name?(@exp[1], :teardown)
-      end
-
-      def sexp
-        @exp
-      end
-    end
-  end
-end

data/lib/minitest_to_rspec/model/klass.rb

@@ -1,100 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module MinitestToRspec
-  module Model
-    # Data object.  Represents a `:class` S-expression.
-    class Klass < Base
-      def initialize(exp)
-        assert_sexp_type(:class, exp)
-        @exp = exp.dup
-        assert_valid_name
-      end
-
-      def action_controller_test_case?
-        lineage?(parent, %i[ActionController TestCase])
-      end
-
-      def action_mailer_test_case?
-        lineage?(parent, %i[ActionMailer TestCase])
-      end
-
-      def active_support_test_case?
-        lineage?(parent, %i[ActiveSupport TestCase])
-      end
-
-      # Raise an error if we don't know now to process the name
-      # of this class.  Specifically, classes with module-shorthand.
-      def assert_valid_name
-        if name.is_a?(Symbol)
-          # Valid
-        elsif name.respond_to?(:sexp_type) && name.sexp_type == :colon2
-          raise ModuleShorthandError
-        else
-          raise ProcessingError, "Unexpected class expression: #{name}"
-        end
-      end
-
-      def block?
-        !block.empty?
-      end
-
-      def block
-        @_block ||= @exp[3..-1] || []
-      end
-
-      def draper_test_case?
-        lineage?(parent, %i[Draper TestCase])
-      end
-
-      # Returns the name of the class.  Examples:
-      #
-      # - Banana #=> :Banana
-      # - Fruit::Banana #=> s(:colon2, s(:const, :Fruit), :Banana)
-      #
-      # Note that the latter (module shorthand) is not supported
-      # by MinitestToRspec.  See `#assert_valid_name`.
-      #
-      def name
-        @exp[1]
-      end
-
-      # Returns the "inheritance".  Examples:
-      #
-      # - Inherit nothing #=> nil
-      # - Inherit Foo #=> s(:const, :Foo)
-      # - Inherit Bar::Foo #=> s(:colon2, s(:const, :Bar), :Foo)
-      #
-      def parent
-        @_parent ||= @exp[2]
-      end
-
-      # Returns true if `@exp` inherits from, e.g. ActiveSupport::TestCase.
-      # TODO: Other test case parent classes.
-      def test_case?
-        return false unless sexp_type?(:colon2, parent)
-        active_support_test_case? ||
-          action_controller_test_case? ||
-          action_mailer_test_case? ||
-          draper_test_case?
-      end
-
-      private
-
-      def ancestor_name(exp, index)
-        assert_sexp_type(:colon2, exp)
-        ancestor = exp[index + 1]
-        sexp_type?(:const, ancestor) ? ancestor[1] : ancestor
-      end
-
-      def lineage?(exp, names)
-        assert_sexp_type(:colon2, exp)
-        exp.length == names.length + 1 &&
-          names.each_with_index.all? { |name, ix|
-            name.to_sym == ancestor_name(exp, ix).to_sym
-          }
-      end
-    end
-  end
-end

data/lib/minitest_to_rspec/processor.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'ruby_parser'
-require 'sexp_processor'
-require_relative 'subprocessors/call'
-require_relative 'subprocessors/defn'
-require_relative 'subprocessors/klass'
-require_relative 'subprocessors/iter'
-
-module MinitestToRspec
-  # Consumes a `String` of minitest code and returns an S-expression
-  # representing equivalent RSpec code. The main method is `#process`. See
-  # `SexpProcessor` docs for details.
-  class Processor < SexpProcessor
-    def initialize(rails, mocha)
-      super()
-      self.strict = false
-      @mocha = mocha
-      @rails = rails
-    end
-
-    def process_call(exp)
-      Subprocessors::Call.new(exp, @rails, @mocha).process
-    end
-
-    def process_class(exp)
-      Subprocessors::Klass.new(exp, @rails, @mocha).process
-    end
-
-    def process_defn(exp)
-      Subprocessors::Defn.new(exp, @rails, @mocha).process
-    end
-
-    def process_iter(exp)
-      Subprocessors::Iter.new(exp, @rails, @mocha).process
-    end
-  end
-end

data/lib/minitest_to_rspec/subprocessors/base.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../sexp_assertions'
-
-module MinitestToRspec
-  module Subprocessors
-    # Parent class of "sub-processors". There is one sub-processor for each
-    # `sexp_type` that `Processor` knows how to process.
-    #
-    # For example, `Subprocessors::Call` will process an `s(:call, ..)`
-    # expression representing minitest code, and return an S-expression
-    # representing equivalent RSpec code.
-    class Base
-      include SexpAssertions
-
-      def initialize(rails, mocha)
-        @rails = rails
-        @mocha = mocha
-      end
-
-      # Returns a s-expression representing an rspec-mocks stub.
-      def allow_to(msg_recipient, matcher, any_instance = false)
-        allow_method = any_instance ? :allow_any_instance_of : :allow
-        target = s(:call, nil, allow_method, msg_recipient)
-        s(:call, target, :to, matcher)
-      end
-
-      # Returns a s-expression representing an RSpec expectation, i.e. the
-      # combination of an "expectation target" and a matcher.
-      def expect(target, eager, phase, matcher, any_instance)
-        et = expectation_target(target, eager, any_instance)
-        s(:call, et, phase, matcher)
-      end
-
-      def expect_to(matcher, target, eager, any_instance = false)
-        expect(target, eager, :to, matcher, any_instance)
-      end
-
-      def expect_to_not(matcher, target, eager)
-        expect(target, eager, :to_not, matcher, false)
-      end
-
-      # In RSpec, `expect` returns an "expectation target".  This
-      # can be based on an expression, as in `expect(1 + 1)` or it
-      # can be based on a block, as in `expect { raise }`.  Either
-      # way, it's called an "expectation target".
-      def expectation_target(exp, eager, any_instance)
-        if eager
-          expectation_target_eager(exp, any_instance)
-        else
-          expectation_target_lazy(exp)
-        end
-      end
-
-      def expectation_target_eager(exp, any_instance)
-        expect_method = any_instance ? :expect_any_instance_of : :expect
-        s(:call, nil, expect_method, exp)
-      end
-
-      def expectation_target_lazy(block)
-        s(:iter,
-          s(:call, nil, :expect),
-          0,
-          full_process(block)
-        )
-      end
-
-      # If it's a `Sexp`, run `obj` through a new `Processor`.  Otherwise,
-      # return `obj`.
-      #
-      # This is useful for expressions that cannot be fully understood by a
-      # single subprocessor.  For example, we must begin processing all :iter
-      # expressions, because some :iter represent calls we're interested in,
-      # e.g. `assert_difference`.  However, if the :iter turns out to be
-      # uninteresting (perhaps it has no assertions) we still want to fully
-      # process its sub-expressions.
-      #
-      # TODO: `full_process` may not be the best name.
-      def full_process(obj)
-        obj.is_a?(Sexp) ? Processor.new(@rails, @mocha).process(obj) : obj
-      end
-
-      def matcher(name, *args)
-        exp = s(:call, nil, name)
-        exp.concat(args)
-      end
-    end
-  end
-end

data/lib/minitest_to_rspec/subprocessors/call.rb

@@ -1,391 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest_to_rspec/type'
-require 'minitest_to_rspec/expression_builders/stub'
-require_relative '../model/call'
-require_relative '../model/hash_exp'
-require_relative 'base'
-
-module MinitestToRspec
-  module Subprocessors
-    # Processes `s(:call, ..)` expressions.
-    class Call < Base
-      # Mocha methods will only be processed if `--mocha` flag was given,
-      # i.e. `mocha` argument in constructor is true.
-      MOCHA_METHODS = %i[
-        expects
-        once
-        returns
-        stub
-        stubs
-        stub_everything
-        twice
-      ].freeze
-
-      def initialize(sexp, rails, mocha)
-        super(rails, mocha)
-        @exp = Model::Call.new(sexp)
-        sexp.clear
-      end
-
-      # Given a `Model::Call`, returns a `Sexp`
-      def process
-        if process?
-          send(name_of_processing_method)
-        else
-          @exp.original
-        end
-      end
-
-      def process?
-        respond_to?(name_of_processing_method, true) &&
-          (@mocha || !MOCHA_METHODS.include?(@exp.method_name))
-      end
-
-      private
-
-      # - msg_rcp.  Message recipient.  The object to be stubbed.
-      # - msg.  Message.  The name of the stubbed method.
-      # - ret_vals.  Return values.
-      # - any_ins.  Any instance?  True if this is an `any_instance` stub.
-      # - with. Allowed arguments.
-      def allow_receive_and_return(msg_rcp, msg, ret_vals, any_ins, with)
-        allow_to(
-          msg_rcp,
-          receive_and_return(msg, ret_vals, with),
-          any_ins
-        )
-      end
-
-      # Given `exp`, an S-expression representing an rspec-mocks statement
-      # (expect or allow) apply `ordinal`, which is either `:once` or `:twice`.
-      # This feels like a hack.  No other processing "re-opens" an "output
-      # sexp".
-      def apply_expectation_count_to(exp, ordinal)
-        exp[3] = s(:call, exp[3], ordinal)
-        exp
-      end
-
-      def be_falsey
-        matcher(:be_falsey)
-      end
-
-      def be_nil
-        matcher(:be_nil)
-      end
-
-      def be_truthy
-        matcher(:be_truthy)
-      end
-
-      def call_to_question_mark?(exp)
-        sexp_type?(:call, exp) && Model::Call.new(exp).question_mark_method?
-      end
-
-      def eq(exp)
-        matcher(:eq, exp)
-      end
-
-      # - msg_rcp.  Message recipient.  The object to be stubbed.
-      # - msg.  Message.  The name of the stubbed method.
-      # - ret_vals.  Return values.
-      # - any_ins.  Any instance?  True if this is an `any_instance` stub.
-      # - with. Allowed arguments.
-      def expect_receive_and_return(msg_rcp, msg, ret_vals, any_ins, with)
-        expect_to(
-          receive_and_return(msg, ret_vals, with),
-          msg_rcp,
-          true,
-          any_ins
-        )
-      end
-
-      # Given a `Sexp` representing a `Hash` of message expectations,
-      # return an array of `Sexp`, each representing an expectation
-      # in rspec-mocks syntax.
-      def hash_to_expectations(sexp, receiver)
-        Model::HashExp.new(sexp).to_h.map { |msg, ret_val|
-          expect_receive_and_return(
-            receiver.deep_clone, msg, wrap_sexp(ret_val), false, []
-          )
-        }
-      end
-
-      def match(pattern)
-        matcher(:match, pattern)
-      end
-
-      def method_assert
-        refsert eq(s(:true)), be_truthy
-      end
-
-      def method_assert_equal
-        expected = @exp.arguments[0]
-        calculated = @exp.arguments[1]
-        expect_to(eq(expected), calculated, true)
-      end
-
-      def method_assert_match
-        pattern = @exp.arguments[0]
-        string = @exp.arguments[1]
-        expect_to(match(pattern), string, true)
-      end
-
-      def method_assert_nil
-        expect_to(be_nil, @exp.arguments[0], true)
-      end
-
-      def method_assert_not_nil
-        expect_to_not(be_nil, @exp.arguments[0], true)
-      end
-
-      def method_assert_not_equal
-        expected = @exp.arguments[0]
-        calculated = @exp.arguments[1]
-        expect_to_not(eq(expected), calculated, true)
-      end
-
-      def method_expects
-        if @exp.num_arguments == 1
-          mocha_expects(@exp)
-        else
-          @exp.original
-        end
-      end
-
-      def method_once
-        mocha_once(@exp)
-      end
-
-      def method_refute
-        refsert eq(s(:false)), be_falsey
-      end
-
-      def method_refute_equal
-        unexpected = @exp.arguments[0]
-        calculated = @exp.arguments[1]
-        expect_to_not(eq(unexpected), calculated, true)
-      end
-
-      # Processes an entire line of code that ends in `.returns`
-      def method_returns
-        receiver = mocha_stub_receiver(@exp)
-        any_instance = rspec_any_instance?(@exp)
-        message_call = mocha_stub_expects(@exp)
-        message = message_call.arguments.first
-        with = mocha_stub_with(@exp)
-        returns = @exp.arguments.first
-        count = message_call.method_name == :expects ? 1 : nil
-        ExpressionBuilders::Stub.new(
-          receiver, any_instance, message, with, returns, count
-        ).to_rspec_exp
-      rescue StandardError
-        # TODO: We used to have an `UnknownVariant` error.
-        # That was nice and specific.
-        @exp.original
-      end
-
-      def method_require
-        if @exp.require_test_helper?
-          require_spec_helper
-        else
-          @exp.original
-        end
-      end
-
-      def method_should
-        s(:call, nil, :it, *@exp.arguments)
-      end
-
-      # Happily, the no-block signatures of [stub][3] are the
-      # same as [double][2].
-      #
-      # - (name)
-      # - (stubs)
-      # - (name, stubs)
-
-      def method_stub
-        mocha_stub(@exp)
-      end
-
-      # [stub_everything][1] responds to all messages with nil.
-      # [double.as_null_object][4] responds with self.  Not a
-      # drop-in replacement, but will work in many situations.
-      # RSpec doesn't provide an equivalent to `stub_everything`,
-      # AFAIK.
-
-      def method_stub_everything
-        if @exp.receiver.nil?
-          d = s(:call, nil, :double, *@exp.arguments)
-          s(:call, d, :as_null_object)
-        else
-          @exp.original
-        end
-      end
-
-      def method_test
-        s(:call, nil, :it, *@exp.arguments)
-      end
-
-      def method_twice
-        mocha_twice(@exp)
-      end
-
-      def mocha_expects(exp)
-        raise ArgumentError unless exp.is_a?(Model::Call)
-        arg = exp.arguments.first
-        if sexp_type?(:hash, arg)
-          mocha_expects_hash(exp, arg)
-        elsif sexp_type?(:lit, arg)
-          mocha_expects_lit(exp, arg)
-        else
-          exp.original
-        end
-      end
-
-      def mocha_expects_hash(exp, hash_sexp)
-        assert_sexp_type(:hash, hash_sexp)
-        pointless_lambda(hash_to_expectations(hash_sexp, exp.receiver))
-      end
-
-      def mocha_expects_lit(exp, lit_sexp)
-        assert_sexp_type(:lit, lit_sexp)
-        expect_to(receive_and_call_original(lit_sexp), exp.receiver, true)
-      end
-
-      # TODO: add support for
-      # - at_least
-      # - at_least_once
-      # - at_most
-      # - at_most_once
-      # - never
-      def mocha_expectation_count(exp, count)
-        Type.assert(Model::Call, exp)
-        Type.assert(Integer, count)
-        receiver = mocha_stub_receiver(exp)
-        any_instance = rspec_any_instance?(exp)
-        message = mocha_stub_expects(exp).arguments.first
-        with = mocha_stub_with(exp)
-        returns = exp.find_call_in_receiver_chain(:returns)&.arguments&.first
-        ExpressionBuilders::Stub.new(
-          receiver, any_instance, message, with, returns, count
-        ).to_rspec_exp
-      end
-
-      # Given a mocha stub, e.g. `X.any_instance.expects(:y)`, returns `X`.
-      def mocha_stub_receiver(exp)
-        chain = exp.receiver_chain
-        last = chain[-1]
-        last.nil? ? chain[-2] : last
-      end
-
-      # Given an `exp` representing a chain of calls, like
-      # `stubs(x).returns(y).once`, finds the call to `stubs` or `expects`.
-      def mocha_stub_expects(exp)
-        exp.find_call_in_receiver_chain(%i[stubs expects])
-      end
-
-      def mocha_stub_with(exp)
-        exp.find_call_in_receiver_chain(:with)&.arguments&.first
-      end
-
-      def rspec_any_instance?(exp)
-        exp.calls_in_receiver_chain.any? { |i|
-          i.method_name.to_s.include?('any_instance')
-        }
-      end
-
-      def mocha_once(exp)
-        mocha_expectation_count(exp, 1)
-      end
-
-      def mocha_stub(exp)
-        raise ArgumentError unless exp.is_a?(Model::Call)
-        if exp.receiver.nil?
-          s(:call, nil, :double, *exp.arguments)
-        else
-          exp.original
-        end
-      end
-
-      def mocha_twice(exp)
-        mocha_expectation_count(exp, 2)
-      end
-
-      def name_of_processing_method
-        "method_#{@exp.method_name}".to_sym
-      end
-
-      # Given `array_of_calls`, returns a `Sexp` representing a
-      # self-executing lambda.
-      #
-      # This works around the fact that `sexp_processor` expects us to return
-      # a single `Sexp`, not an array of `Sexp`.  We also can't return a
-      # `:block`, or else certain input would produce nested blocks (e.g.
-      # `s(:block, s(:block, ..))`) which `ruby2ruby` (naturally) does not know
-      # how to process.  So, the easiest solution I could think of is a
-      # self-executing lambda.
-      #
-      # Currently, the only `:call` which we process into multiple calls is
-      # the hash form of a mocha `#expects`, thankfully uncommon.
-      #
-      # To get better output (without a pointless lambda) we would have to
-      # process `:block` *and* `:defn`, which we are not yet doing.
-
-      def pointless_lambda(array_of_calls)
-        assert_sexp_type_array(:call, array_of_calls)
-        s(:call,
-          s(:iter,
-            s(:call, nil, :lambda),
-            0,
-            s(:block,
-              s(:str, 'Sorry for the pointless lambda here.'),
-              *array_of_calls
-            )
-          ),
-          :call
-        )
-      end
-
-      def receive(message, with = [])
-        r = s(:call, nil, :receive, message)
-        if with.empty?
-          r
-        else
-          s(:call, r, :with, *with)
-        end
-      end
-
-      def receive_and_call_original(message)
-        s(:call, s(:call, nil, :receive, message), :and_call_original)
-      end
-
-      def receive_and_return(message, return_values, with = [])
-        s(:call, receive(message, with), :and_return, *return_values)
-      end
-
-      # `refsert` - Code shared by refute and assert. I could also have gone
-      # with `assfute`. Wooo .. time for bed.
-      def refsert(exact, fuzzy)
-        actual = @exp.arguments[0]
-        matcher = call_to_question_mark?(actual) ? exact : fuzzy
-        expect_to(matcher, actual, true)
-      end
-
-      def require_spec_helper
-        prefix = @rails ? 'rails' : 'spec'
-        s(:call, nil, :require, s(:str, "#{prefix}_helper"))
-      end
-
-      # Wraps `obj` in an `Array` if it is a `Sexp`
-      def wrap_sexp(obj)
-        obj.is_a?(Sexp) ? [obj] : obj
-      end
-    end
-  end
-end
-
-# [1]: http://bit.ly/1yll6ND
-# [2]: http://bit.ly/1CRdmP3
-# [3]: http://bit.ly/1aY2mJN
-# [4]: http://bit.ly/1OtwDOY