minitest_to_rspec 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c9d5f1d2e46d2dda762773e68dbe9e52ab2fdf6
-  data.tar.gz: e8c9aa28efe6397fdd477ca2fab1906eedd2ec76
+  metadata.gz: c5b86085638913b9300eac531234df1080da30f8
+  data.tar.gz: 25716e1fa38dd1770ecf4d6af06d1ae17e83f9b8
 SHA512:
-  metadata.gz: fbb7261a6826ad41645eabe1e196d27e063885cee9d3f0597ca6634957a07986367216762cd99f23e06e5c0c0597a51c7c19fa3561cdab117bc01c88f2ef4625
-  data.tar.gz: f3bb7eedbe467dd10895ae229e8578d3cb0f7108c352e555f072e633cac0bb3ab2e1ddbe19de03476c6a047655032186fe2e310696f311f3e2463f324925843d
+  metadata.gz: 5f77f05e827b8a7ccf6670bd10f3ff595199b19be8398035377c3efad2ded7f251b188a5ba0a0d443abc7d78debcfab986a17b001afc2b653a9ee7ee9d1a51ba
+  data.tar.gz: 602e936f4681ccb800f950185d8fb970299531a5616346a72b7f2a49c80e21aedf8168aa1aff1f87e36e2eafee9c45a59e54919a8e2985178236e853d63d858e

data/CHANGELOG.md

@@ -4,6 +4,27 @@ Change Log
 This project follows [semver 2.0.0][1] and the recommendations
 of [keepachangelog.com][2].
 
+0.7.0
+-----
+
+### Changed
+- `assert` on a question-mark method converts to `eq(true)` instead
+  of `be_truthy`. Likewise, `refute` converts to `eq(false)`. This is not
+  guaranteed to be the same as minitest's fuzzy `assert`, but the convention of
+  question-mark methods returning real booleans is strong.
+
+### Added
+- Converts assert_not_nil
+- CLI
+  - Added `--mocha` flag. If present, converts mocha to
+    rspec-mocks. (Experimental)
+  - Creates `target_file` directory if it does not exist
+- Experimental
+  - mocha: with
+
+### Fixed
+- `__FILE__` keyword in input
+
 0.6.2
 -----
 

data/README.md

@@ -7,6 +7,7 @@ Converts [minitest][8] files to [rspec][9].
 - Selected assertions from [Test::Unit][26], [minitest][8],
   and [ActiveSupport][27] are converted to [rspec-expectations][25].
 - Selected methods from [mocha][28] are converted to [rspec-mocks][24].
+  (Experimental)
 
 Example
 -------
@@ -28,26 +29,22 @@ end
 Output:
 
 ```ruby
-require("spec_helper")
-RSpec.describe(Array) do
-  it("changes length") do
+require "spec_helper"
+RSpec.describe Array do
+  it "changes length" do
     ary = []
-    expect { ary.push(:x) }.to(change { ary.length })
+    expect { ary.push(:x) }.to change { ary.length }
   end
 end
 ```
 
-The code style is whatever [ruby2ruby][6] feels like printing,
-and is not configurable.  Comments are discarded.
-
 Usage
 -----
 
 ### CLI
 
 ```bash
-gem install mt2rspec
-bundle exec mt2rspec [--rails] source_file [target_file]
+bundle exec mt2rspec [--rails] [--mocha] source_file [target_file]
 bundle exec mt2rspec --help
 ```
 
@@ -55,16 +52,28 @@ bundle exec mt2rspec --help
 
 ```ruby
 require 'minitest_to_rspec'
-MinitestToRspec::Converter.new.convert("assert('banana')")
+converter = MinitestToRspec::Converter.new(rails: false, mocha: false)
+converter.convert("assert('banana')")
 #=> "expect(\"banana\").to(be_truthy)"
 ```
 
+Output
+------
+
+The primary goal is correctness, but [code style][34] is also important. To
+allow us to configure our output, we use [sexp2ruby][33] instead of
+[ruby2ruby][6]. As [sexp2ruby][33] adds more configuration options, we'll make
+use of them.
+
+Comments are discarded by [ruby_parser][14], so we have no way of
+preserving them.
+
 Supported Assertions
 --------------------
 
-Selected assertions from minitest, Test::Unit, and ActiveSupport.
-See [doc/supported_assertions.md][5] for rationale.  Contributions
-are welcome.
+Selected assertions from [minitest][8], [Test::Unit][26], and
+[ActiveSupport][27]. See [doc/supported_assertions.md][5] for rationale.
+Contributions are welcome.
 
 Assertion                   | Arity | Source
 --------------------------- | ----- | ------
