minitest_to_rspec 0.11.0 → 0.12.0

data/lib/minitest_to_rspec/input/subprocessors/iter.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'minitest_to_rspec/input/subprocessors/base'
+require 'minitest_to_rspec/input/model/iter'
+
+module MinitestToRspec
+  module Input
+    module Subprocessors
+      # Processes `s(:iter, ..)` expressions.
+      class Iter < Base
+        def initialize(sexp, rails, mocha)
+          super(rails, mocha)
+          @exp = Model::Iter.new(sexp)
+          sexp.clear
+        end
+
+        def process
+          process_exp(@exp)
+        end
+
+        private
+
+        # Returns an expression representing an RSpec `change {}`
+        # matcher.  See also `change_by` below.
+        def change(exp)
+          matcher_with_block(:change, exp)
+        end
+
+        # Returns an expression representing an RSpec `change {}.by()` matcher.
+        def change_by(diff_exp, by_exp)
+          s(:call,
+            change(diff_exp),
+            :by,
+            by_exp
+          )
+        end
+
+        def matcher_with_block(matcher_name, block)
+          s(:iter,
+            s(:call, nil, matcher_name),
+            0,
+            block
+          )
+        end
+
+        def method_assert_difference(exp)
+          call = exp[1]
+          block = exp[3]
+          by = call[4]
+          what = parse(call[3][1])
+          matcher = by.nil? ? change(what) : change_by(what, by)
+          expect_to(matcher, block, false)
+        end
+
+        def method_assert_no_difference(exp)
+          call = exp[1]
+          block = exp[3]
+          what = parse(call[3][1])
+          expect_to_not(change(what), block, false)
+        end
+
+        def method_assert_nothing_raised(exp)
+          block = exp[3]
+          expect_to_not(raise_error, block, false)
+        end
+
+        def method_assert_raise(iter)
+          method_assert_raises(iter)
+        end
+
+        def method_assert_raises(iter)
+          expect_to(raise_error(*iter.call_arguments), iter.block, false)
+        end
+
+        def method_refute_raise(iter)
+          method_refute_raises(iter)
+        end
+
+        def method_refute_raises(iter)
+          expect_to_not(raise_error(*iter.call_arguments), iter.block, false)
+        end
+
+        def method_setup(exp)
+          replace_method_name(exp, :before)
+        end
+
+        def method_teardown(exp)
+          replace_method_name(exp, :after)
+        end
+
+        def name_of_processing_method(iter)
+          method_name = iter[1][2]
+          "method_#{method_name}".to_sym
+        end
+
+        def parse(str)
+          RubyParser.new.parse(str)
+        end
+
+        # Given a `Model::Iter`, returns a `Sexp`
+        def process_exp(exp)
+          if processable?(exp)
+            send_to_processing_method(exp)
+          else
+            process_uninteresting_iter(exp.sexp)
+          end
+        end
+
+        def processable?(iter)
+          if !iter.empty? && iter[1].sexp_type == :call
+            method_name = iter[1][2]
+            decision = "#{method_name}?".to_sym
+            iter.respond_to?(decision) && iter.public_send(decision)
+          else
+            false
+          end
+        end
+
+        def process_uninteresting_iter(exp)
+          iter = s(exp.shift)
+          until exp.empty?
+            iter << full_process(exp.shift)
+          end
+          iter
+        end
+
+        # Given `args` which came from an `assert_raise` or an
+        # `assert_raises`, return a `raise_error` matcher.
+        # When the last argument is a string, it represents the
+        # assertion failure message, and is discarded.
+        def raise_error(*args)
+          args.pop if !args.empty? && args.last.sexp_type == :str
+          matcher(:raise_error, *args)
+        end
+
+        def replace_method_name(exp, new_method)
+          iter = s(:iter, s(:call, nil, new_method))
+          exp.each do |e| iter << full_process(e) end
+          iter
+        end
+
+        def send_to_processing_method(exp)
+          send(name_of_processing_method(exp), exp)
+        end
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/input/subprocessors/klass.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'minitest_to_rspec/errors'
+require 'minitest_to_rspec/input/model/klass'
+require 'minitest_to_rspec/input/subprocessors/base'
+
+module MinitestToRspec
+  module Input
+    module Subprocessors
+      # Processes `s(:class, ..)` expressions.
+      class Klass < Base
+        # Takes `sexp`, a `:class` s-expression, and `rails`, a
+        # boolean indicating that `rspec-rails` conventions (like
+        # `:type` metadata) should be used.
+        def initialize(sexp, rails, mocha)
+          super(rails, mocha)
+          @exp = Model::Klass.new(sexp)
+          sexp.clear
+        end
+
+        def process
+          sexp = head
+          ebk = @exp.block
+          if ebk.length > 1
+            sexp << block
+          elsif ebk.length == 1
+            sexp << full_process(ebk[0])
+          end
+          sexp
+        end
+
+        private
+
+        # Returns a :block S-expression, the contents of the class.
+        def block
+          processed = @exp.block.map { |line| full_process(line) }
+          s(:block, *processed)
+        end
+
+        # Given a `test_class_name` like `BananaTest`, returns the
+        # described class, like `Banana`.
+        def described_class(test_class_name)
+          test_class_name.to_s.gsub(/Test\Z/, '').to_sym
+        end
+
+        # Returns the head of the output Sexp.  If it's a test case,
+        # an :iter representing an `RSpec.describe`.  Otherwise, a :class.
+        def head
+          if @exp.test_case?
+            rspec_describe_block
+          else
+            s(:class, @exp.name, @exp.parent)
+          end
+        end
+
+        # Returns an S-expression representing the
+        # RDM (RSpec Describe Metadata) hash
+        def rdm
+          s(:hash, s(:lit, :type), s(:lit, rdm_type))
+        end
+
+        # Returns the RDM (RSpec Describe Metadata) type.
+        #
+        # > Model specs: type: :model
+        # > Controller specs: type: :controller
+        # > Request specs: type: :request
+        # > Feature specs: type: :feature
+        # > View specs: type: :view
+        # > Helper specs: type: :helper
+        # > Mailer specs: type: :mailer
+        # > Routing specs: type: :routing
+        # > http://bit.ly/1G5w7CJ
+        #
+        # TODO: Obviously, they're not all supported yet.
+        def rdm_type
+          if @exp.action_controller_test_case?
+            :controller
+          elsif @exp.draper_test_case?
+            :decorator
+          elsif @exp.action_mailer_test_case?
+            :mailer
+          else
+            :model
+          end
+        end
+
+        def rspec_describe
+          const = s(:const, described_class(@exp.name))
+          call = s(:call, s(:const, :RSpec), :describe, const)
+          call << rdm if @rails
+          call
+        end
+
+        # Returns a S-expression representing a call to RSpec.describe
+        def rspec_describe_block
+          s(:iter, rspec_describe, 0)
+        end
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/minitest/stub.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'minitest_to_rspec/errors'
+require 'minitest_to_rspec/type'
+require 'minitest_to_rspec/input/model/call'
+
+module MinitestToRspec
+  module Minitest
+    # Represents an `expects` or a `stubs` from mocha.
+    # Conceptually the same as `Rspec::Stub`.
+    class Stub
+      def initialize(call)
+        Type.assert(Input::Model::Call, call)
+        @call = call
+      end
+
+      # Given e.g. `X.any_instance.expects(:y)`, returns `X`.
+      def receiver
+        chain = @call.receiver_chain
+        last = chain[-1]
+        last.nil? ? chain[-2] : last
+      end
+
+      # Returns true if we are stubbing any instance of `receiver`.
+      def any_instance?
+        @call.calls_in_receiver_chain.any? { |i|
+          i.method_name.to_s.include?('any_instance')
+        }
+      end
+
+      # Given e.g. `expects(:y)`, returns `:y`.
+      def message
+        case @call.method_name
+        when :expects, :stubs
+          @call.arguments.first
+        else
+          call = the_call_to_stubs_or_expects
+          if call.nil?
+            raise UnknownVariant, 'not a mocha stub, no stubs/expects'
+          else
+            call.arguments.first
+          end
+        end
+      end
+
+      def with
+        @call.find_call_in_receiver_chain(:with)&.arguments&.first
+      end
+
+      def returns
+        case @call.method_name
+        when :returns
+          @call.arguments.first
+        else
+          @call.find_call_in_receiver_chain(:returns)&.arguments&.first
+        end
+      end
+
+      # TODO: add support for
+      # - at_least
+      # - at_least_once
+      # - at_most
+      # - at_most_once
+      # - never
+      def count
+        case @call.method_name
+        when :expects, :once
+          1
+        when :returns
+          the_call_to_stubs_or_expects.method_name == :expects ? 1 : nil
+        when :twice
+          2
+        end
+      end
+
+      private
+
+      # Given an `exp` representing a chain of calls, like
+      # `stubs(x).returns(y).once`, finds the call to `stubs` or `expects`.
+      def the_call_to_stubs_or_expects
+        @call.find_call_in_receiver_chain(%i[stubs expects])
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/{expression_builders → rspec}/stub.rb

