minitest_to_rspec 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c0b2d69b30e206e341a4bd6a5b036ae70469f96e
+  data.tar.gz: f101b5c2b968434081eff2574abda02c01c73eec
+SHA512:
+  metadata.gz: 7574bec7773f8e050aae8326b63d699146feed31abc91abb9eac7d7ce5d609c1a11a6d9705c7bf1ce5600f936abcbe02325ba35b453a083750d2f5d22e15b5c1
+  data.tar.gz: 718febe6a17d6495f56423fc288131ebdc0725723cd5900512204feac01d173e515f0e947cf0bdbe946d42e1ea11ce5975356548df8722e0b52dfc3f7fe5b71f

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/pkg/
+/spec/reports/
+/tmp/

data/.ruby-version

@@ -0,0 +1 @@
+2.2.1

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - "2.0.0-p598"
+  - "2.1.5"
+  - "2.2.1"
+script: bundle exec rake
+notifications:
+  email: false

data/CHANGELOG.md

@@ -0,0 +1,21 @@
+Change Log
+==========
+
+This project follows [semver 2.0.0][1] and the recommendations
+of [keepachangelog.com][2].
+
+Road Map
+--------
+
+- CLI
+- More assertions
+
+Contributions welcome.
+
+0.1.0
+-----
+
+Initial release.  11 assertions are supported.
+
+[1]: http://semver.org/spec/v2.0.0.html
+[2]: http://keepachangelog.com/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,28 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people
+who contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual
+language or imagery, derogatory comments or personal attacks, trolling, public
+or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct. Project maintainers who do not follow the
+Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by opening an issue or contacting one or more of the project
+maintainers.
+
+This Code of Conduct is adapted from the [Contributor
+Covenant](http:contributor-covenant.org), version 1.0.0, available at
+[http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org
+/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in minitest_to_rspec.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jared Beck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,75 @@
+# MinitestToRspec
+
+Converts [minitest][8] files to [rspec][9].
+
+[![Build Status][1]][2] [![Code Climate][3]][4] [![Test Coverage][7]][4]
+
+Example
+-------
+
+Input:
+
+```ruby
+require 'test_helper'
+class BananaTest < ActiveSupport::TestCase
+  test "is delicious" do
+    assert Banana.new.delicious?
+  end
+end
+```
+
+Output:
+
+```ruby
+require("spec_helper")
+RSpec.describe(Banana) do
+  it("is delicious") { expect(Banana.new.delicious?).to(be_truthy) }
+end
+```
+
+The code style is whatever [ruby2ruby][6] feels like printing,
+and is not configurable.  The goal is not style, but to get to
+rspec quickly.
+
+Usage
+-----
+
+No CLI executable is provided yet, but ruby usage is simple.
+
+```ruby
+require 'minitest_to_rspec'
+MinitestToRspec::Converter.new.convert("assert('banana')")
+#=> "expect(\"banana\").to(be_truthy)"
+```
+
+Supported Assertions
+--------------------
+
+Selected assertions from minitest, Test::Unit, and ActiveSupport.
+See [doc/supported_assertions.md][5] for rationale.  Contributions
+are welcome.
+
+Assertion                   | Arity
+--------------------------- | -----
+assert                      |
+assert_difference           | 1
+assert_difference           | 2
+assert_equal                |
+assert_match                |
+assert_nil                  |
+assert_no_difference        |
+[assert_nothing_raised][10] |
+assert_raises               |
+refute                      |
+refute_equal                |
+
+[1]: https://travis-ci.org/jaredbeck/minitest_to_rspec.svg
+[2]: https://travis-ci.org/jaredbeck/minitest_to_rspec
+[3]: https://codeclimate.com/github/jaredbeck/minitest_to_rspec/badges/gpa.svg
+[4]: https://codeclimate.com/github/jaredbeck/minitest_to_rspec
+[5]: https://github.com/jaredbeck/minitest_to_rspec/blob/master/doc/supported_assertions.md
+[6]: https://github.com/seattlerb/ruby2ruby
+[7]: https://codeclimate.com/github/jaredbeck/minitest_to_rspec/badges/coverage.svg
+[8]: https://github.com/jaredbeck/minitest_to_rspec/blob/master/doc/minitest.md
+[9]: https://github.com/jaredbeck/minitest_to_rspec/blob/master/doc/rspec.md
+[10]: http://www.rubydoc.info/gems/test-unit/3.0.9/Test/Unit/Assertions#assert_nothing_raised-instance_method

data/Rakefile

@@ -0,0 +1,19 @@
+require 'cane/rake_task'
+require 'rspec/core/rake_task'
+
+desc 'Check quality metrics'
+Cane::RakeTask.new(:quality) do |cane|
+  cane.max_violations = 0
+  cane.abc_glob = 'lib/**/*.rb'
+  cane.abc_max = 10
+  cane.no_doc = true
+  cane.style_glob = 'lib/**/*.rb'
+  cane.style_measure = 80
+end
+
+task(:spec).clear
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = false
+end
+
+task :default => [:quality, :spec]

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "minitest_to_rspec"
+
+# You can also use a different console, if you like.
+# require "irb"
+# IRB.start
+
+require "pry"
+Pry.start

data/doc/minitest.md

@@ -0,0 +1,29 @@
+Minitest
+========
+
+Gem  | https://rubygems.org/gems/minitest 
+Docs | http://www.rubydoc.info/gems/minitest/5.5.1
+
+ActiveSupport
+-------------
+
+Rails adds some assertions to minitest. 
+
+- http://guides.rubyonrails.org/testing.html
+- [active_support/testing/assertions.rb][3] 
+
+Test::Unit
+----------
+
+- https://github.com/test-unit/test-unit
+- http://www.rubydoc.info/gems/test-unit/3.0.9/Test/Unit/Assertions
+
+Selected History
+----------------
+
+[Minitest was removed from ruby stdlib][1] in ruby 2.2, but it is 
+still [packaged with ruby][2] somehow.
+
+[1]: https://bugs.ruby-lang.org/issues/9711
+[2]: https://bugs.ruby-lang.org/issues/9852
+[3]: https://github.com/rails/rails/blob/master/activesupport/lib/active_support/testing/assertions.rb

data/doc/rspec.md

@@ -0,0 +1,5 @@
+RSpec
+=====
+
+Gem  | https://rubygems.org/gems/rspec
+Docs | https://relishapp.com/rspec

data/doc/supported_assertions.md

@@ -0,0 +1,60 @@
+Supported Assertions
+====================
+
+A quick survey of one mid-sized test suite (14 kilolines) found
+the following assertions in use.
+
+```bash
+find test -type f -name '*.rb' | xargs cat > all_tests;
+for a in $( cat ~/Desktop/assertions ); do
+  echo -n $a
+  ggrep -E "\\b$a\\b" all_tests | wc -l
+done |
+awk '{print $2 " " $1}' |
+sort -nr
+```
+
+```
+625 assert
+530 assert_equal
+84 assert_difference
+38 assert_no_difference
+10 refute
+10 assert_nil
+5 assert_nothing_raised
+4 assert_match
+2 assert_raises
+1 refute_equal
+0 refute_same
+0 refute_respond_to
+0 refute_predicate
+0 refute_operator
+0 refute_nil
+0 refute_match
+0 refute_kind_of
+0 refute_instance_of
+0 refute_includes
+0 refute_in_epsilon
+0 refute_in_delta
+0 refute_empty
+0 assert_throws
+0 assert_silent
+0 assert_send
+0 assert_same
+0 assert_respond_to
+0 assert_present
+0 assert_predicate
+0 assert_output
+0 assert_operator
+0 assert_not
+0 assert_kind_of
+0 assert_instance_of
+0 assert_includes
+0 assert_in_epsilon
+0 assert_in_delta
+0 assert_empty
+0 assert_blank
+```
+
+Assertions which are not used in the targeted test suite
+are not yet supported, but contributions are welcome.

data/lib/minitest_to_rspec.rb

@@ -0,0 +1,5 @@
+require "minitest_to_rspec/version"
+require "minitest_to_rspec/converter"
+
+module MinitestToRspec
+end

data/lib/minitest_to_rspec/converter.rb

@@ -0,0 +1,57 @@
+require "ruby_parser"
+require "ruby2ruby"
+require_relative "processor"
+
+module MinitestToRspec
+  class Converter
+    def initialize
+      @processor = Processor.new
+      @ruby2ruby = Ruby2Ruby.new
+    end
+
+    def convert(input)
+      render process parse input
+    end
+
+    private
+
+    # Parses an input string using the `ruby_parser` gem, and
+    # returns an Abstract Syntax Tree (AST) in the form of
+    # S-expressions.
+    #
+    # Example of AST
+    # --------------
+    #
+    # s(:block,
+    #   s(:call, nil, :require, s(:str, "test_helper")),
+    #   s(:class,
+    #     :BananaTest,
+    #     s(:colon2, s(:const, :ActiveSupport), :TestCase),
+    #     s(:iter,
+    #       s(:call, nil, :test, s(:str, "is delicious")),
+    #       s(:args),
+    #       s(:call, nil, :assert,
+    #         s(:call, s(:call, s(:const, :Banana), :new), :delicious?)
+    #       )
+    #     )
+    #   )
+    # )
+    #
+    def parse(input)
+      RubyParser.new.parse(input)
+    end
+
+    # Processes an AST (S-expressions) representing a minitest
+    # file, and returns an AST (still S-expressions) representing
+    # an rspec file.
+    def process(exp)
+      @processor.process(exp)
+    end
+
+    # Given an AST representing an rspec file, returns a string
+    # of ruby code.
+    def render(exp)
+      @ruby2ruby.process(exp)
+    end
+  end
+end

data/lib/minitest_to_rspec/errors.rb

@@ -0,0 +1,3 @@
+module MinitestToRspec
+  class NotImplemented < StandardError; end
+end

data/lib/minitest_to_rspec/exp/call.rb

@@ -0,0 +1,84 @@
+module MinitestToRspec
+  module Exp
+
+    # Data object.  Represents a `:call` s-expression.
+    class Call
+      attr_reader :original
+
+      def initialize(exp)
+        unless exp.sexp_type == :call
+          raise ArgumentError, "Expected call, got #{exp.sexp_type}"
+        end
+        @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_raises?(exp)
+          exp.sexp_type == :call && new(exp).assert_raises?
+        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], [: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_raises?
+        method_name == :assert_raises &&
+          arguments.length == 1 &&
+          arguments[0].sexp_type == :const
+      end
+
+      def method_name
+        @exp[2]
+      end
+
+      def one_string_argument?
+        arguments.length == 1 && string?(arguments[0])
+      end
+
+      def require_test_helper?
+        method_name == :require &&
+          one_string_argument? &&
+          arguments[0][1] == "test_helper"
+      end
+
+      private
+
+      def string?(exp)
+        exp.sexp_type == :str
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/exp/iter.rb

@@ -0,0 +1,43 @@
+module MinitestToRspec
+  module Exp
+
+    # Data object.  Represents an `:iter` s-expression.
+    class Iter
+
+      def initialize(exp)
+        unless exp.sexp_type == :iter
+          raise ArgumentError, "Expected iter, got #{exp.sexp_type}"
+        end
+        @exp = exp.dup
+      end
+
+      def [](*args)
+        @exp[*args]
+      end
+
+      def assert_difference?
+        !empty? && Exp::Call.assert_difference?(@exp[1])
+      end
+
+      def assert_no_difference?
+        !empty? && Exp::Call.assert_no_difference?(@exp[1])
+      end
+
+      def assert_nothing_raised?
+        !empty? && Exp::Call.assert_nothing_raised?(@exp[1])
+      end
+
+      def assert_raises?
+        !empty? && Exp::Call.assert_raises?(@exp[1])
+      end
+
+      def empty?
+        @exp.length == 1 # just the sexp_type
+      end
+
+      def sexp
+        @exp
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/processor.rb

@@ -0,0 +1,26 @@
+require "ruby_parser"
+require "sexp_processor"
+require_relative "subprocessors/call"
+require_relative "subprocessors/class"
+require_relative "subprocessors/iter"
+
+module MinitestToRspec
+  class Processor < SexpProcessor
+    def initialize
+      super
+      self.strict = false
+    end
+
+    def process_call(exp)
+      Subprocessors::Call.process(exp)
+    end
+
+    def process_class(exp)
+      Subprocessors::Class.process(exp)
+    end
+
+    def process_iter(exp)
+      Subprocessors::Iter.process(exp)
+    end
+  end
+end

data/lib/minitest_to_rspec/subprocessors/base.rb

@@ -0,0 +1,58 @@
+module MinitestToRspec
+  module Subprocessors
+    class Base
+      class << self
+
+        # 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)
+          s(:call, expectation_target(target, eager), phase, matcher)
+        end
+
+        def expect_to(matcher, target, eager)
+          expect(target, eager, :to, matcher)
+        end
+
+        def expect_to_not(matcher, target, eager)
+          expect(target, eager, :to_not, matcher)
+        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 = true)
+          m = "expectation_target_%s" % [eager ? "eager" : "lazy"]
+          send(m, exp)
+        end
+
+        def expectation_target_eager(exp)
+          s(:call, nil, :expect, exp)
+        end
+
+        def expectation_target_lazy(block)
+          s(:iter,
+            s(:call, nil, :expect),
+            s(:args),
+            full_process(block)
+          )
+        end
+
+        # Run `exp` through a new `Processor`.  This is useful for expressions
+        # that cannot be fully understood by a single subprocessor.  For
+        # example, we process :iter expressions, because we're interested in
+        # :iter that contain e.g. an `assert_difference`.  However, if the :iter
+        # turns out to be uninteresting, we still want to fully process its
+        # sub-expressions. TODO: `full_process` may not be the best name.
+        def full_process(exp)
+          Processor.new.process(exp)
+        end
+
+        def matcher(name, *args)
+          exp = s(:call, nil, name)
+          exp.concat(args)
+        end
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/subprocessors/call.rb