@@ -74,6 +83,7 @@ assert_difference           | 1,2   |
 [assert_not_equal][22]      | 2,3   | Test::Unit
 assert_match                |       |
 assert_nil                  |       |
+assert_not_nil              |       |
 [assert_no_difference][12]  |       | ActiveSupport
 [assert_nothing_raised][10] |       | Test::Unit
 [assert_raise][11]          | 0..2  | Test::Unit
@@ -81,8 +91,6 @@ assert_nil                  |       |
 refute                      |       |
 refute_equal                |       |
 
-To do: assert_not_nil
-
 Supported Mocha
 ---------------
 
@@ -136,3 +144,5 @@ This project would not be possible without [ruby_parser][14],
 [30]: http://www.rubydoc.info/github/floehopper/mocha/Mocha/Expectation
 [31]: http://www.rubydoc.info/github/floehopper/mocha/Mocha/Expectation#once-instance_method
 [32]: http://www.rubydoc.info/github/floehopper/mocha/Mocha/Expectation#twice-instance_method
+[33]: https://github.com/jaredbeck/sexp2ruby
+[34]: https://github.com/bbatsov/ruby-style-guide

data/lib/minitest_to_rspec/cli.rb

@@ -1,3 +1,4 @@
+require "fileutils"
 require "minitest_to_rspec"
 require "trollop"
 
@@ -7,34 +8,36 @@ module MinitestToRspec
     E_FILE_NOT_FOUND      = 2.freeze
     E_FILE_ALREADY_EXISTS = 3.freeze
     E_CONVERT_FAIL        = 4.freeze
+    E_CANNOT_CREATE_TARGET_DIR = 5.freeze
 
     BANNER = <<EOS.freeze
-Usage: mt2rspec --rails source_file [target_file]
+Usage: mt2rspec [--rails] [--mocha] source_file [target_file]
 
-Reads source_file, writes target_file.  If target_file is omitted,
-its location will be inferred.  For example, test/fruit/banana_test.rb
-implies spec/fruit/banana_spec.rb.
+Reads source_file, writes target_file. If target_file is omitted,
+its location will be inferred. For example, test/fruit/banana_test.rb
+implies spec/fruit/banana_spec.rb. If the target directory doesn't
+exist, it will be created.
 
 Options:
 EOS
-
+    OPT_MOCHA = "Convert mocha to rspec-mocks. (Experimental)"
     OPT_RAILS = <<EOS.gsub(/\n/, " ").freeze
 Requires rails_helper instead of spec_helper.
 Passes :type metadatum to RSpec.describe.
 EOS
 
-    attr_reader :rails, :source, :target
+    attr_reader :source, :target
 
     def initialize(args)
-      assert_trollop_version
-
       opts = Trollop.options(args) do
         version MinitestToRspec::VERSION
         banner BANNER
         opt :rails, OPT_RAILS, short: :none
+        opt :mocha, OPT_MOCHA, short: :none
       end
 
       @rails = opts[:rails]
+      @mocha = opts[:mocha]
       case args.length
       when 2
         @source, @target = args
@@ -50,7 +53,8 @@ EOS
     def run
       assert_file_exists(source)
       assert_file_does_not_exist(target)
-      write_target(converter.convert(read_source))
+      ensure_target_directory(target)
+      write_target(converter.convert(read_source, source))
     rescue Error => e
       $stderr.puts "Failed to convert: #{e}"
       exit E_CONVERT_FAIL
@@ -72,19 +76,20 @@ EOS
       end
     end
 
-    # Temporary assertion. It would be nice if gemspec supported git.
-    def assert_trollop_version
-      unless Trollop.method(:die).arity == -2
-        warn "Please use trollop version f7009b45 or greater."
-        warn "This manual version constraint will be removed when"
-        warn "https://github.com/ManageIQ/trollop/pull/63"
-        warn "is included in an official trollop release."
-        exit(-1)
-      end
+    def converter
+      Converter.new(mocha: @mocha, rails: @rails)
     end
 
-    def converter
-      Converter.new(rails: rails)
+    def ensure_target_directory(target)
+      dir = File.dirname(target)
+      return if Dir.exist?(dir)
+      begin
+        FileUtils.mkdir_p(dir)
+      rescue SystemCallError => e
+        $stderr.puts "Cannot create target dir: #{dir}"
+        $stderr.puts e.message
+        exit E_CANNOT_CREATE_TARGET_DIR
+      end
     end
 
     def infer_target_from(source)

