minitest-markdown 0.0.0 → 0.0.1.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d404e86afc3911d3c33f3c6db07e8895fcba5dca70490ceebe23d7e419f18fd
-  data.tar.gz: 6943203dde54269f4c4b4932d0aca354fc6a90b9531ca587956cdc6f90bb4686
+  metadata.gz: 6836d7576d3a208628f401e2660fac20d4288faf95c6513e76dd20a2a402fed2
+  data.tar.gz: 4f38166f7ff54f9a74391daafe8e698a7f0aabc57cf7a3797f292b3b8d85d524
 SHA512:
-  metadata.gz: 8975c4e35527de62d85c8e92298fe67789ae74e1dcec8b39f2d3edf0527d78ea40ab995b8a08c6e5c303acb2b9bcb2957986a24d225a0f6003e438efdee46671
-  data.tar.gz: 92578fe079a4cf4d90e5b74a3dc629b0517dbae6bdd0a08c236d9ce0f2b6ddb7fa36f380a315165006e2a3e5637b3d8bca5604d52124b0a2275c44bc26880695
+  metadata.gz: 393bc3aff42df19c5cfd10c2edddb64242798765d30aed3185e44be621547e0ed93f495113cca4082e388ab20f2da213f4f5ad4411b17f6117b1421c531d066a
+  data.tar.gz: a30d096c73f2064311cb2d729305fe5cc1d00cca871575fb75783d8046d28f5fc325d92882ccb886834358ed6a586f36eb397439829fba22f4d875c2f6e61998

data/CHANGELOG.md

@@ -1,34 +1,5 @@
 ## [Unreleased]
 
-## [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
-- Add dependency; minitest-stub_any_instance 
-
 ## [0.0.1.pre] - 2025-04-24
 
 - Bump minitest dep to >= 5.25.2

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
@@ -42,20 +30,16 @@ To test the Ruby blocks in your README file, create file `test_readme.rb` (for e
 require 'minitest/autorun' # or in your test_helper
 require 'minitest/markdown' # ditto
 
-class ReadmeTest < Minitest::Test # or your own subclass of Minitest::Test
+class ReadmeTest < MyTest # your own subclass of Minitest::Test
   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"
@@ -69,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
@@ -91,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
@@ -101,96 +82,36 @@ 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
-```
-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 test class.
 
 
-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
-
-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:
-```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 = {}
-  stubs[10] = stub_chain
-  stubs[11] = stub_chain # StubChain instances themselves may be reused
+## Configuration
 
-  Markdown.generate_markdown_tests(self, stubs: stubs)
-end
-# => truthy
-```
-The 2 stubs in the `StubChain` instance above are demonstrated in the following example:
+No configuation is required if you use Bundler. If not, set your `project_root` path using the setter method:
 ```ruby
-# This is test_block10
-Set.new([1, 'c', :s]).size
-# => 42
+@config = Markdown.config
+# => instance_of Configuration
 
-# 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_block11
-Set.new.size
-# => 42
+Configuration.instance_methods(false)
+# => includes :project_root=
 ```
 
-### Errors
-
-All errors subclass `Markdown::Error`
-
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -199,7 +120,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://github.com/[USERNAME]/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/test_class.rb

@@ -1,88 +1,75 @@
 # 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
+      def define_methods
+        define_non_test_methods
+        @ruby_blocks.each_with_index { |block, i| define_test_method(block, 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)
         instance = self # scope
         klass.define_method(:"test_block#{meth_index}") do
-          test_code_proc = proc do
-            block.assertions.each { |assertion_hash| instance.send(:evaluation_assertions, assertion_hash, binding) }
-          end
-          stub_chain.call(test_code_proc)
+          block.assertions.each { |assertion_hash| instance.send(:evaluation_assertions, assertion_hash, binding) }
         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 +79,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,14 +1,14 @@
 # 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
+    # A Ruby code block reprenting test code, with 0 or more assertions
+    class TestCodeBlock
       ASSERT_ = 'assert_'
       ASSERT_REGEXP = /\A#{ASSERT_}/
       SKIP = { skip: :skip }.freeze
@@ -16,35 +16,24 @@ module Minitest
 
       ASSERTION_KEYS = %i[ruby assertion test_args].freeze
 
-      HOOK_METHODS      = %i[before_all after_all around around_all].freeze # minitest-hooks extension
-      STATE_METHODS     = %i[setup teardown].freeze
-      STATE_BLOCK_TYPES = Minitest.const_defined?(:Hooks) ? STATE_METHODS + HOOK_METHODS : STATE_METHODS
-
-      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
@@ -56,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
@@ -66,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
@@ -77,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.0'
+    VERSION = '0.0.1.pre'
   end
 end

data/lib/minitest/markdown.rb

@@ -1,18 +1,13 @@
 # frozen_string_literal: true
 
-require 'minitest/stub_any_instance'
-
-require_relative 'stub_chain'
 require_relative 'markdown/configuration'
-require_relative 'markdown/errors'
+require_relative 'markdown/error'
 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
@@ -22,12 +17,8 @@ module Minitest
         yield config
       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)
+      def generate_markdown_tests(klass, path: nil)
+        TestClass.new(klass, path: path).define_methods
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-markdown
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.0.1.pre
 platform: ruby
 authors:
 - MatzFan
@@ -49,20 +49,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.25.2
-- !ruby/object:Gem::Dependency
-  name: minitest-stub_any_instance
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.0'
 description: Generates tests for Ruby code blocks in any Markdown file.
 executables: []
 extensions: []
@@ -77,11 +63,10 @@ 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/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 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 3.6.7
 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