minitest-markdown 0.2.1.pre → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 959c342f3e4ec34238e2385e3578faf1d5133beb2f74d9b52d4ffc9ab0dc8d58
-  data.tar.gz: 8b4bae7c2888040d6b2124fa2bd5d103c67405c883bf3de606f220e317912249
+  metadata.gz: fabeb5456de7296b1986c66822818a5fec9834e2c23e19b33a4c3c198e262ae6
+  data.tar.gz: bebbc7f77cd2443e91e58224888e5b69ab2d072b69e49c4cab86557cb0c3eeec
 SHA512:
-  metadata.gz: e3d59e3fc4f77092cdd8dda4f3a0b8a8d79e1b73cbfc37186947efd6dbb0e35f508ab0d32da4f6a88d4c816d72370ff92b563e819c44073da4ea44404b946acb
-  data.tar.gz: 2522d752e44a422f82be9ccb1a44c9ddec8346381d2cb0465990a7eee5b383e0a6b664c7f7b52c9ba860602c2a78411dc9f225c4a580bc287f65c26fbace05ad
+  metadata.gz: 5b369fab40830b0a31951df1ddb8dc25868471f2766f81fd2c438bba7219921e45ef47e48d9c73b2224655d39a1005efd23e8c0a268481c3f9b0a3d628019ee2
+  data.tar.gz: 2789d00a505fa70ea7ce6c29352807c066951c4498862f4b1afe6190e568e3b7da31ce63b3a5baf74e51cd24759c183a432121cb1209d883faf672ec08a1dd13

data/CHANGELOG.md

@@ -1,5 +1,25 @@
 ## [Unreleased]
 
+## [0.2.3] - 2025-05-22
+
+- New release to catch up with 'pre' versioning 
+
+## [0.0.1] - 2025-05-22
+
+- Fix bug with Minitest::Hooks method definitions
+
+## [0.0.0] - 2025-05-10
+
+- Fix bug in TestCodeBlock error message
+- Add binding to Kernel.eval fixes #1
+- pass kwargs to stub methods in StubProc
+
+## [0.2.2.pre] - 2025-05-08
+
+- Improve magic comment & hook comment parsing
+- Fix bug with empty sting after magic comment
+- Fix bug in config if Bundler undefined
+
 ## [0.2.1.pre] - 2025-05-07
 
 - Fix issue with require in eval

data/README.md

@@ -5,10 +5,11 @@
 
 ## \_why?
 
-Document your Gem's usage, examples etc. with fully testable code! Better still, use your README as a BDD aid and specify functionaility in your README/wiki code blocks *before* you write your code!!
+Document your Gem's usage, examples etc. with fully testable code! Better still, use your README as a BDD aid and specify functionality in your README/wiki code blocks *before* you write your code!!
 
 ## Installation
 
+
 Add the gem to the application's Gemfile:
 
 ```bash
@@ -21,6 +22,17 @@ If bundler is not being used to manage dependencies, install the gem by executin
 gem install minitest-markdown
 ```
 
+## Configuration
+
+No configuration is required if you use Bundler. If not, set your `project_root` path using the setter method:
+```ruby
+@config = Minitest::Markdown.config
+# => instance_of Configuration
+
+Configuration.instance_methods(false)
+# => includes :project_root=
+```
+
 ## Usage
 
 ### In your test class
