markdown_exec 1.3.1 → 1.3.3.1

data/Rakefile

@@ -30,10 +30,10 @@ require_relative 'lib/tap'
 include CLI
 
 include Tap
-tap_config envvar: MarkdownExec::TAP_DEBUG
 
 RuboCop::RakeTask.new do |task|
   task.requires << 'rubocop-minitest'
+  task.requires << 'rubocop-rspec'
 end
 
 desc 'named task because minitest not included in rubocop tests'
@@ -42,7 +42,7 @@ task :rubocopminitest do
 end
 
 task default: %i[test reek rubocop rubocopminitest]
-# task default: %i[spec test reek rubocop rubocopminitest]
+# task default: %i[rspec test reek rubocop rubocopminitest]
 
 # task :default => :build
 
@@ -73,6 +73,12 @@ task :clean do
   system 'rm *.gem'
 end
 
+desc 'minitest'
+task :minitest do
+  puts `bundle exec ruby ./lib/object_present.rb`
+  puts `bundle exec ruby ./lib/cached_nested_file_reader.rb`
+end
+
 desc 'reek'
 task :reek do
   `reek --config .reek .`
@@ -237,15 +243,58 @@ task :update_menu_yml do
 
     ## secondary options
     #
+    {
+      arg_name: 'BOOL',
+      default: false,
+      description: 'Display only blocks of type "bash"',
+      env_var: 'MDE_BASH_ONLY',
+      opt_name: 'bash_only',
+      procname: 'val_as_bool'
+    },
     {
       arg_name: "INT.#{DISPLAY_LEVEL_BASE}-#{DISPLAY_LEVEL_MAX}",
       default: DISPLAY_LEVEL_DEFAULT,
-      description: "Output display level (#{DISPLAY_LEVEL_BASE} to #{DISPLAY_LEVEL_MAX} [data, +context, +info])",
+      description: 'Output display level ' \
+                   "(#{DISPLAY_LEVEL_BASE} to #{DISPLAY_LEVEL_MAX} " \
+                   '[data, +context, +info])',
       env_var: 'MDE_DISPLAY_LEVEL',
       long_name: 'display-level',
       opt_name: 'display_level',
       procname: 'val_as_int'
     },
+    {
+      arg_name: 'REGEX',
+      default: nil,
+      description: 'Exclude blocks with name matching',
+      env_var: 'MDE_EXCLUDE_BY_NAME_REGEX',
+      opt_name: 'exclude_by_name_regex',
+      procname: 'val_as_str'
+    },
+    {
+      arg_name: 'REGEX',
+      default: nil,
+      description: 'Exclude blocks with shell matching',
+      env_var: 'MDE_EXCLUDE_BY_SHELL_REGEX',
+      opt_name: 'exclude_by_shell_regex',
+      procname: 'val_as_str'
+    },
+    {
+      arg_name: 'BOOL',
+      default: true,
+      description: 'Hide all blocks of type "expect"',
+      env_var: 'MDE_EXCLUDE_EXPECT_BLOCKS',
+      opt_name: 'exclude_expect_blocks',
+      procname: 'val_as_bool'
+    },
+    {
+      arg_name: 'BOOL',
+      default: true,
+      description: 'Exclude blocks with name matching expression " \
+       "`block_name_hidden_match`',
+      env_var: 'MDE_HIDE_BLOCKS_BY_NAME',
+      opt_name: 'hide_blocks_by_name',
+      procname: 'val_as_bool'
+    },
     {
       arg_name: 'INT.1-',
       default: 32,
@@ -260,7 +309,6 @@ task :update_menu_yml do
       default: MarkdownExec::BIN_NAME,
       description: 'Name prefix for stdout files',
       env_var: 'MDE_LOGGED_STDOUT_FILENAME_PREFIX',
-      # long_name: 'logged-stdout-filename-prefix',
       opt_name: 'logged_stdout_filename_prefix',
       procname: 'val_as_str'
     },
@@ -269,7 +317,6 @@ task :update_menu_yml do
       default: false,
       description: 'Display document name in block selection menu',
       env_var: 'MDE_MENU_BLOCKS_WITH_DOCNAME',
-      # long_name: 'menu-blocks-with-docname',
       opt_name: 'menu_blocks_with_docname',
       procname: 'val_as_bool'
     },
