minitest-markdown 0.1.0.pre → 0.2.1.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c4e1e286d2eead001d4b6e0d361aa9bb5c0a7019a5eb8d72eacf6635003e59da
-  data.tar.gz: 3f95349b886aa8752280e2fb2b5083d5bfc754ec8c4faed065dbb2a6e9b4d7e5
+  metadata.gz: 959c342f3e4ec34238e2385e3578faf1d5133beb2f74d9b52d4ffc9ab0dc8d58
+  data.tar.gz: 8b4bae7c2888040d6b2124fa2bd5d103c67405c883bf3de606f220e317912249
 SHA512:
-  metadata.gz: cd12cc6d7df1724100119b6e03e5960411d7d83b4de26beb0d4bbde0cc3e3f7a66e94901e5f99f051a82f70e058ffa1b103ee0726d103765bb9c405d661387e1
-  data.tar.gz: 11a4a61ba9044aec6811b9df724a111fa5345b29d837d91c8ee76a73e95939ca760243423e40127597d3b3ea0f040e633e31001d4268f33c8e06b5545efa0e06
+  metadata.gz: e3d59e3fc4f77092cdd8dda4f3a0b8a8d79e1b73cbfc37186947efd6dbb0e35f508ab0d32da4f6a88d4c816d72370ff92b563e819c44073da4ea44404b946acb
+  data.tar.gz: 2522d752e44a422f82be9ccb1a44c9ddec8346381d2cb0465990a7eee5b383e0a6b664c7f7b52c9ba860602c2a78411dc9f225c4a580bc287f65c26fbace05ad

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## [Unreleased]
 
+## [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

@@ -103,14 +103,16 @@ Everything in the code blocks above runs as test code. [minitest-proveit](https:
 
 ## Stubbing
 
-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:
+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:
 ```ruby
 class MarkdownTest < Minitest::Test
-  extend Markdown::Stubb # for the stubb & stubb_any_instance methods
+  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
 
   stubs = {}
-  stubs[8] = stubb(Set, :new, []) # returns a proc
-  stubs[9] = stubb_any_instance(Set, :size, 42) # uses the bundled `minitest-stub_any_instance` extension
+  @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
 
   Markdown.generate_markdown_tests(self, stubs: stubs)
 end
@@ -119,15 +121,15 @@ end
 The 2 stubs above are demonstated in the following examples:
 ```ruby
 # This is test_block8
-Set.new([1, 'c', :s]) # Set.new stubbed to return an Array
-# => instance_of Array
+Set.new([1, 'c', :s]).size # Here Set.new was stubbed to return an Array and Array#size was stubbed to return 42
+# => 42
 ```
+Example showing the reuse of a StubChain:
 ```ruby
 # This is test_block9
-Set.new([1, 'c', :s]).size # Set#size stubbed to return 42
+Set.new([]).size
 # => 42
 ```
-Presently only one stub per test is possible.
 
 ## Configuration
 

data/lib/minitest/markdown/test_class.rb

@@ -3,6 +3,8 @@
 require_relative '../assertions_extensions'
 require_relative 'test_code_block'
 
+$LOAD_PATH << '.' # fix #2
+
 module Minitest
   module Markdown
     # knows how to build a markdown test
@@ -59,13 +61,14 @@ module Minitest
         @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
+      def define_test_method(block, meth_index, stub_chain = nil)
+        stub_chain ||= StubChain.new
         instance = self # scope
         klass.define_method(:"test_block#{meth_index}") do
-          stub.call 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)
         end
       end
 

data/lib/minitest/markdown/version.rb

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

data/lib/minitest/markdown.rb

@@ -2,15 +2,17 @@
 
 require 'minitest/stub_any_instance'
 
+require_relative 'stub_chain'
 require_relative 'markdown/configuration'
 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
@@ -21,6 +23,10 @@ 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

data/lib/minitest/stub_chain.rb

@@ -0,0 +1,41 @@
+# 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, method, ret_val, any_instance: false)
+      return proc { |&blk| klass.stub(method, ret_val) { blk.call } } unless any_instance
+
+      proc { |&blk| klass.stub_any_instance(method, ret_val) { 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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-markdown
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre
+  version: 0.2.1.pre
 platform: ruby
 authors:
 - MatzFan
@@ -78,10 +78,10 @@ files:
 - lib/minitest/markdown.rb
 - lib/minitest/markdown/configuration.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.6.8
+rubygems_version: 3.7.0.dev
 specification_version: 4
 summary: Turn your README.md Ruby code blocks into testable code.
 test_files: []

data/lib/minitest/markdown/stubb.rb

@@ -1,16 +0,0 @@
-# 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