@@ -29,17 +41,24 @@ To test the Ruby blocks in your README file, create file `test_readme.rb` (for e
 ```ruby
 require 'minitest/autorun' # or in your test_helper
 require 'minitest/markdown' # ditto
+require 'minitest/hooks/test' # optional, see 'State' section below 
 
 class ReadmeTest < Minitest::Test # or your own subclass of Minitest::Test
+  include Minitest::Hooks # optional, see 'State' section below 
+
   Markdown.generate_markdown_tests(self)
 end
-# => nil
+# => truthy
 ```
 To test Ruby blocks in another Markdown file, create another test file and pass the path to your Markdown file using the `:path` keyword arg i.e. `Markdown.generate_markdown_tests(self, path: '/path/to/your/markdown/file.md')`
 
 ### In your Markdown - magic comments become assertions
 
-Each Markdown file is represented by a single test class and each Ruby block in a file becomes a test method with zero or more assertions. The syntax used is `# => ` followed by an assertion keyword. Keywords may be one of the [Minitest "assert_" assertions](https://docs.seattlerb.org/minitest/Minitest/Assertions.html) less the "assert_" prefix (refutations are not implemented at this time). If the keyword is omitted, the default assertion; `assert_equal` is used. The actual value passed to the assertion is the result of the evaluation of the Ruby code above each magic comment. The following block (a single test) includes 3 assertions:
+Each Markdown file is represented by a single test class and each Ruby block* in a file becomes a test method with zero or more assertions. Test methods are named according to their index; `test_block0`, `test_block1` etc.
+
+\*Any 'state' blocks are excluded from indexing - see State section below
+
+The syntax used for assertions is `# => ` followed by an assertion keyword. Keywords may be any one of the [Minitest "assert_" assertions](https://docs.seattlerb.org/minitest/Minitest/Assertions.html) less the "assert_" prefix (refutations are not implemented at this time). If the keyword is omitted, the default assertion; `assert_equal` is used. The actual value passed to the assertion is the result of the evaluation of the Ruby code above each magic comment. The following block (a single test) includes 6 assertions:
 ```ruby
 File.read 'test/fixtures/klass.rb'
 # => "class Klass\n  def hello\n    'Hello Markdown!'\n  end\nend"
@@ -53,12 +72,15 @@ Klass.new # inline comments are also ignored
 # The assertion and expected value are:-
 # => instance_of Klass
 
-# No keywword here, so the default assertion is used (assert_equal)
+# No keyword here, so the default assertion is used (assert_equal)
 Klass.new.hello
 # => 'Hello Markdown!'
 
 Klass.hello
 # => raises NoMethodError
+
+self
+# => instance_of Markdown::TestClass
 ```
 Plain old `assert` has been aliased as `assert_truthy`, so when expecting a truthy value you should do this:
 ```ruby
@@ -72,7 +94,7 @@ For convenience, the assertion `assert_includes` has also been aliased so that i
 2
 # => included_in [1, 2, 3]
 ```
-Everything on the magic comment line after the keyword, or `# => `, if one is omitted, is evaluated as Ruby code. Note: **inline comments are NOT ALLOWED on magic comment lines**. Where an assertion takes multiple positional args, these are simply separated by commas. Note that the assertion keyword itself is **not an argument**. The syntax is as follows:
+Everything on the magic comment line after the assertion keyword, or `# => ` if one is omitted, is evaluated as Ruby code. Note: **inline comments are NOT ALLOWED on magic comment lines**. Where an assertion takes multiple positional args, these are simply separated by commas. Note that the assertion keyword itself is **not an argument**. The syntax is as follows:
 ```ruby
 22/7.0
 # => in_delta Math::PI, 0.01
@@ -82,65 +104,102 @@ To skip a test, use `skip`, as you would in a regular test:
 "some code which you don't want to test yet"
 # => skip 'give a reason for the skip here'
 ```
+Test failures will look like this - note the method name `test_block10` in this example:
+```
+Minitest::Markdown::ReadmeTest#test_block10 [lib/minitest/markdown/test_class.rb:118]:
+Expected: 42
+  Actual: 0
+```
 
 ### State
 
-Minitest's `setup` and `teardown` methods are generated by using the appropriate comment on the first line of a code block. Magic comments are ignored in such blocks, as these are not tests. E.g.
+Instance vars are shared across test methods within a class, but as Minitest's default is to run tests in random order you may want to use a setup block in order to ensure a stored value is available to all test blocks (tests) in the Markdown file test class (see below):
+```ruby
+@instance_var
+# => 7
+
+@before_all_instance_var # see hook methods below
+# => 'foo'
+```
+Minitest's `setup` and `teardown` methods are generated by using the appropriate comment on the first line of a code block. Assertion magic comments are ignored in such blocks, as these are not tests. E.g.
+
 ```ruby
 # setup
 
-@instance_var = 42
+# do some setup task - or:-
+@instance_var = 7 # now available in all test method blocks, including the one above
+# => IGNORED
 ```
-The instance var set is now available to all test blocks (tests) in the Markdown file.
 ```ruby
-@instance_var
-# => 42
+# teardown
+
+# do some teardown task
 ```
-The hook methods defined in the [minitest-hooks](https://github.com/jeremyevans/minitest-hooks?tab=readme-ov-file#in-tests-minitesttest-) extension (`before_all`, `after_all`, `around` & `around_all`)are also available in this way if `minitest-hooks` is installed and `Minitest::Hooks` is included in your test class.
+The hook methods defined in the [minitest-hooks](https://github.com/jeremyevans/minitest-hooks?tab=readme-ov-file#in-tests-minitesttest-) extension (`before_all`, `after_all`, `around` & `around_all`)are also available in this way if `minitest-hooks` is installed and `Minitest::Hooks` is included in your markdown test class. See the 'In your test class' section above for an example. You can now do this:
 
+```ruby
+# before_all
+@before_all_instance_var = 'foo'
+```
 
-Everything in the code blocks above runs as test code. [minitest-proveit](https://github.com/seattlerb/minitest-proveit) would complain otherwise ;-)
+Everything in the Ruby code blocks above and below here runs as test code. [minitest-proveit](https://github.com/seattlerb/minitest-proveit) would complain otherwise ;-)
+
+### Mocks
+
+Mocks use the "mock" keyword for [assert_mock](https://docs.seattlerb.org/minitest/Minitest/Assertions.html#method-i-assert_mock) in place of the equivalent `mock.verify`:
+```ruby
+@mymock = Minitest::Mock.new
+@mymock.expect(:puts, nil, ['Hello World!'])
+
+@mymock.puts 'Hello World!'
+# => mock @mymock
+```
 
-## Stubbing
+### Stubbing
 
-It is possible to pass stubs to the generated tests. This is done using the stubs keyword. Hash keys represent the index of the test code block and the key is an instance of `StubChain`. `StubChain.stubproc` returns a procified stub which is called around the relevant test code. Zero or more of these reusable procs can be used to instantiate a StubChain object:
+It is possible to pass stubs to the generated tests. This is done using the stubs keyword. Hash keys represent the index of the test code block. **Important: any 'state' blocks are ignored for test code block indexing**. The hash value must be an instance of `Minitest::StubChain` which holds a proc for each stub in the chain. For convenience `StubChain.stubproc` returns a suitable stub proc object which is called around the relevant test code. Zero or more of these reusable procs can be used to instantiate a StubChain object:
 ```ruby
 class MarkdownTest < Minitest::Test
   set_stubs_new = Minitest::StubChain.stubproc(Set, :new, []) # returns a proc which stubs Set.new to return an empty array
   array_stubs_size = Minitest::StubChain.stubproc(Array, :size, 42, any_instance: true) # uses the bundled minitest-stub_any_instance gem
 
+  stub_chain = Minitest::StubChain.new([set_stubs_new]) # initialized with zero or more stub procs
+  stub_chain.stubs << array_stubs_size # add another like this if need be
+
   stubs = {}
-  @stub_chain = Minitest::StubChain.new([set_stubs_new, array_stubs_size]) # initialized with zero or more stub procs
-  stubs[8] = @stub_chain
-  stubs[9] = @stub_chain # StubChain instances themseves may be reused
+  stubs[10] = stub_chain
+  stubs[11] = stub_chain # StubChain instances themselves may be reused
 
   Markdown.generate_markdown_tests(self, stubs: stubs)
 end
-# => nil
+# => truthy
 ```
-The 2 stubs above are demonstated in the following examples:
+The 2 stubs in the `StubChain` instance above are demonstrated in the following example:
 ```ruby
-# This is test_block8
-Set.new([1, 'c', :s]).size # Here Set.new was stubbed to return an Array and Array#size was stubbed to return 42
+# This is test_block10
+Set.new([1, 'c', :s]).size
 # => 42
+
+# Because we added `stubs[10] = stub_chain` above, this is exactly equivalent to:
+#
+# def test_block10
+#   Set.stub(:new, []) do
+#     Array.stub_any_instance(:size, 42) do
+#       assert_equal 42, Set.new([1, 'c', :s]).size
+#     end
+#   end
+# end
 ```
 Example showing the reuse of a StubChain:
 ```ruby
-# This is test_block9
-Set.new([]).size
+# This is test_block11
+Set.new.size
 # => 42
 ```
 
-## Configuration
-
-No configuation is required if you use Bundler. If not, set your `project_root` path using the setter method:
-```ruby
-@config = Markdown.config
-# => instance_of Configuration
+### Errors
 
-Configuration.instance_methods(false)
-# => includes :project_root=
-```
+All errors subclass `Markdown::Error`
 
 ## Development
 
@@ -150,7 +209,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://gitlab.com/matzfan/minitest-markdown. Please checkout a suitably named branch before submitting a PR.
+Bug reports and pull requests are welcome on GitLab at https://gitlab.com/matzfan/minitest-markdown. Please checkout a suitably named branch before submitting a PR.
 
 ## License
 

data/lib/minitest/markdown/configuration.rb

@@ -2,29 +2,32 @@
 
 require 'pathname'
 
-require_relative 'error'
+require_relative 'errors'
 
 module Minitest
   module Markdown
     # configuration for gem
     class Configuration
-      attr_accessor :project_root, :prove_it
+      PROJECT_ROOT_UNDETERMINED = "Project root can't be determined, set with 'Markdown.config.project_root = /path'"
+
+      attr_writer :project_root
+      attr_accessor :prove_it
 
       def initialize
-        @project_root = determine_project_root
+        @project_root = self.class.determine_project_root
         @prove_it = true
       end
 
-      def readme_path
-        project_root.join 'README.md'
+      def self.determine_project_root
+        Bundler.root if defined? Bundler
       end
 
-      private
-
-      def determine_project_root
-        return Bundler.root if defined? Bundler
+      def project_root
+        @project_root || (raise Error, PROJECT_ROOT_UNDETERMINED)
+      end
 
-        raise Error::MarkdownError, "Project root can't be determined, set with 'Config.project_root = /root/path'"
+      def readme_path
+        project_root.join 'README.md'
       end
     end
   end

data/lib/minitest/markdown/{error.rb → errors.rb}

@@ -2,8 +2,6 @@
 
 module Minitest
   module Markdown
-    module Error
-      class MarkdownError < StandardError; end
-    end
+    class Error < StandardError; end
   end
 end

data/lib/minitest/markdown/{test_code_block.rb → ruby_code_block.rb}

@@ -1,39 +1,47 @@
 # frozen_string_literal: true
 
-require 'minifyrb' # DEP
+require 'minifyrb'
 
 require_relative '../assertions_extensions' # for assert_truthy
-require_relative '../markdown/error'
+require_relative '../markdown/errors'
 
 module Minitest
   module Markdown
-    # A Ruby code block reprenting test code, with 0 or more assertions
-    class TestCodeBlock
-      ASSERT_ = 'assert_'
-      ASSERT_REGEXP = /\A#{ASSERT_}/
-      SKIP = { skip: :skip }.freeze
+    # A Ruby code block representing test code, with 0 or more assertions or a 'state' block
+    class RubyCodeBlock
+      ASSERT_           = 'assert_'
+      ASSERT_REGEXP     = /\A#{ASSERT_}/
+      SKIP              = { skip: :skip }.freeze
       DEFAULT_ASSERTION = :assert_equal
 
-      ASSERTION_KEYS = %i[ruby assertion test_args].freeze
+      ASSERTION_KEYS    = %i[ruby assertion test_args].freeze
+      STATE_BLOCK_TYPES = %i[setup teardown before_all after_all around around_all].freeze
 
-      MAGIC_COMMENT_DELIMITER = '# => '
-      MAGIC_COMMENT_REGEXP = /^#{MAGIC_COMMENT_DELIMITER}.*$/
-      MAGIC_COMMENT_SCAN_REGEXP = /^#{MAGIC_COMMENT_DELIMITER}(.*)$/ # strips delimiter prefix
+      MAGIC_COMMENT_REGEXP      = /^\s*#\s*=>.*$/
+      MAGIC_COMMENT_SCAN_REGEXP = /^\s*#\s*=>\s*(.*)$/ # strips delimiter prefix
+
+      MISSING_ASSERTION_OR_VALUE = "Magic comment missing assertion or value. Something must follow '# =>'"
 
       attr_reader :fenced_block_str
 
       def self.asserts
-        Assertions.instance_methods.grep(ASSERT_REGEXP) - [:assert_send] # deprecated
+        @asserts ||= Assertions.instance_methods.grep(ASSERT_REGEXP) - [:assert_send] # deprecated
       end
 
       def self.assertions_map
-        asserts.inject({}) { |memo, m| memo.merge(m.to_s.split(ASSERT_)[1..].join.to_sym => m) }.merge(SKIP)
+        @assertions_map ||= asserts.inject(SKIP) { |memo, m| memo.merge(m.to_s.split(ASSERT_)[1..].join.to_sym => m) }
       end
 
       def initialize(fenced_block_str)
         @fenced_block_str = fenced_block_str
       end
 
+      def type
+        STATE_BLOCK_TYPES.each { |type| return type if fenced_block_str.lines.first&.match?(/^\s*#\s*#{type}\s*\n$/) }
+
+        :test
+      end
+
       def assertions
         assertions_arr.map { |arr| Hash[*ASSERTION_KEYS.zip(arr).flatten] }
       end
@@ -45,6 +53,8 @@ module Minitest
       end
 
       def parse(magic_comment_string)
+        raise ArgumentError, MISSING_ASSERTION_OR_VALUE if magic_comment_string.strip.empty?
+
         assertion = parse_assertion(magic_comment_string)
         return [DEFAULT_ASSERTION, "[#{magic_comment_string}]"] if assertion.nil?
         return [assertion, '[]'] if magic_comment_string.split.size == 1
@@ -53,7 +63,7 @@ module Minitest
       end
 
       def parse_assertion(str)
-        self.class.assertions_map[str.split.first.to_sym]
+        self.class.assertions_map[str.split.first.to_sym] # 'nil' => :assert_nil, but 'nil?' => nil
       end
 
       def magic_comments
@@ -64,7 +74,7 @@ module Minitest
         @fenced_block_str.split(MAGIC_COMMENT_REGEXP).map do |str|
           Minifyrb::Minifier.new(str).minify.strip
         rescue SyntaxError
-          raise Error::MarkdownError, "Syntax error in:\n\n#{str}"
+          raise Error, "Syntax error in:\n\n#{str}"
         end
       end
     end

data/lib/minitest/markdown/test_class.rb

@@ -1,67 +1,74 @@
 # frozen_string_literal: true
 
 require_relative '../assertions_extensions'
-require_relative 'test_code_block'
+require_relative 'ruby_code_block'
 
 $LOAD_PATH << '.' # fix #2
 
 module Minitest
   module Markdown
-    # knows how to build a markdown test
+    # knows how to build a markdown test class, test methods and 'state' methods
     class TestClass
-      FENCED_BLOCK_REGEXP = /^```ruby\n(.*?)\n```/m # TODO: use Lexer/RDoc::Parser? which can deal with md comments
-      HOOK_METHODS = %i[before_all after_all around around_all].freeze # minitest-hooks extension
-      NON_TEST_METHODS = %i[setup teardown].freeze
+      FENCED_BLOCK_REGEXP = /^```ruby\n(.*?)\n```/m
+
+      BAD_KLASS = 'TestClass must be instantiated with Minitest::Test or subclass thereof'
+      BAD_PATH  = 'Path does not exist, is not readable or is not a Markdown file:'
+      MD        = '.md'
+
+      HOOK_METHODS_BEFORE = %i[before_all].freeze
+      HOOK_METHODS_AFTER  = %i[after_all around around_all].freeze
 
       attr_reader :klass, :path
 
       def initialize(klass, path: nil)
-        @klass = klass
-        @config = Markdown.config
-        @path = path || @config.readme_path
-        @ruby_blocks = parse_ruby_blocks
+        @klass = validate_class klass
+        @path = validate_path path
+        @state_methods_defined = []
       end
 
       def define_methods(stubs: {})
-        define_non_test_methods
-        @ruby_blocks.each_with_index { |block, i| define_test_method(block, i, stubs[i]) }
-        nil
+        i = 0
+        parse_ruby_blocks.each do |block|
+          next define_non_test_method(block) unless block.type == :test
+
+          define_test_method(block, i, stub_chain: stubs[i])
+          i += 1
+        end
       end
 
       private
 
-      def parse_ruby_blocks
-        File.new(path).read.scan(FENCED_BLOCK_REGEXP).flatten.map { |str| TestCodeBlock.new(str) }
+      def validate_class(klass)
+        raise ArgumentError, BAD_KLASS unless klass.respond_to?(:ancestors) && klass.ancestors.include?(Minitest::Test)
+
+        klass
       end
 
-      def define_non_test_methods
-        recognized_non_test_methods.each { |name| define_non_test_method(name, parse_non_test_method_block(name)) }
+      def validate_path(pth)
+        return Markdown.config.readme_path if pth.nil?
+        raise ArgumentError, "#{BAD_PATH} #{pth}" unless File.exist?(pth) && File.file?(pth) && File.extname(pth) == MD
+
+        pth
       end
 
-      def recognized_non_test_methods
-        Minitest.const_defined?(:Hooks) ? NON_TEST_METHODS + HOOK_METHODS : NON_TEST_METHODS
+      def parse_ruby_blocks
+        File.new(path).read.scan(FENCED_BLOCK_REGEXP).flatten.map { |str| RubyCodeBlock.new(str) }
       end
 
-      def define_non_test_method(type, block)
-        return unless block
+      def define_non_test_method(block)
+        type = block.type
+        raise Error, "State method: #{type} is already defined" if @state_methods_defined.include? type
 
         bind = binding
         klass.define_method(type) do
-          super() if type == :before_all
-          bind.eval(block)
-          super() if %i[after_all around around_all].include? type
+          super() if HOOK_METHODS_BEFORE.include? type
+          bind.eval(block.fenced_block_str)
+          super() if HOOK_METHODS_AFTER.include? type
         end
+        @state_methods_defined << type
       end
 
-      def parse_non_test_method_block(type)
-        blocks = @ruby_blocks.map.select { |blk| blk.fenced_block_str.lines.first == "# #{type}\n" }
-        return if blocks.empty?
-        raise Error::MarkdownError, "Multiple #{type} blocks are not allowed" if blocks.size > 1
-
-        @ruby_blocks.delete(blocks.first).fenced_block_str # hook method blocks can't be test methods
-      end
-
-      def define_test_method(block, meth_index, stub_chain = nil)
+      def define_test_method(block, meth_index, stub_chain:)
         stub_chain ||= StubChain.new
         instance = self # scope
         klass.define_method(:"test_block#{meth_index}") do
@@ -73,9 +80,9 @@ module Minitest
       end
 
       def evaluation_assertions(assertion_hash, bind)
-        ruby, assertion, args = TestCodeBlock::ASSERTION_KEYS.map { |key| assertion_hash[key] } # order dep
+        ruby, assertion, args = RubyCodeBlock::ASSERTION_KEYS.map { |key| assertion_hash[key] } # order dep
 
-        lmbda = -> { eval(ruby) } # rubocop:disable Security/Eval
+        lmbda = -> { kernel_eval(ruby) }
         return unless assertion
         return eval_with_block(bind, assertion, lmbda, args) if Assertions::WITH_BLOCK_EVAL.include? assertion
 
@@ -85,20 +92,27 @@ module Minitest
       def eval_with_block(bind, assertion, actual, args)
         return bind.receiver.send(assertion, &actual) if args.empty?
 
-        bind.receiver.send(assertion, *eval(args), &actual) # rubocop:disable Security/Eval
+        bind.receiver.send(assertion, *kernel_eval(args), &actual)
       end
 
       def eval_without_block(bind, assertion, lmbda, args)
         actual = lmbda.call
         return bind.receiver.send(assertion, actual) if args == '[]'
 
-        expected, *rest = eval(args) # rubocop:disable Security/Eval
+        expected, *rest = kernel_eval(args)
         expected, actual = actual, expected if Assertions::EXPECTED_ACTUAL_REVERSED.include? assertion
         kwargs = rest.last.is_a?(Hash) ? rest.last : nil
         return bind.receiver.send(assertion, expected, actual, *rest) unless kwargs
 
         bind.receiver.send(assertion, expected, actual, *rest, **kwargs) # assert_respond_to takes a kwarg..
       end
+
+      def kernel_eval(str)
+        bind = binding
+        bind.eval str
+      rescue SyntaxError
+        raise ArgumentError, "Invalid test code, failed to parse #{str}"
+      end
     end
   end
 end

data/lib/minitest/markdown/version.rb

@@ -2,6 +2,6 @@
 
 module Minitest
   module Markdown
-    VERSION = '0.2.1.pre'
+    VERSION = '0.2.3'
   end
 end

data/lib/minitest/markdown.rb

@@ -4,7 +4,7 @@ require 'minitest/stub_any_instance'
 
 require_relative 'stub_chain'
 require_relative 'markdown/configuration'
-require_relative 'markdown/error'
+require_relative 'markdown/errors'
 require_relative 'markdown/version'
 require_relative 'markdown/test_class'
 

data/lib/minitest/stub_chain.rb

@@ -12,10 +12,10 @@ module Minitest
       @stubs = *stubs
     end
 
-    def self.stubproc(klass, method, ret_val, any_instance: false)
-      return proc { |&blk| klass.stub(method, ret_val) { blk.call } } unless any_instance
+    def self.stubproc(klass, *args, any_instance: false, **kwargs)
+      return proc { |&blk| klass.stub(*args, **kwargs) { blk.call } } unless any_instance
 
-      proc { |&blk| klass.stub_any_instance(method, ret_val) { blk.call } }
+      proc { |&blk| klass.stub_any_instance(*args, **kwargs) { blk.call } }
     end
 
     def call(test_code_proc)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-markdown
 version: !ruby/object:Gem::Version
-  version: 0.2.1.pre
+  version: 0.2.3
 platform: ruby
 authors:
 - MatzFan
@@ -77,9 +77,9 @@ files:
 - lib/minitest/assertions_extensions.rb
 - lib/minitest/markdown.rb
 - lib/minitest/markdown/configuration.rb
-- lib/minitest/markdown/error.rb
+- lib/minitest/markdown/errors.rb
+- lib/minitest/markdown/ruby_code_block.rb
 - lib/minitest/markdown/test_class.rb
-- lib/minitest/markdown/test_code_block.rb
 - lib/minitest/markdown/version.rb
 - lib/minitest/stub_chain.rb
 - sig/minitest/markdown.rbs