@@ -278,10 +325,25 @@ task :update_menu_yml do
       default: false,
       description: 'Display headings (levels 1,2,3) in block selection menu',
       env_var: 'MDE_MENU_BLOCKS_WITH_HEADINGS',
-      # long_name: 'menu-blocks-with-headings',
       opt_name: 'menu_blocks_with_headings',
       procname: 'val_as_bool'
     },
+    {
+      arg_name: 'BOOL',
+      default: true,
+      description: 'Display Exit option at top of menu',
+      env_var: 'MDE_MENU_EXIT_AT_TOP',
+      opt_name: 'menu_exit_at_top',
+      procname: 'val_as_bool'
+    },
+    {
+      arg_name: 'BOOL',
+      default: true,
+      description: 'Display Exit option in menu',
+      env_var: 'MDE_MENU_WITH_EXIT',
+      opt_name: 'menu_with_exit',
+      procname: 'val_as_bool'
+    },
     {
       arg_name: 'BOOL',
       default: false,
@@ -291,6 +353,14 @@ task :update_menu_yml do
       opt_name: 'output_execution_summary',
       procname: 'val_as_bool'
     },
+    {
+      arg_name: 'BOOL',
+      default: false,
+      description: 'Output saved script filename at end of execution',
+      env_var: 'MDE_OUTPUT_SAVED_SCRIPT_FILENAME',
+      opt_name: 'output_saved_script_filename',
+      procname: 'val_as_bool'
+    },
     {
       arg_name: 'BOOL',
       default: false,
@@ -332,7 +402,6 @@ task :update_menu_yml do
       default: 0o755,
       description: 'chmod for saved scripts',
       env_var: 'MDE_SAVED_SCRIPT_CHMOD',
-      # long_name: 'saved-script-chmod',
       opt_name: 'saved_script_chmod',
       procname: 'val_as_int'
     },
@@ -341,7 +410,6 @@ task :update_menu_yml do
       default: MarkdownExec::BIN_NAME,
       description: 'Name prefix for saved scripts',
       env_var: 'MDE_SAVED_SCRIPT_FILENAME_PREFIX',
-      # long_name: 'saved-script-filename-prefix',
       opt_name: 'saved_script_filename_prefix',
       procname: 'val_as_str'
     },
@@ -359,7 +427,6 @@ task :update_menu_yml do
       default: 'mde_*.sh',
       description: 'Glob matching saved scripts',
       env_var: 'MDE_SAVED_SCRIPT_GLOB',
-      # long_name: 'saved-script-glob',
       opt_name: 'saved_script_glob',
       procname: 'val_as_str'
     },
@@ -377,11 +444,25 @@ task :update_menu_yml do
       default: 'mde_*.out.txt',
       description: 'Glob matching saved outputs',
       env_var: 'MDE_SAVED_STDOUT_GLOB',
-      # long_name: 'saved-stdout-glob',
       opt_name: 'saved_stdout_glob',
       procname: 'val_as_str'
     },
-
+    {
+      arg_name: 'REGEX',
+      default: nil,
+      description: 'Select blocks with name matching',
+      env_var: 'MDE_SELECT_BY_NAME_REGEX',
+      opt_name: 'select_by_name_regex',
+      procname: 'val_as_str'
+    },
+    {
+      arg_name: 'REGEX',
+      default: nil,
+      description: 'Select blocks with shell matching',
+      env_var: 'MDE_SELECT_BY_SHELL_REGEX',
+      opt_name: 'select_by_shell_regex',
+      procname: 'val_as_str'
+    },
     {
       default: '^[\(\[].*[\)\]]$',
       description: 'Pattern for blocks to hide from user-selection',
@@ -408,13 +489,13 @@ task :update_menu_yml do
       procname: 'val_as_str'
     },
     {
-      default: '<(?<full>(?<type>\$)?(?<name>[A-Za-z]\S*))',
+      default: '<(?<full>(?<type>\$)?(?<name>[A-Za-z_\-\.\w]+))',
       env_var: 'MDE_BLOCK_STDIN_SCAN',
       opt_name: 'block_stdin_scan',
       procname: 'val_as_str'
     },
     {
-      default: '>(?<full>(?<type>\$)?(?<name>[A-Za-z]\S*))',
+      default: '>(?<full>(?<type>\$)?(?<name>[A-Za-z_\-\.\w]+))',
       env_var: 'MDE_BLOCK_STDOUT_SCAN',
       opt_name: 'block_stdout_scan',
       procname: 'val_as_str'
@@ -432,7 +513,7 @@ task :update_menu_yml do
       procname: 'val_as_str'
     },
     {
-      default: '^`{3,}(?<shell>[^`\s]*) *(?<name>.*)$',
+      default: '^`{3,}(?<shell>[^`\s]*) *:?(?<name>[^\s]*) *(?<rest>.*) *$',
       env_var: 'MDE_FENCED_START_EX_MATCH',
       opt_name: 'fenced_start_ex_match',
       procname: 'val_as_str'
@@ -455,6 +536,12 @@ task :update_menu_yml do
       opt_name: 'heading3_match',
       procname: 'val_as_str'
     },