@@ -3,8 +3,9 @@
 require 'minitest_to_rspec/type'
 
 module MinitestToRspec
-  module ExpressionBuilders
-    # Represents an `expects` or a `stubs`
+  module Rspec
+    # Represents a `receive` matcher from RSpec.
+    # Conceptually the same as `Minitest::Stub`.
     class Stub
       def initialize(receiver, any_instance, message, with, returns, count)
         Type.assert(Sexp, receiver)

data/lib/minitest_to_rspec/type.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module MinitestToRspec
-  # Runtime type assertion function.
+  # Runtime type assertions.
   module Type
     class << self
       def assert(types, value)

data/lib/minitest_to_rspec/version.rb

@@ -2,7 +2,7 @@
 
 #:nodoc:
 module MinitestToRspec
-  VERSION = '0.11.0'
+  VERSION = '0.12.0'
 
   def self.gem_version
     ::Gem::Version.new(VERSION)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest_to_rspec
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Jared Beck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-10 00:00:00.000000000 Z
+date: 2018-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby2ruby
@@ -151,22 +151,21 @@ files:
 - lib/minitest_to_rspec/cli.rb
 - lib/minitest_to_rspec/converter.rb
 - lib/minitest_to_rspec/errors.rb
-- lib/minitest_to_rspec/expression_builders/stub.rb
-- lib/minitest_to_rspec/model/base.rb
-- lib/minitest_to_rspec/model/call.rb
-- lib/minitest_to_rspec/model/calls/once.rb
-- lib/minitest_to_rspec/model/calls/twice.rb
-- lib/minitest_to_rspec/model/defn.rb
-- lib/minitest_to_rspec/model/hash_exp.rb
-- lib/minitest_to_rspec/model/iter.rb
-- lib/minitest_to_rspec/model/klass.rb
-- lib/minitest_to_rspec/processor.rb
+- lib/minitest_to_rspec/input/model/base.rb
+- lib/minitest_to_rspec/input/model/call.rb
+- lib/minitest_to_rspec/input/model/defn.rb
+- lib/minitest_to_rspec/input/model/hash_exp.rb
+- lib/minitest_to_rspec/input/model/iter.rb
+- lib/minitest_to_rspec/input/model/klass.rb
+- lib/minitest_to_rspec/input/processor.rb
+- lib/minitest_to_rspec/input/subprocessors/base.rb
+- lib/minitest_to_rspec/input/subprocessors/call.rb
+- lib/minitest_to_rspec/input/subprocessors/defn.rb
+- lib/minitest_to_rspec/input/subprocessors/iter.rb
+- lib/minitest_to_rspec/input/subprocessors/klass.rb
+- lib/minitest_to_rspec/minitest/stub.rb
+- lib/minitest_to_rspec/rspec/stub.rb
 - lib/minitest_to_rspec/sexp_assertions.rb
