minitest-markdown 0.2.2.pre → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a9a40aad00d3cf796ff92234e9677cc452131a2ca0ff09936d77de0155e1cd7
-  data.tar.gz: 57e2ce0e6b9b4a3752a621dde91cdf8e483dca82efa4eb6373a2de04f2175769
+  metadata.gz: fabeb5456de7296b1986c66822818a5fec9834e2c23e19b33a4c3c198e262ae6
+  data.tar.gz: bebbc7f77cd2443e91e58224888e5b69ab2d072b69e49c4cab86557cb0c3eeec
 SHA512:
-  metadata.gz: a09e92d607c2484518f8f23fac73e709de766b62f41d17bdfeaccc4931293b2e00cbdf35a5ad4872be6aae6f4022a6579d38dc31c23a5581191c16c85924b596
-  data.tar.gz: 96fbb9758bfd397dcce743c0f76c9e78e6155b4fd5f4a299e9c64bb304503732565f4310b348032a43fb4febccab3e7eb79b1cc12aa3a21b82563fc2760d829d
+  metadata.gz: 5b369fab40830b0a31951df1ddb8dc25868471f2766f81fd2c438bba7219921e45ef47e48d9c73b2224655d39a1005efd23e8c0a268481c3f9b0a3d628019ee2
+  data.tar.gz: 2789d00a505fa70ea7ce6c29352807c066951c4498862f4b1afe6190e568e3b7da31ce63b3a5baf74e51cd24759c183a432121cb1209d883faf672ec08a1dd13

data/CHANGELOG.md

@@ -1,5 +1,19 @@
 ## [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

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
@@ -23,9 +24,9 @@ gem install minitest-markdown
 
 ## Configuration
 
-No configuation is required if you use Bundler. If not, set your `project_root` path using the setter method:
+No configuration is required if you use Bundler. If not, set your `project_root` path using the setter method:
 ```ruby
-@config = Markdown.config
+@config = Minitest::Markdown.config
 # => instance_of Configuration
 
 Configuration.instance_methods(false)
@@ -40,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"
@@ -64,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
@@ -83,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
@@ -93,51 +104,95 @@ 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 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!'])
 
-Everything in the code blocks above runs as test code. [minitest-proveit](https://github.com/seattlerb/minitest-proveit) would complain otherwise ;-)
+@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, Set.new) # returns a proc which stubs Set.new to return an empty set
-  set_stubs_size = Minitest::StubChain.stubproc(Set, :size, 42, any_instance: true) # uses the bundled minitest-stub_any_instance gem
+  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, set_stubs_size]) # initialized with zero or more stub procs
-  stubs[9] = @stub_chain
-  stubs[10] = @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_block9
-Set.new([1, 'c', :s]).size # Here Set.new was stubbed to return an empty set and Set#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_block10
+# This is test_block11
 Set.new.size
 # => 42
 ```
@@ -154,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/ruby_code_block.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'minifyrb'
+
+require_relative '../assertions_extensions' # for assert_truthy
+require_relative '../markdown/errors'
+
+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
+      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
+
+      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
+        @asserts ||= 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) }
+      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
+
+      private
+
+      def assertions_arr
+        code_strings.zip(magic_comments.map { |s| parse(s) }).map(&:flatten)
+      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
+
+        [assertion, "[#{magic_comment_string.sub(/#{assertion.to_s.sub(ASSERT_, '')}\s+/, '')}]"]
+      end
+
+      def parse_assertion(str)
+        self.class.assertions_map[str.split.first.to_sym] # 'nil' => :assert_nil, but 'nil?' => nil
+      end
+
+      def magic_comments
+        @fenced_block_str.scan(MAGIC_COMMENT_SCAN_REGEXP).flatten
+      end
+
+      def code_strings
+        @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}"
+        end
+      end
+    end
+  end
+end

data/lib/minitest/markdown/test_class.rb

@@ -1,34 +1,39 @@
 # 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 or is not readable:'