+    {
+      default: '^ *@import (.+)$',
+      env_var: 'MDE_IMPORT_PATTERN',
+      opt_name: 'import_pattern',
+      procname: 'val_as_str'
+    },
     {
       default: '*.[Mm][Dd]',
       env_var: 'MDE_MD_FILENAME_GLOB',
@@ -605,18 +692,12 @@ task :update_menu_yml do
       env_var: 'MDE_OUTPUT_DIVIDER_COLOR',
       opt_name: 'output_divider_color',
       procname: 'val_as_str'
-      # },
-      # {
-      #   default: '',
-      #   description: '',
-      #   env_var: 'MDE_PROMPT_',
-      #   opt_name: 'prompt_',
-      #   procname: 'val_as_str'
     }
   ]
 
   File.write(MENU_YML,
-             "# #{MarkdownExec::APP_NAME} - #{MarkdownExec::APP_DESC} (#{MarkdownExec::VERSION})\n" +
+             "# #{MarkdownExec::APP_NAME} - #{MarkdownExec::APP_DESC} " \
+             "(#{MarkdownExec::VERSION})\n" +
               menu_options.to_yaml)
   puts `stat #{MENU_YML}`
 end
@@ -630,10 +711,13 @@ def update_tab_completion(target)
 
   svhs = YAML.load File.open(MENU_YML)
   svhs.each do |svh|
-    svh[:compreply] = CLI::value_for_cli(svh[:default]) if svh[:compreply].nil?
+    svh[:compreply] = CLI.value_for_cli(svh[:default]) if svh[:compreply].nil?
   end.tap_inspect name: :svhs, type: :yaml
 
-  File.write target, ERB.new(File.read(filespec = File.join(BF, 'tab_completion.sh.erb'))).result(binding)
+  File.write target,
+             ERB.new(File.read(filespec = File.join(BF,
+                                                    'tab_completion.sh.erb')))
+                .result(binding)
   puts `stat #{filespec}`
 end
 

data/bin/tab_completion.sh

