markdown_exec 1.3.7 → 1.3.9

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown_exec
 version: !ruby/object:Gem::Version
-  version: 1.3.7
+  version: 1.3.9
 platform: ruby
 authors:
 - Fareed Stevenson
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-16 00:00:00.000000000 Z
+date: 2023-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clipboard
@@ -105,28 +105,39 @@ files:
 - assets/output_of_execution.png
 - assets/select_a_block.png
 - assets/select_a_file.png
+- bin/colorize_env_vars.sh
 - bin/console
 - bin/mde
 - bin/setup
 - bin/tab_completion.sh
 - bin/tab_completion.sh.erb
+- examples/duplicate_block.md
+- examples/import0.md
+- examples/import1.md
+- examples/include.md
+- examples/infile_config.md
+- examples/linked1.md
+- examples/linked2.md
+- examples/opts.md
+- examples/pass-through.md
+- examples/plant.md
+- examples/port.md
+- examples/vars.md
+- examples/wrap.md
 - lib/block_label.rb
+- lib/block_types.rb
 - lib/cached_nested_file_reader.rb
 - lib/cli.rb
 - lib/colorize.rb
 - lib/env.rb
-- lib/env_opts.rb
 - lib/environment_opt_parse.rb
 - lib/fcb.rb
 - lib/filter.rb
-- lib/markdown_block_manager.rb
 - lib/markdown_exec.rb
 - lib/markdown_exec/version.rb
 - lib/mdoc.rb
 - lib/menu.src.yml
 - lib/menu.yml
-- lib/menu_options.rb
-- lib/menu_options.yml
 - lib/object_present.rb
 - lib/option_value.rb
 - lib/regexp.rb

data/lib/env_opts.rb

