minitest-markdown 0.0.1 → 0.1.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 497033589078efbc020edf7c16075dc2c72af705ef81b947ef9e3f9532abdae3
-  data.tar.gz: c2919ce835a3dd9326cf66efdabd6fa2a739459cb236b3ac4b4dd5d1102784e1
+  metadata.gz: c4e1e286d2eead001d4b6e0d361aa9bb5c0a7019a5eb8d72eacf6635003e59da
+  data.tar.gz: 3f95349b886aa8752280e2fb2b5083d5bfc754ec8c4faed065dbb2a6e9b4d7e5
 SHA512:
-  metadata.gz: 152b82cbb368756281c6da8523de466e35a4a546c748282769282bfcf5cf799b66e8ba380246dda6e4c700589d2fbe5708d0d150de21c201b1d76254029721ee
-  data.tar.gz: bc042b387c85a1e1a57372a825064b54665fe1e541933b1e74d3c2932ee765477b334c4bbb7d2272fac6bfb5fbbfe6df0c2c1a6c7202ff1e2544a8cf8f2c6a99
+  metadata.gz: cd12cc6d7df1724100119b6e03e5960411d7d83b4de26beb0d4bbde0cc3e3f7a66e94901e5f99f051a82f70e058ffa1b103ee0726d103765bb9c405d661387e1
+  data.tar.gz: 11a4a61ba9044aec6811b9df724a111fa5345b29d837d91c8ee76a73e95939ca760243423e40127597d3b3ea0f040e633e31001d4268f33c8e06b5545efa0e06

data/CHANGELOG.md

@@ -1,33 +1,5 @@
 ## [Unreleased]
 
-## [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
-- Fix bug in StubChain where instance was mutated after #call
-
-## [0.2.0.pre] - 2025-05-06
-
-- Add ability to pass any number of stubs to a test code block
-
-### Breaking changes
-- StubChain class replaces Stubb module see https://gitlab.com/matzfan/minitest-markdown#stubbing
-
 ## [0.1.0.pre] - 2025-05-01
 
 - Add ability to pass stubs to test class

data/README.md

@@ -5,11 +5,10 @@
 
 ## \_why?
 
-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!!
+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!!
 
 ## Installation
 
-
 Add the gem to the application's Gemfile:
 
 ```bash
@@ -22,17 +21,6 @@ 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
@@ -41,24 +29,17 @@ 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
-# => truthy
+# => nil
 ```
 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. 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:
+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:
 ```ruby
 File.read 'test/fixtures/klass.rb'
 # => "class Klass\n  def hello\n    'Hello Markdown!'\n  end\nend"
@@ -72,15 +53,12 @@ Klass.new # inline comments are also ignored
 # The assertion and expected value are:-
 # => instance_of Klass
 
-# No keyword here, so the default assertion is used (assert_equal)
+# No keywword 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
@@ -94,7 +72,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 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:
+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:
 ```ruby
 22/7.0
 # => in_delta Math::PI, 0.01
@@ -104,102 +82,63 @@ 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
 
-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.
-
+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.
 ```ruby
 # setup
 
-# do some setup task - or:-
-@instance_var = 7 # now available in all test method blocks, including the one above
-# => IGNORED
+@instance_var = 42
 ```
+The instance var set is now available to all test blocks (tests) in the Markdown file.
 ```ruby
-# teardown
-
-# do some teardown task
+@instance_var
+# => 42
 ```
-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:
+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.
 
-```ruby
-# before_all
-@before_all_instance_var = 'foo'
-```
 
