minitest_to_rspec 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: be2fe63a020fb7a38b10551341162eb978a0b84c
-  data.tar.gz: '0696d05d0c95b8cb6afbe1865ae224b2e8066e86'
+SHA256:
+  metadata.gz: e8f9207756131c32b3622da37695b0da546d38749df1d22ae1f7d1daa1f1f1a5
+  data.tar.gz: dfb8bb34cd541ed7172822c98ce84db91bb7b99af0bd3f01d907da50a0472af1
 SHA512:
-  metadata.gz: 1f44130fe3b150666829ff09abd348e92dffa6104f70678412ea1ef9e9e7cb363280549930796062d4c346590f634584cab18cd9db92f1c16f5a876b3ae88833
-  data.tar.gz: ef3a2361df027ddb59c33f858c49641f295298fa60d6a140bc63b60408e9706c2ec4d57cba346ed964d1eb7de5aa017b016b1bf151f403dfac5046f618b49c5b
+  metadata.gz: 45025ed9cdf045697a49d0571811fa14919ba91868044630de17f4436a0f1ffa32c6f172a9b8518eb7139dadce949798caa6a37828101303892d1055c3522001
+  data.tar.gz: 3ea95cd4da9200505c5c23bf072d084aa37d4994add74f8689e9766061046aa8a68ce6f66adb5c10d325143b3e73a878a86bafc5693088e5016fc4a4d01c7385

data/.travis.yml

@@ -1,7 +1,8 @@
 language: ruby
 rvm:
-  - "2.3.5"
-  - "2.4.2"
+  - "2.3.6"
+  - "2.4.3"
+  - "2.5.0"
 script: bundle exec rake
 sudo: false
 notifications:

data/CHANGELOG.md

@@ -17,6 +17,25 @@ of [keepachangelog.com][2].
 
 - None
 
+## 0.12.0 (2018-03-11)
+
+### Breaking Changes
+
+- None
+
+### Added
+
+- [#21](https://github.com/jaredbeck/minitest_to_rspec/pull/21) -
+  convert `setup`/`teardown` methods to `before`/`after` blocks
+- [#20](https://github.com/jaredbeck/minitest_to_rspec/pull/20) -
+  Support `refute_raise[s]`
+- [#18](https://github.com/jaredbeck/minitest_to_rspec/pull/18) -
+  Support namespaced exceptions for assert_raise[s]
+
+### Fixed
+
+- None
+
 ## 0.11.0 (2017-11-10)
 
 ### Breaking Changes

data/README.md

@@ -97,6 +97,8 @@ assert_not_nil              |       |
 [assert_raises][13]         | 0..2  | Minitest
 refute                      |       |
 refute_equal                |       |
+[refute_raise][39]          |       |
+[refute_raises][39]         |       |
 
 ## Supported Mocha
 
@@ -160,3 +162,4 @@ This project would not be possible without [ruby_parser][14],
 [36]: http://www.rubydoc.info/github/thoughtbot/shoulda-context/master/Shoulda/Context/ClassMethods#context-instance_method
 [37]: http://www.rubydoc.info/github/thoughtbot/shoulda-context/master/Shoulda/Context/Context#setup-instance_method
 [38]: http://www.rubydoc.info/github/thoughtbot/shoulda-context/master/Shoulda/Context/ClassMethods#should-instance_method
+[39]: https://github.com/jaredbeck/minitest_to_rspec/pull/20

data/lib/minitest_to_rspec/converter.rb

@@ -2,14 +2,14 @@
 
 require 'ruby_parser'
 require 'ruby2ruby'
-require_relative 'processor'
+require 'minitest_to_rspec/input/processor'
 require_relative 'errors'
 
 module MinitestToRspec
   # Converts strings of minitest code. Does not read or write files.
   class Converter
     def initialize(rails: false, mocha: false)
-      @processor = Processor.new(rails, mocha)
+      @processor = Input::Processor.new(rails, mocha)
     end
 
     # - `input` - Contents of a ruby file.

data/lib/minitest_to_rspec/input/model/base.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'minitest_to_rspec/sexp_assertions'
+
+module MinitestToRspec
+  module Input
+    module Model
+      # Input models are simple data objects
+      # representing the S-expressions they are named after.
+      class Base
+        include SexpAssertions
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/input/model/call.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'minitest_to_rspec/input/model/base'
+
+module MinitestToRspec
+  module Input
+    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 refute_raise?(exp)
+            exp.sexp_type == :call && new(exp).refute_raise?
+          end
+
+          def refute_raises?(exp)
+            exp.sexp_type == :call && new(exp).refute_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 refute_raise?
+          method_name == :refute_raise && raise_error_args?
+        end
+
+        def refute_raises?
+          method_name == :refute_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], [:colon2]].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
+end

data/lib/minitest_to_rspec/input/model/defn.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'minitest_to_rspec/input/model/base'
+
+module MinitestToRspec
+  module Input
+    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
+
+        def setup?
+          method_name == 'setup'
+        end
+
+        def teardown?
+          method_name == 'teardown'
+        end
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/input/model/hash_exp.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'minitest_to_rspec/input/model/base'
+
+module MinitestToRspec
+  module Input
+    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
+end

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'minitest_to_rspec/input/model/base'
+
+module MinitestToRspec
+  module Input
+    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 refute_raise?
+          !empty? && Model::Call.refute_raise?(@exp[1])
+        end
+
+        def refute_raises?
+          !empty? && Model::Call.refute_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
+end

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

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'minitest_to_rspec/input/model/base'
+
+module MinitestToRspec
+  module Input
+    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
+end