@@ -0,0 +1,109 @@
+require_relative "../exp/call"
+require_relative "base"
+
+module MinitestToRspec
+  module Subprocessors
+    class Call < Base
+
+      ASSERTIONS = %i[
+        assert
+        assert_equal
+        assert_match
+        assert_nil
+        refute
+        refute_equal
+      ]
+
+      class << self
+        def process(sexp)
+          exp = Exp::Call.new(sexp)
+          sexp.clear
+          process_exp(exp)
+        end
+
+        private
+
+        def assertion?(exp)
+          ASSERTIONS.include?(exp.method_name)
+        end
+
+        def be_falsey
+          matcher(:be_falsey)
+        end
+
+        def be_nil
+          matcher(:be_nil)
+        end
+
+        def be_truthy
+          matcher(:be_truthy)
+        end
+
+        def eq(exp)
+          matcher(:eq, exp)
+        end
+
+        def match(pattern)
+          matcher(:match, pattern)
+        end
+
+        def method_assert(exp)
+          expect_to(be_truthy, exp.arguments[0], true)
+        end
+
+        def method_assert_equal(exp)
+          expected = exp.arguments[0]
+          calculated = exp.arguments[1]
+          expect_to(eq(expected), calculated, true)
+        end
+
+        def method_assert_match(exp)
+          pattern = exp.arguments[0]
+          string = exp.arguments[1]
+          expect_to(match(pattern), string, true)
+        end
+
+        def method_assert_nil(exp)
+          expect_to(be_nil, exp.arguments[0], true)
+        end
+
+        def method_refute(exp)
+          expect_to(be_falsey, exp.arguments[0], true)
+        end
+
+        def method_refute_equal(exp)
+          unexpected = exp.arguments[0]
+          calculated = exp.arguments[1]
+          expect_to_not(eq(unexpected), calculated, true)
+        end
+
+        def method_test(exp)
+          s(:call, nil, :it, *exp.arguments)
+        end
+
+        def processable?(exp)
+          exp.method_name == :test || assertion?(exp)
+        end
+
+        # Given a `Exp::Call`, returns a `Sexp`
+        def process_exp(exp)
+          if exp.require_test_helper?
+            require_spec_helper
+          elsif processable?(exp)
+            process_method(exp)
+          else
+            exp.original
+          end
+        end
+
+        def process_method(exp)
+          send("method_#{exp.method_name}".to_sym, exp)
+        end
+
+        def require_spec_helper
+          s(:call, nil, :require, s(:str, "spec_helper"))
+        end
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/subprocessors/class.rb