-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 ;-)
+Everything in the code blocks above runs as test code. [minitest-proveit](https://github.com/seattlerb/minitest-proveit) would complain otherwise ;-)
 
-### Mocks
+## Stubbing
 
-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
-
-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:
+It is possible to pass stubs to the generated tests. This is done by passing a hash of procs using the stubs keyword. Hash keys represent the index of the text code block and the key is a proc which is called around the relevant test code. 2 convenience methods are provided by the `Markdown::Stubb` module. In your markdown test:
 ```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
+  extend Markdown::Stubb # for the stubb & stubb_any_instance methods
 
   stubs = {}
-  stubs[10] = stub_chain
-  stubs[11] = stub_chain # StubChain instances themselves may be reused
+  stubs[8] = stubb(Set, :new, []) # returns a proc
+  stubs[9] = stubb_any_instance(Set, :size, 42) # uses the bundled `minitest-stub_any_instance` extension
 
   Markdown.generate_markdown_tests(self, stubs: stubs)
 end
-# => truthy
+# => nil
 ```
-The 2 stubs in the `StubChain` instance above are demonstrated in the following example:
+The 2 stubs above are demonstated in the following examples:
 ```ruby
-# 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
+# This is test_block8
+Set.new([1, 'c', :s]) # Set.new stubbed to return an Array
+# => instance_of Array
 ```
-Example showing the reuse of a StubChain:
 ```ruby
-# This is test_block11
-Set.new.size
+# This is test_block9
+Set.new([1, 'c', :s]).size # Set#size stubbed to return 42
 # => 42
 ```
+Presently only one stub per test is possible.
+
+## Configuration
 
-### Errors
+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
 
-All errors subclass `Markdown::Error`
+Configuration.instance_methods(false)
+# => includes :project_root=
+```
 
 ## Development
 
@@ -209,7 +148,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-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.
+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.
 
 ## License
 

data/lib/minitest/markdown/configuration.rb

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

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

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

data/lib/minitest/markdown/stubb.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Minitest
+  module Markdown
+    # a proc'ed stub
+    module Stubb
+      def stubb(object, method, ret_val, *args, **kwargs)
+        proc { |&blk| object.stub(method, ret_val, *args, **kwargs) { blk.call } }
+      end
+
+      def stubb_any_instance(object, method, ret_val, *args, **kwargs)
+        proc { |&blk| object.stub_any_instance(method, ret_val, *args, **kwargs) { blk.call } }
+      end
+    end
+  end
+end

data/lib/minitest/markdown/test_class.rb

@@ -1,88 +1,78 @@
 # frozen_string_literal: true
 
 require_relative '../assertions_extensions'
-require_relative 'ruby_code_block'
-
-$LOAD_PATH << '.' # fix #2
+require_relative 'test_code_block'
 
 module Minitest
   module Markdown
-    # knows how to build a markdown test class, test methods and 'state' methods
+    # knows how to build a markdown test
     class TestClass
-      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
+      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
 
       attr_reader :klass, :path
 
       def initialize(klass, path: nil)
-        @klass = validate_class klass
-        @path = validate_path path
-        @state_methods_defined = []
+        @klass = klass
+        @config = Markdown.config
+        @path = path || @config.readme_path
+        @ruby_blocks = parse_ruby_blocks
       end
 
       def define_methods(stubs: {})
-        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
+        define_non_test_methods
+        @ruby_blocks.each_with_index { |block, i| define_test_method(block, i, stubs[i]) }
+        nil
       end
 
       private
 
-      def validate_class(klass)
-        raise ArgumentError, BAD_KLASS unless klass.respond_to?(:ancestors) && klass.ancestors.include?(Minitest::Test)
-
-        klass
+      def parse_ruby_blocks
+        File.new(path).read.scan(FENCED_BLOCK_REGEXP).flatten.map { |str| TestCodeBlock.new(str) }
       end
 
-      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
+      def define_non_test_methods
+        recognized_non_test_methods.each { |name| define_non_test_method(name, parse_non_test_method_block(name)) }
       end
 
-      def parse_ruby_blocks
-        File.new(path).read.scan(FENCED_BLOCK_REGEXP).flatten.map { |str| RubyCodeBlock.new(str) }
+      def recognized_non_test_methods
+        Minitest.const_defined?(:Hooks) ? NON_TEST_METHODS + HOOK_METHODS : NON_TEST_METHODS
       end
 
-      def define_non_test_method(block)
-        type = block.type
-        raise Error, "State method: #{type} is already defined" if @state_methods_defined.include? type
+      def define_non_test_method(type, block)
+        return unless block
 
         bind = binding
         klass.define_method(type) do
-          super() if HOOK_METHODS_BEFORE.include? type
-          bind.eval(block.fenced_block_str)
-          super() if HOOK_METHODS_AFTER.include? type
+          super() if type == :before_all
+          bind.eval(block)
+          super() if %i[after_all around around_all].include? type
         end
-        @state_methods_defined << type
       end
 
-      def define_test_method(block, meth_index, stub_chain:)
-        stub_chain ||= StubChain.new
+      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 = nil)
+        stub ||= proc { |&blk| blk.call } # empty proc if no stub provided
         instance = self # scope
         klass.define_method(:"test_block#{meth_index}") do
-          test_code_proc = proc do
+          stub.call do
             block.assertions.each { |assertion_hash| instance.send(:evaluation_assertions, assertion_hash, binding) }
           end
-          stub_chain.call(test_code_proc)
         end
       end
 
       def evaluation_assertions(assertion_hash, bind)
-        ruby, assertion, args = RubyCodeBlock::ASSERTION_KEYS.map { |key| assertion_hash[key] } # order dep
+        ruby, assertion, args = TestCodeBlock::ASSERTION_KEYS.map { |key| assertion_hash[key] } # order dep
 
-        lmbda = -> { kernel_eval(ruby) }
+        lmbda = -> { eval(ruby) } # rubocop:disable Security/Eval
         return unless assertion
         return eval_with_block(bind, assertion, lmbda, args) if Assertions::WITH_BLOCK_EVAL.include? assertion
 
@@ -92,27 +82,20 @@ module Minitest
       def eval_with_block(bind, assertion, actual, args)
         return bind.receiver.send(assertion, &actual) if args.empty?
 
-        bind.receiver.send(assertion, *kernel_eval(args), &actual)
+        bind.receiver.send(assertion, *eval(args), &actual) # rubocop:disable Security/Eval
       end
 
       def eval_without_block(bind, assertion, lmbda, args)
         actual = lmbda.call
         return bind.receiver.send(assertion, actual) if args == '[]'
 
-        expected, *rest = kernel_eval(args)
+        expected, *rest = eval(args) # rubocop:disable Security/Eval
         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/{ruby_code_block.rb → test_code_block.rb}

@@ -1,47 +1,39 @@
 # frozen_string_literal: true
 
-require 'minifyrb'
+require 'minifyrb' # DEP
 
 require_relative '../assertions_extensions' # for assert_truthy
-require_relative '../markdown/errors'
+require_relative '../markdown/error'
 
 module Minitest
   module Markdown
-    # 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
+    # A Ruby code block reprenting test code, with 0 or more assertions
+    class TestCodeBlock
+      ASSERT_ = 'assert_'
+      ASSERT_REGEXP = /\A#{ASSERT_}/
+      SKIP = { skip: :skip }.freeze
       DEFAULT_ASSERTION = :assert_equal
 
-      ASSERTION_KEYS    = %i[ruby assertion test_args].freeze
-      STATE_BLOCK_TYPES = %i[setup teardown before_all after_all around around_all].freeze
+      ASSERTION_KEYS = %i[ruby assertion test_args].freeze
 
-      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 '# =>'"
+      MAGIC_COMMENT_DELIMITER = '# => '
+      MAGIC_COMMENT_REGEXP = /^#{MAGIC_COMMENT_DELIMITER}.*$/
+      MAGIC_COMMENT_SCAN_REGEXP = /^#{MAGIC_COMMENT_DELIMITER}(.*)$/ # strips delimiter prefix
 
       attr_reader :fenced_block_str
 
       def self.asserts
-        @asserts ||= Assertions.instance_methods.grep(ASSERT_REGEXP) - [:assert_send] # deprecated
+        Assertions.instance_methods.grep(ASSERT_REGEXP) - [:assert_send] # deprecated
       end
 
       def self.assertions_map
-        @assertions_map ||= asserts.inject(SKIP) { |memo, m| memo.merge(m.to_s.split(ASSERT_)[1..].join.to_sym => m) }
+        asserts.inject({}) { |memo, m| memo.merge(m.to_s.split(ASSERT_)[1..].join.to_sym => m) }.merge(SKIP)
       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
@@ -53,8 +45,6 @@ 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
@@ -63,7 +53,7 @@ module Minitest
       end
 
       def parse_assertion(str)
-        self.class.assertions_map[str.split.first.to_sym] # 'nil' => :assert_nil, but 'nil?' => nil
+        self.class.assertions_map[str.split.first.to_sym]
       end
 
       def magic_comments
@@ -74,7 +64,7 @@ module Minitest
         @fenced_block_str.split(MAGIC_COMMENT_REGEXP).map do |str|
           Minifyrb::Minifier.new(str).minify.strip
         rescue SyntaxError
-          raise Error, "Syntax error in:\n\n#{str}"
+          raise Error::MarkdownError, "Syntax error in:\n\n#{str}"
         end
       end
     end

data/lib/minitest/markdown/version.rb

@@ -2,6 +2,6 @@
 
 module Minitest
   module Markdown
-    VERSION = '0.0.1'
+    VERSION = '0.1.0.pre'
   end
 end

data/lib/minitest/markdown.rb

@@ -2,17 +2,15 @@
 
 require 'minitest/stub_any_instance'
 
-require_relative 'stub_chain'
 require_relative 'markdown/configuration'
-require_relative 'markdown/errors'
+require_relative 'markdown/error'
+require_relative 'markdown/stubb'
 require_relative 'markdown/version'
 require_relative 'markdown/test_class'
 
 module Minitest
   # namespace
   module Markdown
-    ARG_ERR = 'stubs keyword takes a hash. Keys are integers and values are StubChain instances'
-
     class << self
       def config
         @config ||= Configuration.new
@@ -23,10 +21,6 @@ module Minitest
       end
 
       def generate_markdown_tests(klass, path: nil, stubs: {})
-        raise ArgumentError, ARG_ERR unless stubs.is_a? Hash
-        raise ArgumentError, ARG_ERR unless stubs.keys.all? { |o| o.instance_of? Integer }
-        raise ArgumentError, ARG_ERR unless stubs.values.all? { |o| o.instance_of? StubChain }
-
         TestClass.new(klass, path: path).define_methods(stubs: stubs)
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-markdown
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0.pre
 platform: ruby
 authors:
 - MatzFan
@@ -77,11 +77,11 @@ files:
 - lib/minitest/assertions_extensions.rb
 - lib/minitest/markdown.rb
 - lib/minitest/markdown/configuration.rb
-- lib/minitest/markdown/errors.rb
-- lib/minitest/markdown/ruby_code_block.rb
+- lib/minitest/markdown/error.rb
+- lib/minitest/markdown/stubb.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
 homepage: https://gitlab.com/matzfan/minitest-markdown
 licenses:
@@ -104,7 +104,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.0.dev
+rubygems_version: 3.6.8
 specification_version: 4
 summary: Turn your README.md Ruby code blocks into testable code.
 test_files: []

data/lib/minitest/stub_chain.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module Minitest
-  # respresentaion of zero or more stub blocks around one or more test assertions
-  class StubChain
-    NOT_CALLABLE_ERR = 'StubChain#call takes a callable argument'
-    MUST_NOT_CALL_A_BLOCK_ERR = 'StubChain#call takes a callable argument which must not call a block'
-
-    attr_reader :stubs
-
-    def initialize(stubs = [])
-      @stubs = *stubs
-    end
-
-    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(*args, **kwargs) { blk.call } }
-    end
-
-    def call(test_code_proc)
-      validate(test_code_proc)
-      call_recursive [*stubs, test_code_proc]
-    end
-
-    private
-
-    def validate(test_code_proc)
-      raise ArgumentError, NOT_CALLABLE_ERR unless test_code_proc.respond_to?(:call)
-
-      test_code_proc
-    end
-
-    def call_recursive(call_chain)
-      prok = call_chain.shift
-      return prok.call if call_chain.empty?
-
-      prok.call { call_recursive(call_chain) }
-    end
-  end
-end