data/lib/minitest_to_rspec/converter.rb

@@ -19,21 +19,24 @@ module MinitestToRspec
       to_not
     ]
 
-    def initialize(options)
-      @options = options
-      @processor = Processor.new(@options[:rails])
+    def initialize(rails: false, mocha: false)
+      @processor = Processor.new(rails, mocha)
     end
 
-    def convert(input)
-      render process parse input
+    # - `input` - Contents of a ruby file.
+    # - `file_path` - Optional. Value will replace any `__FILE__`
+    #   keywords in the input.
+    def convert(input, file_path = nil)
+      render process parse(input, file_path)
     end
 
     private
 
     # Parses input string and returns Abstract Syntax Tree (AST)
     # as an S-expression.
-    def parse(input)
-      RubyParser.new.parse(input)
+    def parse(input, file_path)
+      file_path ||= "No file path provided to #{self.class}#convert"
+      RubyParser.new.parse(input, file_path)
     end
 
     # Processes an AST (S-expressions) representing a minitest

data/lib/minitest_to_rspec/{exp → model}/base.rb

@@ -1,7 +1,7 @@
 require_relative "../sexp_assertions"
 
 module MinitestToRspec
-  module Exp
+  module Model
 
     # Classes inheriting `Base` are simple data objects
     # representing the S-expressions they are named after.

data/lib/minitest_to_rspec/{exp → model}/call.rb

@@ -1,7 +1,7 @@
 require_relative "base"
 
 module MinitestToRspec
-  module Exp
+  module Model
 
     # Data object.  Represents a `:call` s-expression.
     class Call < Base
@@ -35,7 +35,7 @@ module MinitestToRspec
         end
 
         def method_name?(exp, name)
-          exp.sexp_type == :call && new(exp).method_name == name
+          exp.sexp_type == :call && new(exp).method_name.to_s == name.to_s
         end
       end
 
@@ -70,6 +70,13 @@ module MinitestToRspec
         method_name == :assert_raises && raise_error_args?
       end
 
+      def calls_in_receiver_chain
+        receiver_chain.
+          compact.
+          select { |r| sexp_type?(:call, r) }.
+          map { |r| Call.new(r) }
+      end
+
       def method_name
         @exp[2]
       end
@@ -95,14 +102,14 @@ module MinitestToRspec
       end
 
       # While `#receiver` returns a `Sexp`, `#receiver_call`
-      # returns a `Exp::Call`.
+      # returns a `Model::Call`.
       def receiver_call
         if sexp_type?(:call, receiver)
-          rvc = Exp::Call.new(receiver)
+          rvc = Model::Call.new(receiver)
 
           # TODO: Seems like a factory pattern
           if rvc.method_name == :returns
-            Exp::Calls::Returns.new(receiver)
+            Model::Calls::Returns.new(receiver)
           else
             rvc
           end
@@ -111,12 +118,52 @@ module MinitestToRspec
         end
       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| Call.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)

data/lib/minitest_to_rspec/{exp → model}/calls/once.rb

@@ -2,7 +2,7 @@ require_relative "../call"
 require_relative "../../errors"
 
 module MinitestToRspec
-  module Exp
+  module Model
     module Calls
       class Once < Call
       end

data/lib/minitest_to_rspec/{exp → model}/calls/returns.rb

@@ -2,32 +2,29 @@ require_relative "../call"
 require_relative "../../errors"
 
 module MinitestToRspec
-  module Exp
+  module Model
     module Calls
 
       # Represents a call to `returns`, the stubbing method
       # from `mocha`.
       class Returns < Call
-        KNOWN_RECEIVERS = %i[stubs expects]
-        RSPEC_MOCK_METHODS = { expects: :expect, stubs: :allow }
+        KNOWN_RECEIVERS = %i[stubs expects with]
 
         def initialize(exp)
           @exp = exp
           raise UnknownVariant unless known_variant?
         end
 
+        def stub?
+          receiver_chain_include?(:stubs)
+        end
+
         def any_instance?
-          rcr = receiver_call.receiver
-          if !rcr.nil? && sexp_type?(:call, rcr)
-            Call.new(rcr).method_name == :any_instance
-          else
-            false
-          end
+          receiver_chain_include?(:any_instance)
         end
 
-        # The message recipient
-        def msg_recipient
-          receiver_call.receiver
+        def expectation?
+          receiver_chain_include?(:expects)
         end
 
         def known_variant?
