markdown_exec 1.3.3.4 → 1.3.6

data/lib/block_label.rb

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+##
+# This class is used to represent a block label which can be constructed using various components.
+# It handles initialization using a hash and provides a method to create a label string.
+#
+# Example Usage:
+# block = {
+#   filename: 'example.md',
+#   headings: ['Header1', 'Header2'],
+#   menu_blocks_with_docname: true,
+#   menu_blocks_with_headings: false,
+#   title: 'Sample Title',
+#   body: 'Sample Body',
+#   text: 'Sample Text'
+# }
+# label_obj = BlockLabel.new(block)
+# label_str = label_obj.make
+#
+
+class BlockLabel
+  def self.make(filename:, headings:, menu_blocks_with_docname:, menu_blocks_with_headings:, title:, body:, text:)
+    label = title
+    label = body if label.nil? || label.empty?
+    label = text if label.nil? || label.empty?
+
+    parts = [label]
+
+    parts << headings.compact.join(' # ') if menu_blocks_with_headings
+    parts << filename if menu_blocks_with_docname
+
+    parts.join('  ')
+  rescue StandardError => err
+    warn(error = "ERROR ** BlockLabel.make(); #{err.inspect}")
+    binding.pry if $tap_enable
+    raise ArgumentError, error
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require 'minitest/autorun'
+
+  class BlockLabelTest < Minitest::Test
+    def setup
+      @block_data = {
+        filename: 'example.md',
+        headings: %w[Header1 Header2],
+        menu_blocks_with_docname: true,
+        menu_blocks_with_headings: false,
+        title: 'Sample Title',
+        body: 'Sample Body',
+        text: 'Sample Text'
+      }
+    end
+
+    def test_make_method
+      assert_equal 'Sample Title  example.md', BlockLabel.make(**@block_data)
+    end
+
+    def test_make_method_without_title
+      @block_data[:title] = nil
+      label = BlockLabel.make(**@block_data)
+      assert_equal 'Sample Body  example.md', label
+    end
+
+    def test_make_method_without_title_and_body
+      @block_data[:title] = nil
+      @block_data[:body] = nil
+      label = BlockLabel.make(**@block_data)
+      assert_equal 'Sample Text  example.md', label
+    end
+
+    def test_make_method_with_headings
+      @block_data[:menu_blocks_with_headings] = true
+      label = BlockLabel.make(**@block_data)
+      assert_equal 'Sample Title  Header1 # Header2  example.md', label
+    end
+  end
+end

data/lib/env_opts.rb

@@ -93,9 +93,9 @@ class EnvOpts
     args_ind = 0
     while args_ind < argv.count
       args_consumed = 0
-      arg = argv.fetch(args_ind, '') #.tap_inspect 'argument', source: 'EnvOpts'
+      arg = argv.fetch(args_ind, '')
       if arg.start_with? '--'
-        opt_name = arg[2..-1] #.tap_inspect 'opt_name', source: 'EnvOpts'
+        opt_name = arg[2..-1]
         args_consumed = consume_arguments(opt_name,
                                           argv.fetch(args_ind + 1, nil))
       end
@@ -136,7 +136,7 @@ class EnvOpts
   # option names use hyphens
   #
   def self.symbol_name_to_option_name(name)
-    name.to_s.gsub('_', '-') #.tap_inspect
+    name.to_s.gsub('_', '-')
   end
 
   private
@@ -144,7 +144,7 @@ class EnvOpts
   # convert key name or symbol to an option name
   #
   def key_name_to_option_name(key)
-    (key.is_a?(Symbol) ? EnvOpts.symbol_name_to_option_name(key) : key) #.tap_inspect
+    (key.is_a?(Symbol) ? EnvOpts.symbol_name_to_option_name(key) : key)
   end
 
   # get cast of environment variable
@@ -175,7 +175,7 @@ class EnvOpts
   # option names use hyphens
   #
   def method_name_to_option_name(name)
-    name.to_s.gsub('_', '-') #.tap_inspect
+    name.to_s.gsub('_', '-')
   end
 
   # read and write options using the option name as a method
@@ -187,7 +187,7 @@ class EnvOpts
       set_key_value_as_cast(name, value)
     else
       @values[method_name_to_option_name(method_name)]
-    end #.tap_inspect "ref #{method_name}", source: 'EnvOpts'
+    end
   end
 
   # option name to environment name