-- lib/minitest_to_rspec/subprocessors/base.rb
-- lib/minitest_to_rspec/subprocessors/call.rb
-- lib/minitest_to_rspec/subprocessors/defn.rb
-- lib/minitest_to_rspec/subprocessors/iter.rb
-- lib/minitest_to_rspec/subprocessors/klass.rb
 - lib/minitest_to_rspec/type.rb
 - lib/minitest_to_rspec/version.rb
 - minitest_to_rspec.gemspec
@@ -190,7 +189,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Converts minitest files to rspec

data/lib/minitest_to_rspec/model/base.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../sexp_assertions'
-
-module MinitestToRspec
-  module Model
-    # Classes inheriting `Base` are simple data objects
-    # representing the S-expressions they are named after.
-    class Base
-      include SexpAssertions
-    end
-  end
-end

data/lib/minitest_to_rspec/model/call.rb

@@ -1,165 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-
-module MinitestToRspec
-  module Model
-    # Data object.  Represents a `:call` s-expression.
-    class Call < Base
-      attr_reader :original
-
-      def initialize(exp)
-        assert_sexp_type(:call, exp)
-        @exp = exp.dup
-        @original = exp.dup
-      end
-
-      class << self
-        def assert_difference?(exp)
-          exp.sexp_type == :call && new(exp).assert_difference?
-        end
-
-        def assert_no_difference?(exp)
-          exp.sexp_type == :call && new(exp).assert_no_difference?
-        end
-
-        def assert_nothing_raised?(exp)
-          exp.sexp_type == :call && new(exp).assert_nothing_raised?
-        end
-
-        def assert_raise?(exp)
-          exp.sexp_type == :call && new(exp).assert_raise?
-        end
-
-        def assert_raises?(exp)
-          exp.sexp_type == :call && new(exp).assert_raises?
-        end
-
-        def method_name?(exp, name)
-          exp.sexp_type == :call && new(exp).method_name.to_s == name.to_s
-        end
-      end
-
-      def arguments
-        @exp[3..-1] || []
-      end
-
-      def argument_types
-        arguments.map(&:sexp_type)
-      end
-
-      def assert_difference?
-        return false unless method_name == :assert_difference
-        [[:str], %i[str lit]].include?(argument_types)
-      end
-
-      def assert_no_difference?
-        method_name == :assert_no_difference &&
-          arguments.length == 1 &&
-          arguments[0].sexp_type == :str
-      end
-
-      def assert_nothing_raised?
-        method_name == :assert_nothing_raised && arguments.empty?
-      end
-
-      def assert_raise?
-        method_name == :assert_raise && raise_error_args?
-      end
-
-      def assert_raises?
-        method_name == :assert_raises && raise_error_args?
-      end
-
-      def calls_in_receiver_chain
-        receiver_chain.each_with_object([]) do |e, a|
-          next unless sexp_type?(:call, e)
-          a << self.class.new(e)
-        end
-      end
-
-      def find_call_in_receiver_chain(method_names)
-        name_array = [method_names].flatten
-        calls_in_receiver_chain.find { |i| name_array.include?(i.method_name) }
-      end
-
-      def method_name
-        @exp[2]
-      end
-
-      def num_arguments
-        arguments.length
-      end
-
-      def one_string_argument?
-        arguments.length == 1 && string?(arguments[0])
-      end
-
-      # Returns true if arguments can be processed into RSpec's `raise_error`
-      # matcher.  When the last argument is a string, it represents the
-      # assertion failure message, which will be discarded later.
-      def raise_error_args?
-        arg_types = arguments.map(&:sexp_type)
-        [[], [:str], [:const], %i[const str]].include?(arg_types)
-      end
-
-      def receiver
-        @exp[1]
-      end
-
-      # Consider the following chain of method calls:
-      #
-      #     @a.b.c
-      #
-      # whose S-expression is
-      #
-      #     s(:call, s(:call, s(:call, nil, :a), :b), :c)
-      #
-      # the "receiver chain" is
-      #
-      #     [
-      #       s(:call, s(:call, nil, :a), :b),
-      #       s(:call, nil, :a),
-      #       nil
-      #     ]
-      #
-      # The order of the returned array matches the order in which
-      # messages are received, i.e. the order of execution.
-      #
-      # Note that the final receiver `nil` is included. This `nil`
-      # represents the implicit receiver, e.g. `self` or `main`.
-      #
-      def receiver_chain
-        receivers = []
-        ptr = @exp
-        while sexp_type?(:call, ptr)
-          receivers << ptr[1]
-          ptr = ptr[1]
-        end
-        receivers
-      end
-
-      def receiver_chain_include?(method_name)
-        receiver_chain.compact.any? { |r|
-          self.class.method_name?(r, method_name)
-        }
-      end
-
-      def require_test_helper?
-        method_name == :require &&
-          one_string_argument? &&
-          arguments[0][1] == 'test_helper'
-      end
-
-      def question_mark_method?
-        method_name.to_s.end_with?('?')
-      end
-
-      private
-
-      def string?(exp)
-        exp.sexp_type == :str
-      end
-    end
-  end
-end