@@ -40,13 +37,25 @@ module MinitestToRspec
         end
 
         def message
-          receiver_call.arguments[0]
+          calls_in_receiver_chain.
+            find { |c| [:stubs, :expects].include? c.method_name }.
+            arguments[0]
         end
 
         # To avoid a `ProcessingError` please check `known_variant?`
         # before calling `rspec_mocks_method`.
         def rspec_mocks_method
-          RSPEC_MOCK_METHODS[receiver_call.method_name]
+          s = stub?
+          e = expectation?
+          if s && e
+            raise ProcessingError, "Method chain contains stubs and expects"
+          elsif s
+            :allow
+          elsif e
+            :expect
+          else
+            raise ProcessingError, "Found returns without stubs or expects"
+          end
         end
 
         # Returns `Sexp` representing the object that will receive
@@ -55,16 +64,22 @@ module MinitestToRspec
         #     banana.stubs(:delicious?).returns(true)
         #     Kiwi.any_instance.stubs(:delicious?).returns(false)
         #
-        # The `rspec_msg_recipient` is `banana` and `Kiwi`, respectively.
+        # On the first line, the `rspec_msg_recipient` is `banana`. On the
+        # second, `Kiwi`.
         #
         def rspec_msg_recipient
-          any_instance? ? Call.new(msg_recipient).receiver : msg_recipient
+          receiver_chain.compact.last
         end
 
         # The return values
         def values
           arguments
         end
+
+        def with
+          w = calls_in_receiver_chain.find { |c| c.method_name == :with }
+          w.nil? ? [] : w.arguments
+        end
       end
     end
   end

data/lib/minitest_to_rspec/{exp → model}/calls/twice.rb

@@ -2,7 +2,7 @@ require_relative "../call"
 require_relative "../../errors"
 
 module MinitestToRspec
-  module Exp
+  module Model
     module Calls
       class Twice < Call
       end

data/lib/minitest_to_rspec/{exp → model}/hash_exp.rb

@@ -1,5 +1,5 @@
 module MinitestToRspec
-  module Exp
+  module Model
 
     # Data object.  Represents a `:hash` S-expression.
     class HashExp < Base

data/lib/minitest_to_rspec/{exp → model}/iter.rb

@@ -1,7 +1,7 @@
 require_relative "base"
 
 module MinitestToRspec
-  module Exp
+  module Model
 
     # Data object.  Represents an `:iter` s-expression.
     class Iter < Base
@@ -15,23 +15,23 @@ module MinitestToRspec
       end
 
       def assert_difference?
-        !empty? && Exp::Call.assert_difference?(@exp[1])
+        !empty? && Model::Call.assert_difference?(@exp[1])
       end
 
       def assert_no_difference?
-        !empty? && Exp::Call.assert_no_difference?(@exp[1])
+        !empty? && Model::Call.assert_no_difference?(@exp[1])
       end
 
       def assert_nothing_raised?
-        !empty? && Exp::Call.assert_nothing_raised?(@exp[1])
+        !empty? && Model::Call.assert_nothing_raised?(@exp[1])
       end
 
       def assert_raise?
-        !empty? && Exp::Call.assert_raise?(@exp[1])
+        !empty? && Model::Call.assert_raise?(@exp[1])
       end
 
       def assert_raises?
-        !empty? && Exp::Call.assert_raises?(@exp[1])
+        !empty? && Model::Call.assert_raises?(@exp[1])
       end
 
       def block
@@ -48,7 +48,7 @@ module MinitestToRspec
       end
 
       def call_obj
-        Exp::Call.new(call)
+        Model::Call.new(call)
       end
 
       # Enumerates children, skipping the base `call` and
@@ -63,11 +63,11 @@ module MinitestToRspec
       end
 
       def setup?
-        !empty? && Exp::Call.method_name?(@exp[1], :setup)
+        !empty? && Model::Call.method_name?(@exp[1], :setup)
       end
 
       def teardown?
-        !empty? && Exp::Call.method_name?(@exp[1], :teardown)
+        !empty? && Model::Call.method_name?(@exp[1], :teardown)
       end
 
       def sexp

data/lib/minitest_to_rspec/{exp → model}/klass.rb

@@ -1,7 +1,7 @@
 require_relative "base"
 
 module MinitestToRspec
-  module Exp
+  module Model
 
     # Data object.  Represents a `:class` S-expression.
     class Klass < Base

data/lib/minitest_to_rspec/processor.rb