@@ -0,0 +1,105 @@
+require_relative "../errors"
+require_relative "base"
+
+module MinitestToRspec
+  module Subprocessors
+    class Class < Base
+      class << self
+
+        # Examples of S-expressions
+        # -------------------------
+        #
+        # An empty class
+        #
+        #     class Derp; end
+        #     s(:class, :Derp, nil)
+        #
+        # A trivial class
+        #
+        #     class Derp; puts; end
+        #     s(:class, :Derp, nil, s(:call, nil, :puts))
+        #
+        # A TestCase
+        #
+        #     s(:class,
+        #       :BananaTest,
+        #       s(:colon2, s(:const, :ActiveSupport), :TestCase),
+        #       s(:iter,
+        #         s(:call, nil, :test, s(:str, "is delicious")),
+        #         s(:args),
+        #         s(:call, nil, :assert,
+        #           s(:call, s(:call, s(:const, :Banana), :new), :delicious?)
+        #         )
+        #       )
+        #     )
+        #
+        def process(exp)
+          raise ArgumentError unless exp.shift == :class
+          name = exp.shift
+          parent = exp.shift
+          iter = exp.empty? ? nil : exp.shift
+          raise("Unexpected class expression") unless exp.empty?
+          result(name, parent, iter)
+        end
+
+        private
+
+        def active_support_test_case?(parent)
+          parent.length == 3 &&
+            parent[1] == s(:const, :ActiveSupport) &&
+            parent[2] == :TestCase
+        end
+
+        # Given a `test_class_name` like `BananaTest`, returns the
+        # described clas, like `Banana`.
+        def described_class(test_class_name)
+          test_class_name.to_s.gsub(/Test\Z/, "").to_sym
+        end
+
+        def inheritance?(exp)
+          exp.sexp_type == :colon2
+        end
+
+        # Run `exp` through a new `Processor`.  This is appropriate
+        # for expressions like `:iter` (a block) which we're not
+        # interested in processing.  We *are* interested in
+        # processing expressions within an `:iter`, but not the
+        # iter itself.  TODO: `full_process` may not be the best name.
+        def full_process(exp)
+          Processor.new.process(exp)
+        end
+
+        def result(name, parent, iter)
+          if parent && test_case?(parent)
+            rspec_describe_block(name, iter)
+          elsif iter.nil?
+            s(:class, name, parent)
+          else
+            s(:class, name, parent, full_process(iter))
+          end
+        end
+
+        def rspec_describe(arg)
+          s(:call, s(:const, :RSpec), :describe, arg)
+        end
+
+        # Returns a S-expression representing a call to RSpec.describe
+        def rspec_describe_block(name, iter)
+          arg = s(:const, described_class(name))
+          result = s(:iter, rspec_describe(arg), s(:args))
+          unless iter.nil?
+            result << full_process(iter)
+          end
+          result
+        end
+
+        # TODO: Obviously, there are test case parent classes
+        # other than ActiveSupport::TestCase
+        def test_case?(parent)
+          raise ArgumentError unless inheritance?(parent)
+          active_support_test_case?(parent)
+        end
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/subprocessors/iter.rb

