minitest_to_rspec 0.11.0 → 0.12.0

data/lib/minitest_to_rspec/subprocessors/defn.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../model/defn'
-require_relative 'base'
-
-module MinitestToRspec
-  module Subprocessors
-    # Minitest tests can be defined as methods using names beginning with
-    # 'test_'. Process those tests into RSpec `it` example blocks.
-    class Defn < Base
-      def initialize(sexp, rails, mocha)
-        super(rails, mocha)
-        @original = sexp.dup
-        @exp = Model::Defn.new(sexp)
-        sexp.clear
-      end
-
-      # Using a `Model::Defn`, returns a `Sexp`
-      def process
-        if @exp.test_method?
-          s(:iter,
-            s(:call, nil, :it, s(:str, example_title)),
-            0,
-            example_block)
-        else
-          @original
-        end
-      end
-
-      private
-
-      # Remove 'test_' prefix and replace underscores with spaces
-      def example_title
-        @exp.method_name.sub(/^test_/, '').tr('_', ' ')
-      end
-
-      def example_block
-        block = s(:block)
-        @exp.body.each_with_object(block) do |line, blk|
-          blk << process_line(line)
-        end
-      end
-
-      def process_line(line)
-        ::MinitestToRspec::Processor.new(@rails, @mocha).process(line)
-      end
-    end
-  end
-end

data/lib/minitest_to_rspec/subprocessors/iter.rb

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'base'
-require_relative '../model/iter'
-
-module MinitestToRspec
-  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_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

data/lib/minitest_to_rspec/subprocessors/klass.rb

@@ -1,99 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../errors'
-require_relative '../model/klass'
-require_relative 'base'
-
-module MinitestToRspec
-  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