@@ -6,22 +6,23 @@ require_relative "subprocessors/iter"
 
 module MinitestToRspec
   class Processor < SexpProcessor
-    def initialize(rails)
+    def initialize(rails, mocha)
       super()
       self.strict = false
+      @mocha = mocha
       @rails = rails
     end
 
     def process_call(exp)
-      Subprocessors::Call.new(exp, @rails).process
+      Subprocessors::Call.new(exp, @rails, @mocha).process
     end
 
     def process_class(exp)
-      Subprocessors::Klass.new(exp, @rails).process
+      Subprocessors::Klass.new(exp, @rails, @mocha).process
     end
 
     def process_iter(exp)
-      Subprocessors::Iter.new(exp).process
+      Subprocessors::Iter.new(exp, @rails, @mocha).process
     end
   end
 end

data/lib/minitest_to_rspec/subprocessors/base.rb

@@ -5,6 +5,11 @@ module MinitestToRspec
     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
@@ -64,7 +69,7 @@ module MinitestToRspec
       #
       # TODO: `full_process` may not be the best name.
       def full_process(obj)
-        obj.is_a?(Sexp) ? Processor.new(false).process(obj) : obj
+        obj.is_a?(Sexp) ? Processor.new(@rails, @mocha).process(obj) : obj
       end
 
       def matcher(name, *args)

data/lib/minitest_to_rspec/subprocessors/call.rb

@@ -1,34 +1,57 @@
-require_relative "../exp/call"
-require_relative "../exp/calls/returns"
-require_relative "../exp/hash_exp"
+require_relative "../model/call"
+require_relative "../model/calls/returns"
+require_relative "../model/hash_exp"
 require_relative "base"
 
 module MinitestToRspec
   module Subprocessors
     class Call < Base
-      def initialize(sexp, rails)
-        @exp = Exp::Call.new(sexp)
+
+      # 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
+      ]
+
+      def initialize(sexp, rails, mocha)
+        super(rails, mocha)
+        @exp = Model::Call.new(sexp)
         sexp.clear
-        @rails = rails
       end
 
-      # Given a `Exp::Call`, returns a `Sexp`
+      # Given a `Model::Call`, returns a `Sexp`
       def process
-        if respond_to?(name_of_processing_method, true)
+        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.
-      def allow_receive_and_return(msg_rcp, msg, ret_vals, any_ins = false)
-        allow_to(msg_rcp, receive_and_return(msg, ret_vals), any_ins)
+      # - 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
@@ -52,6 +75,10 @@ module MinitestToRspec
         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
@@ -60,17 +87,23 @@ module MinitestToRspec
       # - msg.  Message.  The name of the stubbed method.
       # - ret_vals.  Return values.
       # - any_ins.  Any instance?  True if this is an `any_instance` stub.
-      def expect_receive_and_return(msg_rcp, msg, ret_vals, any_ins = false)
-        expect_to(receive_and_return(msg, ret_vals), msg_rcp, true, any_ins)
+      # - 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)
-        Exp::HashExp.new(sexp).to_h.map { |msg, ret_val|
+        Model::HashExp.new(sexp).to_h.map { |msg, ret_val|
           expect_receive_and_return(
-            receiver.deep_clone, msg, wrap_sexp(ret_val)
+            receiver.deep_clone, msg, wrap_sexp(ret_val), false, []
           )
         }
       end
@@ -80,7 +113,7 @@ module MinitestToRspec
       end
 
       def method_assert
-        expect_to(be_truthy, @exp.arguments[0], true)
+        refsert eq(s(:true)), be_truthy
       end
 
       def method_assert_equal
@@ -99,6 +132,10 @@ module MinitestToRspec
         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]
@@ -118,7 +155,7 @@ module MinitestToRspec
       end
 
       def method_refute
-        expect_to(be_falsey, @exp.arguments[0], true)
+        refsert eq(s(:false)), be_falsey
       end
 
       def method_refute_equal
@@ -128,7 +165,7 @@ module MinitestToRspec
       end
 
       def method_returns
-        mocha_returns(Exp::Calls::Returns.new(@exp.original))
+        mocha_returns(Model::Calls::Returns.new(@exp.original))
       rescue UnknownVariant
         @exp.original
       end
@@ -176,7 +213,7 @@ module MinitestToRspec
       end
 
       def mocha_expects(exp)
-        raise ArgumentError unless exp.is_a?(Exp::Call)
+        raise ArgumentError unless exp.is_a?(Model::Call)
         arg = exp.arguments.first
         if sexp_type?(:hash, arg)
           mocha_expects_hash(exp, arg)