@@ -0,0 +1,107 @@
+require_relative "base"
+require_relative "../exp/iter"
+
+module MinitestToRspec
+  module Subprocessors
+    class Iter < Base
+      class << self
+        def process(sexp)
+          exp = Exp::Iter.new(sexp)
+          sexp.clear
+          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),
+            s(:args),
+            block
+          )
+        end
+
+        def parse(str)
+          RubyParser.new.parse(str)
+        end
+
+        def process_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 process_assert_no_difference(exp)
+          call = exp[1]
+          block = exp[3]
+          what = parse(call[3][1])
+          expect_to_not(change(what), block, false)
+        end
+
+        def process_assert_nothing_raised(exp)
+          block = exp[3]
+          expect_to_not(raise_error, block, false)
+        end
+
+        def process_assert_raises(exp)
+          block = exp[3]
+          call = Exp::Call.new(exp[1])
+          err = call.arguments.first
+          expect_to(raise_error(err), block, false)
+        end
+
+        # Given a `Exp::Iter`, returns a `Sexp`
+        def process_exp(exp)
+          m = processing_method(exp)
+          if m.nil?
+            process_uninteresting_iter(exp.sexp)
+          else
+            send(m, exp)
+          end
+        end
+
+        def process_uninteresting_iter(exp)
+          iter = s(exp.shift)
+          until exp.empty?
+            iter << full_process(exp.shift)
+          end
+          iter
+        end
+
+        # Returns the name of a method in this subprocessor, or nil if
+        # this iter is not processable.
+        def processing_method(iter)
+          if !iter.empty? && iter[1].sexp_type == :call
+            method_name = iter[1][2]
+            decision = "#{method_name}?".to_sym
+            if iter.respond_to?(decision) && iter.public_send(decision)
+              "process_#{method_name}".to_sym
+            end
+          end
+        end
+
+        def raise_error(*args)
+          matcher(:raise_error, *args)
+        end
+      end
+    end
+  end
+end