data/lib/environment_opt_parse.rb

@@ -146,7 +146,7 @@ class EnvironmentOptParse
   include Menu
 
   def initialize(menu: {}, lambdas: nil, options: nil, version: nil)
-    @menu = if menu.class.to_s == 'String'
+    @menu = if menu.instance_of?(::String)
               filetext = File.read(menu).tap_yaml 'filetext'
               fileyaml = YAML.load(filetext)
               fileyaml.map(&:sym_keys)
@@ -156,7 +156,7 @@ class EnvironmentOptParse
     @lambdas = lambdas
     @version = version || '0.1'
     # @options = {}
-    @options = if options.class.to_s == 'String'
+    @options = if options.instance_of?(::String)
                  YAML.safe_load(File.read(options)).sym_keys.tap_yaml '@options'
                else
                  {}
@@ -193,7 +193,7 @@ class EnvironmentOptParse
                        exit
                      },
         val_as_bool: lambda { |value|
-                       value.class.to_s == 'String' ? (value.chomp != '0') : value
+                       value.instance_of?(::String) ? (value.chomp != '0') : value
                      },
         val_as_int: ->(value) { value.to_i },
         val_as_str: ->(value) { value.to_s },

data/lib/fcb.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+module MarkdownExec
+  class Error < StandardError; end
+
+  # Fenced Code Block (FCB)
+  #
+  # This class represents a fenced code block in a markdown document.
+  # It allows for setting and getting attributes related to the code block,
+  # such as body, call, headings, and more.
+  #
+  class FCB
+    def initialize(options = {})
+      @attrs = {
+        body: nil,
+        call: nil,
+        headings: [],
+        name: nil,
+        reqs: [],
+        shell: '',
+        title: '',
+        random: Random.new.rand,
+        text: nil # displayable in menu
+      }.merge(options)
+    end
+
+    def to_h
+      @attrs
+    end
+
+    def to_yaml
+      @attrs.to_yaml
+    end
+
+    private
+
+    # 2023-10-07 proposed but not functional with code
+    #
+    # def method_missing(method, *args, &block)
+    #   method_name = method.to_s
+
+    #   if method_name[-1] == '='
+    #     @attrs[method_name.chop.to_sym] = args[0]
+    #   elsif @attrs.key?(method_name.to_sym)
+    #     @attrs[method_name.to_sym]
+    #   else
+    #     super
+    #   end
+    # rescue StandardError => err
+    #   warn(error = "ERROR ** FCB.method_missing(method: #{method_name}, *args: #{args.inspect}, &block)")
+    #   warn err.inspect
+    #   warn(caller[0..4])
+    #   raise err  # Here, we simply propagate the original error instead of wrapping it in a StandardError.
+    # end
+
+    # :reek:ManualDispatch
+    def method_missing(method, *args, &block)
+      method_name = method.to_s
+
+      if @attrs.respond_to?(method_name)
+        @attrs.send(method_name, *args, &block)
+      elsif method_name[-1] == '='
+        @attrs[method_name.chop.to_sym] = args[0]
+      else
+        @attrs[method_name.to_sym]
+      end
+    rescue StandardError => err
+      warn("ERROR ** FCB.method_missing(method: #{method_name}," \
+           " *args: #{args.inspect}, &block)")
+      warn err.inspect
+      warn(caller[0..4])
+      # raise StandardError, error
+      raise err # Here, we simply propagate the original error instead of wrapping it in a StandardError.
+    end
+
+    def respond_to_missing?(method_name, _include_private = false)
+      @attrs.key?(method_name.to_sym) || super
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require 'minitest/autorun'
+  require 'yaml'
+
+  class FCBTest < Minitest::Test
+    def setup
+      @fcb_data = {
+        body: 'Sample body',
+        call: 'Sample call',
+        headings: %w[Header1 Header2],
+        name: 'Sample name',
+        reqs: %w[req1 req2],
+        shell: 'bash',
+        text: 'Sample Text',
+        title: 'Sample Title'
+      }
+      @fcb = MarkdownExec::FCB.new(@fcb_data)
+    end
+
+    def test_initialization_with_correct_data
+      assert_equal 'Sample body', @fcb.body
+      assert_equal %w[Header1 Header2], @fcb.headings
+    end
+
+    def test_to_h_method
+      assert_equal @fcb_data.merge({ random: @fcb.random }), @fcb.to_h
+    end
+
+    def test_to_yaml_method
+      assert_equal YAML.load(@fcb_data.merge({ random: @fcb.random }).to_yaml),
+                   YAML.load(@fcb.to_yaml)
+    end
+
+    def test_method_missing_getter
+      assert_equal 'Sample Title', @fcb.title
+    end
+
+    def test_method_missing_setter
+      @fcb.title = 'New Title'
+      assert_equal 'New Title', @fcb.title
+    end
+
+    # 2023-10-09 does not trigger error; treats as option name
+    #
+    # def test_method_missing_with_unknown_method
+    #   assert_raises(NoMethodError) { @fcb.unknown_method }
+    # end
+  end
+end