@@ -198,7 +235,7 @@ module MinitestToRspec
       end
 
       def mocha_expectation_count(exp, ordinal)
-        raise ArgumentError unless exp.is_a?(Exp::Call)
+        raise ArgumentError unless exp.is_a?(Model::Call)
         raise ArgumentError unless %i[once twice].include?(ordinal)
         rvc = exp.receiver_call
         receiver_processing_method = "mocha_#{rvc.method_name}".to_sym
@@ -214,21 +251,22 @@ module MinitestToRspec
         mocha_expectation_count(exp, :once)
       end
 
-      # Given `r`, a `Exp::Calls::Returns`, return a `Sexp` representing
+      # Given `r`, a `Model::Calls::Returns`, return a `Sexp` representing
       # the equivalent stub or message expectation in RSpec.
       def mocha_returns(r)
-        raise ArgumentError unless r.is_a?(Exp::Calls::Returns)
+        raise ArgumentError unless r.is_a?(Model::Calls::Returns)
         subprocessor_method = "#{r.rspec_mocks_method}_receive_and_return"
         send(subprocessor_method,
           r.rspec_msg_recipient,
           r.message,
           r.values,
-          r.any_instance?
+          r.any_instance?,
+          r.with
         )
       end
 
       def mocha_stub(exp)
-        raise ArgumentError unless exp.is_a?(Exp::Call)
+        raise ArgumentError unless exp.is_a?(Model::Call)
         if exp.receiver.nil?
           s(:call, nil, :double, *exp.arguments)
         else
@@ -275,16 +313,29 @@ module MinitestToRspec
         )
       end
 
-      def receive(message)
-        s(:call, nil, :receive, message)
+      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)
-        s(:call, receive(message), :and_return, *return_values)
+      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

data/lib/minitest_to_rspec/subprocessors/iter.rb

@@ -1,11 +1,12 @@
 require_relative "base"
-require_relative "../exp/iter"
+require_relative "../model/iter"
 
 module MinitestToRspec
   module Subprocessors
     class Iter < Base
-      def initialize(sexp)
-        @exp = Exp::Iter.new(sexp)
+      def initialize(sexp, rails, mocha)
+        super(rails, mocha)
+        @exp = Model::Iter.new(sexp)
         sexp.clear
       end
 
@@ -84,7 +85,7 @@ module MinitestToRspec
         RubyParser.new.parse(str)
       end
 
-      # Given a `Exp::Iter`, returns a `Sexp`
+      # Given a `Model::Iter`, returns a `Sexp`
       def process_exp(exp)
         if processable?(exp)
           send_to_processing_method(exp)

data/lib/minitest_to_rspec/subprocessors/klass.rb

@@ -1,5 +1,5 @@
 require_relative "../errors"
-require_relative "../exp/klass"
+require_relative "../model/klass"
 require_relative "base"
 
 module MinitestToRspec
@@ -9,10 +9,10 @@ module MinitestToRspec
       # 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)
-        @exp = Exp::Klass.new(sexp)
+      def initialize(sexp, rails, mocha)
+        super(rails, mocha)
+        @exp = Model::Klass.new(sexp)
         sexp.clear
-        @rails = rails
       end
 
       def process

data/lib/minitest_to_rspec/version.rb

@@ -1,3 +1,3 @@
 module MinitestToRspec
-  VERSION = "0.6.2".freeze
+  VERSION = "0.7.0".freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitest_to_rspec
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Jared Beck
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-18 00:00:00.000000000 Z
+date: 2015-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby_parser
@@ -180,14 +180,14 @@ files:
 - lib/minitest_to_rspec/cli.rb
 - lib/minitest_to_rspec/converter.rb
 - lib/minitest_to_rspec/errors.rb
-- lib/minitest_to_rspec/exp/base.rb
-- lib/minitest_to_rspec/exp/call.rb
-- lib/minitest_to_rspec/exp/calls/once.rb
-- lib/minitest_to_rspec/exp/calls/returns.rb
-- lib/minitest_to_rspec/exp/calls/twice.rb
-- lib/minitest_to_rspec/exp/hash_exp.rb
-- lib/minitest_to_rspec/exp/iter.rb
-- lib/minitest_to_rspec/exp/klass.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/returns.rb
+- lib/minitest_to_rspec/model/calls/twice.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/sexp_assertions.rb
 - lib/minitest_to_rspec/subprocessors/base.rb