+      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 = validate_class(klass)
-        @config = Markdown.config
-        @path = validate_path(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
@@ -39,49 +44,31 @@ module Minitest
         klass
       end
 
-      def validate_path(path)
-        return @config.readme_path if path.nil?
-        raise ArgumentError, "#{BAD_PATH} #{path}" unless File.exist?(path) && File.file?(path)
+      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
 
-        path
+        pth
       end
 
       def parse_ruby_blocks
-        File.new(path).read.scan(FENCED_BLOCK_REGEXP).flatten.map { |str| TestCodeBlock.new(str) }
-      end
-
-      def define_non_test_methods
-        recognized_non_test_methods.each { |name| define_non_test_method(name, parse_non_test_method_block(name)) }
-      end
-
-      def recognized_non_test_methods
-        Minitest.const_defined?(:Hooks) ? NON_TEST_METHODS + HOOK_METHODS : NON_TEST_METHODS
+        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| parse_type(blk, type) }
-        return if blocks.empty?
-        raise Error, "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 parse_type(blk, type)
-        blk.fenced_block_str.lines.first.match?(/^\s*#\s*#{type}\s*\n$/)
-      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
@@ -93,7 +80,7 @@ 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 = -> { kernel_eval(ruby) }
         return unless assertion
@@ -120,10 +107,11 @@ module Minitest
         bind.receiver.send(assertion, expected, actual, *rest, **kwargs) # assert_respond_to takes a kwarg..
       end
 
-      def kernel_eval(args)
-        eval args # rubocop:disable Security/Eval
+      def kernel_eval(str)
+        bind = binding
+        bind.eval str
       rescue SyntaxError
-        raise ArgumentError, "Invalid test code, failed to parse #{args}"
+        raise ArgumentError, "Invalid test code, failed to parse #{str}"
       end
     end
   end

data/lib/minitest/markdown/version.rb

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

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.2.pre
+  version: 0.2.3
 platform: ruby
 authors:
 - MatzFan
@@ -78,8 +78,8 @@ files:
 - lib/minitest/markdown.rb
 - lib/minitest/markdown/configuration.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

data/lib/minitest/markdown/test_code_block.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require 'minifyrb' # DEP
-
-require_relative '../assertions_extensions' # for assert_truthy
-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
-      DEFAULT_ASSERTION = :assert_equal
-
-      ASSERTION_KEYS = %i[ruby assertion test_args].freeze
-
-      MAGIC_COMMENT_DELIMITER = '=>'
-      MAGIC_COMMENT_REGEXP = /^\s*#\s*#{MAGIC_COMMENT_DELIMITER}.*$/
-      MAGIC_COMMENT_SCAN_REGEXP = /^\s*#\s*#{MAGIC_COMMENT_DELIMITER}(.*)$/ # strips delimiter prefix
-
-      attr_reader :fenced_block_str
-
-      def self.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)
-      end
-
-      def initialize(fenced_block_str)
-        @fenced_block_str = fenced_block_str
-      end
-
-      def assertions
-        assertions_arr.map { |arr| Hash[*ASSERTION_KEYS.zip(arr).flatten] }
-      end
-
-      private
-
-      def assertions_arr
-        code_strings.zip(magic_comments.each_with_index.map { |s, i| parse(s, i) }).map(&:flatten)
-      end
-
-      def parse(magic_comment_string, idx)
-        raise ArgumentError, "Block#{idx} magic comment 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
-
-        [assertion, "[#{magic_comment_string.sub(/#{assertion.to_s.sub(ASSERT_, '')}\s+/, '')}]"]
-      end
-
-      def parse_assertion(str)
-        self.class.assertions_map[str.split.first.to_sym]
-      end
-
-      def magic_comments
-        @fenced_block_str.scan(MAGIC_COMMENT_SCAN_REGEXP).flatten.map(&:strip)
-      end
-
-      def code_strings
-        @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}"
-        end
-      end
-    end
-  end
-end