data/lib/minitest_to_rspec/version.rb

@@ -0,0 +1,3 @@
+module MinitestToRspec
+  VERSION = "0.1.0"
+end

data/minitest_to_rspec.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'minitest_to_rspec/version'
+
+Gem::Specification.new do |spec|
+  spec.name = "minitest_to_rspec"
+  spec.version = MinitestToRspec::VERSION
+  spec.authors = ["Jared Beck"]
+  spec.email = ["jared@jaredbeck.com"]
+
+  spec.summary = "Converts minitest files to rspec"
+  spec.homepage = "https://github.com/jaredbeck/minitest_to_rspec"
+  spec.license = "MIT"
+
+  spec.files = `git ls-files -z`.split("\x0").reject { |f|
+    f.match(%r{^(test|spec|features)/})
+  }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "ruby_parser"
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "cane"
+  spec.add_development_dependency "codeclimate-test-reporter"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "ruby2ruby"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-nav"
+end

metadata

@@ -0,0 +1,195 @@
+--- !ruby/object:Gem::Specification
+name: minitest_to_rspec
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jared Beck
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ruby_parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby2ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- jared@jaredbeck.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- doc/minitest.md
+- doc/rspec.md
+- doc/supported_assertions.md
+- lib/minitest_to_rspec.rb
+- lib/minitest_to_rspec/converter.rb
+- lib/minitest_to_rspec/errors.rb
+- lib/minitest_to_rspec/exp/call.rb
+- lib/minitest_to_rspec/exp/iter.rb
+- lib/minitest_to_rspec/processor.rb
+- lib/minitest_to_rspec/subprocessors/base.rb
+- lib/minitest_to_rspec/subprocessors/call.rb
+- lib/minitest_to_rspec/subprocessors/class.rb
+- lib/minitest_to_rspec/subprocessors/iter.rb
+- lib/minitest_to_rspec/version.rb
+- minitest_to_rspec.gemspec
+homepage: https://github.com/jaredbeck/minitest_to_rspec
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Converts minitest files to rspec
+test_files: []