@@ -13,7 +13,7 @@ __filedirs_all()
 }
 
 _mde_echo_version() {
-  echo "1.3.1"
+  echo "1.3.3.1"
 }
 
 _mde() {
@@ -138,4 +138,4 @@ _mde() {
 
 complete -o filenames -o nospace -F _mde mde
 # _mde_echo_version
-# echo "Updated: 2022-10-29 23:24:15 UTC"
+# echo "Updated: 2023-10-04 01:23:26 UTC"

data/lib/cached_nested_file_reader.rb

@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+# version 2023-10-03
+
+require 'bundler/setup'
+Bundler.require(:default)
+
+##
+# The CachedNestedFileReader class provides functionality to read file lines with the ability
+# to process '#import filename' directives. When such a directive is encountered in a file,
+# the corresponding 'filename' is read and its contents are inserted at that location.
+# This class caches read files to avoid re-reading the same file multiple times.
+# It allows clients to read lines with or without providing a block.
+#
+class CachedNestedFileReader
+  def initialize(import_pattern: /^ *#import (.+)$/)
+    @file_cache = {}
+    @import_pattern = import_pattern
+  end
+
+  def readlines(filename, &block)
+    if @file_cache.key?(filename)
+      @file_cache[filename].each(&block) if block_given?
+      return @file_cache[filename]
+    end
+
+    directory_path = File.dirname(filename)
+    lines = File.readlines(filename, chomp: true)
+    processed_lines = []
+
+    lines.each do |line|
+      if (match = line.match(@import_pattern))
+        included_file_path = if match[1].strip.match %r{^/}
+                               match[1].strip
+                             else
+                               File.join(directory_path, match[1].strip)
+                             end
+        processed_lines += readlines(included_file_path, &block)
+      else
+        processed_lines.push(line)
+        yield line if block_given?
+      end
+    end
+
+    @file_cache[filename] = processed_lines
+  end
+
+  private
+
+  def fetch_lines(filename)
+    @fetch_lines_cache[filename] ||= File.readlines(filename, chomp: true)
+  end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require 'minitest/autorun'
+  require 'tempfile'
+
+  ##
+  # The CachedNestedFileReaderTest class provides testing for
+  # the CachedNestedFileReader class.
+  #
+  class CachedNestedFileReaderTest < Minitest::Test
+    def setup
+      @file2 = Tempfile.new('test2.txt')
+      @file2.write("ImportedLine1\nImportedLine2")
+      @file2.rewind
+
+      @file1 = Tempfile.new('test1.txt')
+      @file1.write("Line1\nLine2\n #insert #{@file2.path}\nLine3")
+      @file1.rewind
+      # binding.pry
+      @reader = CachedNestedFileReader.new(import_pattern: /^ *#insert (.+)$/)
+    end
+
+    def teardown
+      @file1.close
+      @file1.unlink
+
+      @file2.close
+      @file2.unlink
+    end
+
+    def test_readlines_without_imports
+      result = []
+      @reader.readlines(@file2.path) { |line| result << line }
+      assert_equal %w[ImportedLine1 ImportedLine2], result
+    end
+
+    def test_readlines_with_imports
+      result = []
+      @reader.readlines(@file1.path) { |line| result << line }
+      assert_equal %w[Line1 Line2 ImportedLine1 ImportedLine2 Line3], result
+    end
+
+    def test_caching_functionality
+      # First read
+      result1 = []
+      @reader.readlines(@file2.path) { |line| result1 << line }
+
+      # Simulate file content change
+      @file2.reopen(@file2.path, 'w') { |f| f.write('ChangedLine') }
+
+      # Second read (should read from cache, not the changed file)
+      result2 = []
+      @reader.readlines(@file2.path) { |line| result2 << line }
+
+      assert_equal result1, result2
+      assert_equal %w[ImportedLine1 ImportedLine2], result2
+    end
+  end
+end

data/lib/colorize.rb

@@ -14,6 +14,10 @@
 # │   │                       │
 # │5  │ for flashing text
 class String
+  def plain
+    self
+  end
+
   def black
     "\033[30m#{self}\033[0m"
   end

data/lib/env.rb

@@ -10,17 +10,22 @@ module Env
   # :reek:NilCheck
   # :reek:UtilityFunction
   def env_bool(name, default: false)
-    return default if name.nil? || (val = ENV[name]).nil?
+    return default if name.nil? || (val = ENV.fetch(name, nil)).nil?
     return false if val.empty? || val == '0'
 
     true
   end
 
+  # :reek:UtilityFunction
+  def env_bool_false(name)
+    !(val = (name && ENV.fetch(name, nil))).nil? && !(val.empty? || val == '0')
+  end
+
   # skip :reek:DataClump
   # skip :reek:NilCheck
   # skip :reek:UtilityFunction
   def env_int(name, default: 0)
-    return default if name.nil? || (val = ENV[name]).nil?
+    return default if name.nil? || (val = ENV.fetch(name, nil)).nil?
     return default if val.empty?
 
     val.to_i
@@ -30,7 +35,7 @@ module Env
   # skip :reek:NilCheck
   # skip :reek:UtilityFunction
   def env_str(name, default: '')
-    return default if name.nil? || (val = ENV[name]).nil?
+    return default if name.nil? || (val = ENV.fetch(name, nil)).nil?
 
     val || default
   end

data/lib/env_opts.rb

@@ -0,0 +1,242 @@
+# 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, '') #.tap_inspect 'argument', source: 'EnvOpts'
+      if arg.start_with? '--'
+        opt_name = arg[2..-1] #.tap_inspect 'opt_name', source: 'EnvOpts'
+        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('_', '-') #.tap_inspect
+  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) #.tap_inspect
+  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('_', '-') #.tap_inspect
+  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 #.tap_inspect "ref #{method_name}", source: 'EnvOpts'
+  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