@@ -1,242 +0,0 @@
-# frozen_string_literal: true
-
-# encoding=utf-8
-
-require_relative 'tap'
-
-include Tap #; tap_config
-
-# define options with initial values
-# option to read value from environmnt variables
-# option to cast input values
-# value priority: default < environment < argument
-#
-# :reek:TooManyMethods
-class EnvOpts
-  attr_reader :opts, :values
-
-  def initialize(opts_raw = {}, argv = ARGV)
-    @opts = {}
-    @values = {}
-    add_options(opts_raw)
-    # parse(argv, &block) if block_given?
-    block_given? ? parse(argv, &block) : parse(argv)
-
-    self # rubocop:disable Lint/Void
-  end
-
-  # add options to menu
-  # calculate help text
-  #
-  # :reek:NestedIterators
-  def add_options(opts_raw)
-    return self if opts_raw.nil?
-
-    help_rows = opts_raw.map do |key, opt_raw|
-      opt_name = key_name_to_option_name(key)
-
-      # set_per_options(opt_name, opt_raw)
-      @opts[opt_name] = (opt_raw ||= {})
-      set_key_value_as_cast(opt_name, EnvOpts.optdefault(opt_raw))
-      set_key_value_per_environment_as_cast(opt_name, opt_raw)
-
-      [
-        [20, '-', "--#{opt_name}"],
-        [16, '-',
-         if @opts[opt_name][:env].present?
-           option_name_to_environment_name(opt_name, @opts[opt_name])
-         else
-           ''
-         end],
-        # [24, '-', get_environment_value_from_option(opt_name, @opts[opt_name])],
-        [24, '-', @opts[opt_name][:default]],
-        [6, '-', if (fixed = opt_raw.fetch(:fixed, nil)).nil?
-                   ":#{option_cast(@opts[opt_name])}"
-                 else
-                   fixed.to_s
-                 end]
-      ]
-    end
-
-    max_widths = help_rows.reduce([0, 0, 0, 0]) do |memo, vals|
-      vals.map.with_index do |val, ind|
-        [memo[ind], val[2].to_s.length].max
-      end
-    end
-
-    @values['help'] = help_rows.map do |row|
-      row.map.with_index do |cell, ind|
-        format("%#{cell[1]}#{max_widths[ind]}s", cell[2])
-      end.join('  ')
-    end.join("\n")
-
-    self
-  end
-
-  # accept :d or :default option
-  #
-  def self.optdefault(opt_raw)
-    return opt_raw[:d] unless opt_raw[:d].nil?
-
-    opt_raw[:default]
-  end
-
-  def output_help
-    puts @values['help']
-  end
-
-  # process arguments as mostly pairs of option name and value
-  #
-  def parse(argv = ARGV)
-    return self if argv.nil? || !(argv&.count || 0).positive?
-
-    args_ind = 0
-    while args_ind < argv.count
-      args_consumed = 0
-      arg = argv.fetch(args_ind, '')
-      if arg.start_with? '--'
-        opt_name = arg[2..-1]
-        args_consumed = consume_arguments(opt_name,
-                                          argv.fetch(args_ind + 1, nil))
-      end
-
-      if args_consumed.zero?
-        if arg == '--help'
-          output_help
-          exit
-        elsif block_given?
-          yield 'NAO', [arg]
-          args_consumed = 1
-        else
-          warn "Invalid argument: #{arg.inspect} in #{argv.inspect}"
-          exit 1
-        end
-      end
-
-      args_ind += args_consumed
-    end
-
-    self
-  end
-
-  # set option current values per environment values
-  #
-  def options_per_environment_as_cast(opts_raw)
-    return self if opts_raw.nil?
-
-    opts_raw.each do |key, opt_raw|
-      set_key_value_per_environment_as_cast(key_name_to_option_name(key),
-                                            opt_raw)
-    end
-
-    self
-  end
-
-  # symbol name to option name
-  # option names use hyphens
-  #
-  def self.symbol_name_to_option_name(name)
-    name.to_s.gsub('_', '-')
-  end
-
-  private
-
-  # 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)
-  end
-
-  # get cast of environment variable
-  #
-  def option_cast(opt_raw)
-    (opt_raw[:cast].present? ? opt_raw[:cast].to_s : 'to_s')
-  end
-
-  # update value for named option
-  # return number of arguments used
-  #
-  def consume_arguments(opt_name, value)
-    return 0 if (opt_raw = @opts.fetch(opt_name, nil)).nil?
-
-    return 0 unless opt_raw.fetch(:option, true)
-
-    if !(fixed = opt_raw.fetch(:fixed, nil)).nil?
-      set_key_value_as_cast(opt_name, fixed)
-      1
-    elsif value.nil?
-      0
-    else
-      set_key_value_as_cast(opt_name, value)
-      2
-    end
-  end
-
-  # option names use hyphens
-  #
-  def method_name_to_option_name(name)
-    name.to_s.gsub('_', '-')
-  end
-
-  # read and write options using the option name as a method
-  #
-  def method_missing(method_name, *args)
-    if method_name.to_s.end_with?('=')
-      value = args.first
-      name = method_name_to_option_name(method_name.to_s[0..-2])
-      set_key_value_as_cast(name, value)
-    else
-      @values[method_name_to_option_name(method_name)]
-    end
-  end
-
-  # option name to environment name
-  # if true or empty, compute from option name
-  #
-  def option_name_to_environment_name(opt_name, opt_raw)
-    case env_name = opt_raw.fetch(:env, '')
-    when true, ''
-      "#{@values['env-prefix']}#{opt_name.upcase.gsub('-', '_')}"
-    else
-      env_name
-    end
-  end
-
-  # get environment value from option
-  #
-  def get_environment_value_from_option(opt_name, opt_raw)
-    ENV.fetch(option_name_to_environment_name(opt_name, opt_raw),
-              nil)
-  end
-
-  # option names are available as methods
-  #
-  # :reek:BooleanParameter
-  def respond_to_missing?(method_name, include_private = false)
-    (@opts.keys.include?(method_name_to_option_name(method_name)) || super)
-  end
-
-  def set_key_value_as_cast(key, value)
-    opt = @opts[key]
-    set_key_value_raw(key, (opt[:cast] ? value.send(opt[:cast]) : value))
-  end
-
-  # set key value_per environment as cast
-  #
-  def set_key_value_per_environment_as_cast(key, opt_raw)
-    return if opt_raw[:env].nil?
-
-    value = get_environment_value_from_option(key, opt_raw)
-
-    return unless value
-
-    set_key_value_as_cast(key,
-                          opt_raw[:cast] ? value.send(opt_raw[:cast]) : value)
-  end
-
-  # set key value (raw)
-  #
-  def set_key_value_raw(key, value)
-    @values[key] = value
-  end
-end

data/lib/markdown_block_manager.rb

@@ -1,195 +0,0 @@
-#!/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