data/lib/filter.rb

@@ -0,0 +1,181 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+module MarkdownExec
+  # Filter
+  #
+  # The Filter class provides utilities to determine the inclusion of fenced code blocks (FCB)
+  # based on a set of provided options. The primary function, `fcb_select?`, checks
+  # various properties of an FCB and decides whether to include or exclude it.
+  #
+  # :reek:UtilityFunction
+
+  class Filter
+    def self.fcb_select?(options, fcb)
+      filters = {
+        name_default: true,
+        name_exclude: nil,
+        name_select: nil,
+        shell_default: true,
+        shell_exclude: nil,
+        shell_select: nil,
+        hidden_name: nil
+      }
+
+      name = fcb.fetch(:name, '')
+      shell = fcb.fetch(:shell, '')
+
+      apply_name_filters(options, filters, name)
+      apply_shell_filters(options, filters, shell)
+      apply_other_filters(options, filters, fcb)
+
+      evaluate_filters(options, filters)
+    rescue StandardError => err
+      warn("ERROR ** Filter::fcb_select?(); #{err.inspect}")
+      raise err
+    end
+
+    def self.apply_name_filters(options, filters, name)
+      if name.present? && options[:block_name]
+        if name =~ /#{options[:block_name]}/
+          filters[:name_select] = true
+          filters[:name_exclude] = false
+        else
+          filters[:name_exclude] = true
+          filters[:name_select] = false
+        end
+      end
+
+      if name.present? && filters[:name_select].nil? && options[:select_by_name_regex].present?
+        filters[:name_select] = !!(name =~ /#{options[:select_by_name_regex]}/)
+      end
+
+      unless name.present? && filters[:name_exclude].nil? && options[:exclude_by_name_regex].present?
+        return
+      end
+
+      filters[:name_exclude] = !!(name =~ /#{options[:exclude_by_name_regex]}/)
+    end
+
+    def self.apply_shell_filters(options, filters, shell)
+      filters[:shell_expect] = shell == 'expect'
+
+      if shell.present? && options[:select_by_shell_regex].present?
+        filters[:shell_select] = !!(shell =~ /#{options[:select_by_shell_regex]}/)
+      end
+
+      return unless shell.present? && options[:exclude_by_shell_regex].present?
+
+      filters[:shell_exclude] = !!(shell =~ /#{options[:exclude_by_shell_regex]}/)
+    end
+
+    def self.apply_other_filters(options, filters, fcb)
+      name = fcb.fetch(:name, '')
+      shell = fcb.fetch(:shell, '')
+      filters[:fcb_chrome] = fcb.fetch(:chrome, false)
+
+      if name.present? && options[:hide_blocks_by_name] &&
+         options[:block_name_hidden_match].present?
+        filters[:hidden_name] = !!(name =~ /#{options[:block_name_hidden_match]}/)
+      end
+
+      if shell.present? && options[:hide_blocks_by_shell] &&
+         options[:block_shell_hidden_match].present?
+        !!(shell =~ /#{options[:block_shell_hidden_match]}/)
+      end
+
+      return unless options[:bash_only]
+
+      filters[:shell_default] = (shell == 'bash')
+    end
+
+    def self.evaluate_filters(options, filters)
+      if options[:no_chrome] && filters[:fcb_chrome]
+        false
+      elsif options[:exclude_expect_blocks] && filters[:shell_expect]
+        false
+      elsif filters[:hidden_name] == true
+        true
+      elsif filters[:name_exclude] == true || filters[:shell_exclude] == true || filters[:name_select] == false || filters[:shell_select] == false
+        false
+      elsif filters[:name_select] == true || filters[:shell_select] == true
+        true
+      elsif filters[:name_default] == false || filters[:shell_default] == false
+        false
+      else
+        true
+      end
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require 'minitest/autorun'
+
+  require_relative 'tap'
+  include Tap
+
+  class FilterTest < Minitest::Test
+    def test_no_chrome_condition
+      options = { no_chrome: true }
+      fcb = { chrome: true }
+      refute MarkdownExec::Filter.fcb_select?(options, fcb)
+    end
+
+    def test_exclude_expect_blocks_condition
+      options = { exclude_expect_blocks: true }
+      fcb = { shell: 'expect' }
+      refute MarkdownExec::Filter.fcb_select?(options, fcb)
+    end
+
+    def test_hidden_name_condition
+      options = { hide_blocks_by_name: true, block_name_hidden_match: 'hidden' }
+      fcb = { name: 'hidden_block' }
+      assert MarkdownExec::Filter.fcb_select?(options, fcb)
+    end
+
+    def test_name_exclude_condition
+      options = { block_name: 'test' }
+      fcb = { name: 'sample' }
+      refute MarkdownExec::Filter.fcb_select?(options, fcb)
+    end
+
+    def test_shell_exclude_condition
+      options = { exclude_by_shell_regex: 'exclude_this' }
+      fcb = { shell: 'exclude_this_shell' }
+      refute MarkdownExec::Filter.fcb_select?(options, fcb)
+    end
+
+    def test_name_select_condition
+      options = { select_by_name_regex: 'select' }
+      fcb = { name: 'select_this' }
+      assert MarkdownExec::Filter.fcb_select?(options, fcb)
+    end
+
+    def test_shell_select_condition
+      options = { select_by_shell_regex: 'select_this' }
+      fcb = { shell: 'select_this_shell' }
+      assert MarkdownExec::Filter.fcb_select?(options, fcb)
+    end
+
+    def test_bash_only_condition_true
+      options = { bash_only: true }
+      fcb = { shell: 'bash' }
+      assert MarkdownExec::Filter.fcb_select?(options, fcb)
+    end
+
+    def test_bash_only_condition_false
+      options = { bash_only: true }
+      fcb = { shell: 'zsh' }
+      refute MarkdownExec::Filter.fcb_select?(options, fcb)
+    end
+
+    def test_default_case
+      options = {}
+      fcb = {}
+      assert MarkdownExec::Filter.fcb_select?(options, fcb)
+    end
+  end
+end

data/lib/markdown_block_manager.rb

@@ -0,0 +1,195 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+require_relative 'filter'
+
+module MarkdownExec
+  ##
+  # MarkdownBlockManager represents an imported markdown document.
+  #
+  # It provides methods to extract and manipulate specific sections
+  # of the document, such as code blocks. It also supports recursion
+  # to fetch related or dependent blocks.
+  #
+  class MarkdownBlockManager
+    attr_reader :block_table
+
+    def initialize(block_table)
+      @block_table = block_table
+    end
+
+    def collect_required_code(name)
+      gather_required_blocks(name)
+        .map do |block|
+        process_block_code(block)
+      end.flatten(1)
+    end
+
+    def get_block(name, default = {})
+      @block_table.select { |block| block.fetch(:name, '') == name }.fetch(0, default)
+    end
+
+    def gather_required_blocks(name)
+      named_block = get_block(name)
+      if named_block.nil? || named_block.keys.empty?
+        raise "Named code block `#{name}` not found."
+      end
+
+      all_blocks = [named_block.fetch(:name, '')] + required_blocks(named_block[:reqs])
+      @block_table.select { |block| all_blocks.include? block.fetch(:name, '') }
+                  .map do |block|
+        process_block_references(block)
+      end.flatten(1)
+    end
+
+    def hide_block_given_options(opts, block)
+      (opts[:hide_blocks_by_name] &&
+       block[:name]&.match(Regexp.new(opts[:block_name_hidden_match])) &&
+       (block[:name]&.present? || block[:label]&.present?)
+      )
+    end
+
+    def blocks_per_options(opts = {})
+      filtered_blocks = @block_table.select do |block_group|
+        Filter.block_selected? opts, block_group
+      end
+      if opts[:hide_blocks_by_name]
+        filtered_blocks.reject { |block| hide_block_given_options opts, block }
+      else
+        filtered_blocks
+      end.map do |block|
+        block
+      end
+    end
+
+    def required_blocks(reqs)
+      return [] unless reqs
+
+      remaining = reqs
+      collected = []
+      while remaining.count.positive?
+        remaining = remaining.map do |req|
+          next if collected.include? req
+
+          collected += [req]
+          get_block(req).fetch(:reqs, [])
+        end
+                             .compact
+                             .flatten(1)
+      end
+      collected
+    end
+
+    # Helper method to process block code
+    def process_block_code(block)
+      body = block[:body].join("\n")
+
+      if block[:cann]
+        xcall = block[:cann][1..-2]
+        mstdin = xcall.match(/<(?<type>\$)?(?<name>[A-Za-z_\-.\w]+)/)
+        mstdout = xcall.match(/>(?<type>\$)?(?<name>[A-Za-z_\-.\w]+)/)
+
+        yqcmd = if mstdin[:type]
+                  "echo \"$#{mstdin[:name]}\" | yq '#{body}'"
+                else
+                  "yq e '#{body}' '#{mstdin[:name]}'"
+                end
+        if mstdout[:type]
+          "export #{mstdout[:name]}=$(#{yqcmd})"
+        else
+          "#{yqcmd} > '#{mstdout[:name]}'"
+        end
+      elsif block[:stdout]
+        stdout = block[:stdout]
+        body = block[:body].join("\n")
+        if stdout[:type]
+          %(export #{stdout[:name]}=$(cat <<"EOF"\n#{body}\nEOF\n))
+        else
+          "cat > '#{stdout[:name]}' <<\"EOF\"\n" \
+            "#{body}\n" \
+            "EOF\n"
+        end
+      else
+        block[:body]
+      end
+    end
+
+    # Helper method to process block references
+    def process_block_references(block)
+      if (call = block[:call])
+        [get_block("[#{call.match(/^%\((\S+) |\)/)[1]}]")
+          .merge({ cann: call })]
+      else
+        []
+      end + [block]
+    end
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  # require 'bundler/setup'
+  # Bundler.require(:default)
+
+  require 'minitest/autorun'
+
+  require_relative 'tap'
+  include Tap
+
+  module MarkdownExec
+    class TestMDoc < Minitest::Test
+      def setup
+        @table = [
+          { name: 'block1', body: ['code for block1'], reqs: ['block2'] },
+          { name: 'block2', body: ['code for block2'], reqs: nil },
+          { name: 'block3', body: ['code for block3'], reqs: ['block1'] }
+        ]
+        @doc = MDoc.new(@table)
+      end
+
+      def test_collect_recursively_required_code
+        result = @doc.collect_recursively_required_code('block1')
+        expected_result = @table[0][:body] + @table[1][:body]
+        assert_equal expected_result, result
+      end
+
+      def test_get_block_by_name
+        result = @doc.get_block_by_name('block1')
+        assert_equal @table[0], result
+
+        result_missing = @doc.get_block_by_name('missing_block')
+        assert_equal({}, result_missing)
+      end
+
+      def test_get_required_blocks
+        result = @doc.get_required_blocks('block3')
+        expected_result = [@table[0], @table[1], @table[2]]
+        assert_equal expected_result, result
+
+        assert_raises(RuntimeError) { @doc.get_required_blocks('missing_block') }
+      end
+
+      def test_hide_menu_block_per_options
+        opts = { hide_blocks_by_name: true, block_name_hidden_match: 'block1' }
+        block = { name: 'block1' }
+        result = @doc.hide_menu_block_per_options(opts, block)
+        assert result # this should be true based on the given logic
+      end
+
+      def test_fcbs_per_options
+        opts = { hide_blocks_by_name: true, block_name_hidden_match: 'block1' }
+        result = @doc.fcbs_per_options(opts)
+        assert_equal [@table[1], @table[2]], result
+      end
+
+      def test_recursively_required
+        result = @doc.recursively_required(['block3'])
+        assert_equal %w[block3 block1 block2], result
+
+        result_no_reqs = @doc.recursively_required(nil)
+        assert_equal [], result_no_reqs
+      end
+    end
+  end
+end

data/lib/markdown_exec/version.rb

@@ -7,5 +7,5 @@ module MarkdownExec
   BIN_NAME = 'mde'
   GEM_NAME = 'markdown_exec'
   TAP_DEBUG = 'MDE_DEBUG'
-  VERSION = '1.3.3.4'
+  VERSION = '1.3.6'
 end