markdown_exec 1.6 → 1.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97323ce7d6c677603ca89432c9ca64e45ff205a5b6cc03a71f4be1210bf8104a
-  data.tar.gz: ccce852fe96571b00c4443012371ea5ad29caec29dfdc9649cec7da2c091defe
+  metadata.gz: 97045160c53b7dca3998f6d700bf136f500826141d226f9f2cc650d15e6d1ba7
+  data.tar.gz: c69c23b07fcb3304d0209f79596619fbe54d0c2bb9a03f94c8598e3358c25ed7
 SHA512:
-  metadata.gz: bc08d47d135d9a078240c6e3001322ec8b35b8fb4f7febeabec02729240d7524a40464d9d563aeb15e5c8d09695bd0b512251d970dfede46cf07bd377af72181
-  data.tar.gz: ec61f969d204b0216c02e2e13d270363aef35ecf3ad6ff5a26d653e2d5c8f1608ff3e70a24ab65ab3bd48d8c546e1a6c627734c8e03e08a2440c18b1d9db7fed
+  metadata.gz: a525dc3c727c38aba2d52382871650b6d2636891028a6def27f8958fcd78ae46afcb8fbbeb0f1bfdb0d550beb22c7cc90c67744c52143490f0a27c75c9158442
+  data.tar.gz: ae304dc41d17d2763a17b518da50956f0271ca401a4bc78929200eeb17ab3d19dfd148db76f104aed8216120c38673d19c9e56af018d3c9d83534c8901cc0915

data/.rubocop.yml

@@ -14,7 +14,7 @@ Layout/LineContinuationLeadingSpace:
   Enabled: false
 
 Layout/LineLength:
-  Max: 72
+  Max: 78
   # Max: 80
   # Max: 96
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    markdown_exec (1.6)
+    markdown_exec (1.7)
       clipboard (~> 1.3.6)
       open3 (~> 0.1.1)
       optparse (~> 0.1.1)

data/Rakefile

@@ -81,6 +81,7 @@ task :minitest do
     './lib/cached_nested_file_reader.rb',
     './lib/fcb.rb',
     './lib/filter.rb',
+    './lib/hash_delegator.rb',
     './lib/markdown_exec.rb',
     './lib/mdoc.rb',
     './lib/object_present.rb',

data/bin/tab_completion.sh

@@ -13,7 +13,7 @@ __filedirs_all()
 }
 
 _mde_echo_version() {
-  echo "1.6"
+  echo "1.7"
 }
 
 _mde() {
@@ -138,4 +138,4 @@ _mde() {
 
 complete -o filenames -o nospace -F _mde mde
 # _mde_echo_version
-# echo "Updated: 2023-11-13 16:19:21 UTC"
+# echo "Updated: 2023-12-01 18:34:38 UTC"

data/examples/import0.md

@@ -1,8 +1,44 @@
-```bash :01
-01
-```
+This is Page 0
+
 @import import1.md
-```bash :03
-03
+
+```opts :(document_options)
+user_must_approve: true
+```
+
+::: Page 0 code blocks
+
+```bash :page0_block1 +(page0_block2) +(page1_block2)
+echo "page 0 block 1 visible"
+# requires page 0 block 2
+# imports page 1
+# requires page 1 block 2
+```
+
+```bash :(page0_block2)
+echo "page 0 block 2 hidden"
 ```
 
+::: Control display of code blocks
+
+```opts :hide_imported_blocks
+menu_include_imported_blocks: false
+```
+
+```opts :show_imported_blocks
+menu_include_imported_blocks: true
+```
+
+::: Control display of notes
+
+```opts :hide_imported_notes
+menu_include_imported_notes: false
+```
+
+```opts :show_imported_notes
+menu_include_imported_notes: true
+```
+
+```link :page_1
+file: examples/import1.md
+```

data/examples/import1.md

@@ -1,10 +1,11 @@
-```bash :11
-11
-```
-```bash :12
-12
-```
-```bash:13
-13
+This is Page 1
+
+::: Page 1 code blocks
+
+```bash :page1_block1
+echo "page 1 block 1 visible"
 ```
 
+```bash :(page1_block2)
+echo "page 1 block 2 hidden"
+```

data/examples/linked1.md

@@ -11,16 +11,20 @@ colorize_env_vars 'vars for page2' PAGE2_VAR_VIA_INHERIT page2_var_via_environme
 colorize_env_vars 'vars for page3' PAGE3_VAR_VIA_INHERIT page3_var_via_environment
 ```
 
+```bash :(vars2)
+PAGE2_VAR_VIA_INHERIT=for_page2_from_page1_via_inherited_code_file
+```
+
+```link :(linked2)
+file: examples/linked2.md
+```
+
 ::: This Link block
 ::: 1. requires a block that sets environment variable PAGE2_VAR_VIA_INHERIT,
 ::: 2. navigates to document 2, and
 ::: 3. executes block "show_vars" to display the imported PAGE2_VAR_VIA_INHERIT.
 ::: Any script generated by page 2 will contain the inherited code.
 
-```bash :(vars2)
-PAGE2_VAR_VIA_INHERIT=for_page2_from_page1_via_inherited_code_file
-```
-
 ```link :linked2_import_vars +(vars2)
 file: examples/linked2.md
 block: show_vars

data/lib/array.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+class Array
+  # Processes each element of the array, yielding the previous, current, and next elements to the given block.
+  # Deletes the current element if the block returns true.
+  # @return [Array] The modified array after conditional deletions.
+  def process_and_conditionally_delete!
+    i = 0
+    while i < length
+      prev_item = self[i - 1] unless i.zero?
+      current_item = self[i]
+      next_item = self[i + 1]
+
+      should_delete = yield prev_item, current_item, next_item
+      if should_delete
+        delete_at(i)
+      else
+        i += 1
+      end
+    end
+
+    self
+  end
+end

data/lib/array_util.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+module ArrayUtil
+  def self.partition_by_predicate(arr)
+    true_list = []
+    false_list = []
+
+    arr.each do |element|
+      if yield(element)
+        true_list << element
+      else
+        false_list << element
+      end
+    end
+
+    [true_list, false_list]
+  end
+end

data/lib/cached_nested_file_reader.rb

@@ -5,6 +5,16 @@
 
 # version 2023-10-03
 
+require 'fileutils'
+require_relative 'exceptions'
+
+# a struct to hold the data for a single line
+NestedLine = Struct.new(:text, :depth) do
+  def to_s
+    text
+  end
+end
+
 ##
 # 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,
@@ -13,42 +23,58 @@
 # It allows clients to read lines with or without providing a block.
 #
 class CachedNestedFileReader
+  include Exceptions
+
   def initialize(import_pattern: /^ *#import (.+)$/)
     @file_cache = {}
     @import_pattern = import_pattern
   end
 
-  def readlines(filename, &block)
+  def error_handler(name = '', opts = {})
+    Exceptions.error_handler(
+      "CachedNestedFileReader.#{name} -- #{$!}",
+      opts
+    )
+  end
+
+  def warn_format(name, message, opts = {})
+    Exceptions.warn_format(
+      "CachedNestedFileReader.#{name} -- #{message}",
+      opts
+    )
+  end
+
+  def readlines(filename, depth = 0, &block)
     if @file_cache.key?(filename)
-      @file_cache[filename].each(&block) if block_given?
+      @file_cache[filename].each(&block) if block
       return @file_cache[filename]
     end
 
     directory_path = File.dirname(filename)
-    lines = File.readlines(filename, chomp: true)
+    # 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
+    File.readlines(filename, chomp: true).each do |line|
+      if Regexp.new(@import_pattern) =~ line
+        name_strip = $~[:name].strip
+        included_file_path = if name_strip =~ %r{^/}
+                               name_strip
                              else
-                               File.join(directory_path, match[1].strip)
+                               File.join(directory_path, name_strip)
                              end
-        processed_lines += readlines(included_file_path, &block)
+        processed_lines += readlines(included_file_path, depth + 1,
+                                     &block)
       else
-        processed_lines.push(line)
-        yield line if block_given?
+        nested_line = NestedLine.new(line, depth)
+        processed_lines.push(nested_line)
+        block&.call(nested_line)
       end
     end
 
     @file_cache[filename] = processed_lines
-  end
-
-  private
-
-  def fetch_lines(filename)
-    @fetch_lines_cache[filename] ||= File.readlines(filename, chomp: true)
+  rescue Errno::ENOENT
+    # Exceptions.error_handler('readlines', { abort: true })
+    warn_format('readlines', "No such file -- #{filename}", { abort: true })
   end
 end
 
@@ -56,10 +82,6 @@ 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')
@@ -69,7 +91,7 @@ if $PROGRAM_NAME == __FILE__
       @file1 = Tempfile.new('test1.txt')
       @file1.write("Line1\nLine2\n #insert #{@file2.path}\nLine3")
       @file1.rewind
-      @reader = CachedNestedFileReader.new(import_pattern: /^ *#insert (.+)$/)
+      @reader = CachedNestedFileReader.new(import_pattern: /^ *#insert (?'name'.+)$/)
     end
 
     def teardown
@@ -81,28 +103,26 @@ if $PROGRAM_NAME == __FILE__
     end
 
     def test_readlines_without_imports
-      result = []
-      @reader.readlines(@file2.path) { |line| result << line }
+      result = @reader.readlines(@file2.path).map(&:to_s)
       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
+      result = @reader.readlines(@file1.path).map(&:to_s)
+      assert_equal %w[Line1 Line2 ImportedLine1 ImportedLine2 Line3],
+                   result
     end
 
     def test_caching_functionality
       # First read
-      result1 = []
-      @reader.readlines(@file2.path) { |line| result1 << line }
+
+      result1 = @reader.readlines(@file2.path).map(&:to_s)
 
       # 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 }
+      result2 = @reader.readlines(@file2.path).map(&:to_s)
 
       assert_equal result1, result2
       assert_equal %w[ImportedLine1 ImportedLine2], result2

data/lib/constants.rb

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+class ExecutionStreams
+  StdErr = :stderr
+  StdIn  = :stdin
+  StdOut = :stdout
+end
+
+class LoadFile
+  Load = true
+  Reuse = false
+end
+
+LoadFileNextBlock = Struct.new(:load_file, :next_block)
+
+class MenuControl
+  Fresh = false
+  Repeat = true
+end
+
+class MenuOptions
+  YES = 1
+  NO = 2
+  SCRIPT_TO_CLIPBOARD = 3
+  SAVE_SCRIPT = 4
+end
+
+class MenuState
+  BACK = :back
+  CONTINUE = :continue
+  EXIT = :exit
+end
+
+# selected block and subsequent menu state
+#
+SelectedBlockMenuState = Struct.new(:block, :state)
+
+SHELL_COLOR_OPTIONS = {
+  BlockType::BASH => :menu_bash_color,
+  BlockType::LINK => :menu_link_color,
+  BlockType::OPTS => :menu_opts_color,
+  BlockType::VARS => :menu_vars_color
+}.freeze

data/lib/env.rb

@@ -18,7 +18,8 @@ module Env
 
   # :reek:UtilityFunction
   def env_bool_false(name)
-    !(val = (name && ENV.fetch(name, nil))).nil? && !(val.empty? || val == '0')
+    !(val = (name && ENV.fetch(name,
+                               nil))).nil? && !(val.empty? || val == '0')
   end
 
   # skip :reek:DataClump

data/lib/exceptions.rb

@@ -0,0 +1,34 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+module Exceptions
+  def self.error_handler(name = '', opts = {}, format_string: "\nError: %{name} -- %{message}", color_symbol: :red, take_count: 16)
+    warn(error = format(format_string,
+                        { name: name, message: $! }).send(color_symbol))
+    warn($@.select do |s|
+           s.include? 'markdown_exec'
+         end.reject { |s| s.include? 'vendor' }.take(take_count).map.with_index { |line, ind| " *   #{ind}: #{line}" })
+
+    binding.pry if $tap_enable
+    raise ArgumentError, error unless opts.fetch(:abort, true)
+
+    exit 1
+  end
+
+  def self.warn_format(message = '', opts = {})
+    warn(
+      error = format(
+        opts.fetch(:format_string, "\nError: %{error}"),
+        { error: message }
+      ).send(opts.fetch(:color_symbol, :yellow))
+    )
+    # warn(caller.take(4).map.with_index { |line, ind| " *   #{ind}: #{line}" })
+
+    binding.pry if $tap_enable
+    raise ArgumentError, error unless opts.fetch(:abort, false)
+
+    exit 1
+  end
+end

data/lib/fcb.rb

@@ -19,6 +19,7 @@ module MarkdownExec
         call: nil,
         headings: [],
         dname: nil,
+        indent: '',
         name: nil,
         oname: nil,
         reqs: [],
@@ -29,6 +30,39 @@ module MarkdownExec
       }.merge(options)
     end
 
+    def title=(value)
+      @attrs[:title] = value
+    end
+
+    # Derives a title from the body of an FCB object.
+    # @param fcb [Object] The FCB object whose title is to be derived.
+    # @return [String] The derived title.
+    def derive_title_from_body
+      body_content = @attrs[:body]
+      unless body_content
+        @attrs[:title] = ''
+        return
+      end
+
+      @attrs[:title] = if body_content.count == 1
+                         body_content.first
+                       else
+                         format_multiline_body_as_title(body_content)
+                       end
+    end
+
+    private
+
+    # Formats multiline body content as a title string.
+    # indents all but first line with two spaces so it displays correctly in menu
+    # @param body_lines [Array<String>] The lines of body content.
+    # @return [String] Formatted title.
+    def format_multiline_body_as_title(body_lines)
+      body_lines.map.with_index do |line, index|
+        index.zero? ? line : "  #{line}"
+      end.join("\n") << "\n"
+    end
+
     # :reek:ManualDispatch
     def method_missing(method, *args, &block)
       method_name = method.to_s
@@ -48,7 +82,9 @@ module MarkdownExec
       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)
+    public
+
+    def respond_to_missing?(method_name, include_private = false)
       @attrs.key?(method_name.to_sym) || super
     end
 
@@ -63,6 +99,9 @@ module MarkdownExec
 end
 
 if $PROGRAM_NAME == __FILE__
+  require 'bundler/setup'
+  Bundler.require(:default)
+
   require 'minitest/autorun'
   require 'yaml'
 
@@ -73,6 +112,7 @@ if $PROGRAM_NAME == __FILE__
         call: 'Sample call',
         headings: %w[Header1 Header2],
         dname: 'Sample name',
+        indent: '',
         name: 'Sample name',
         oname: 'Sample name',
         reqs: %w[req1 req2],

data/lib/filter.rb

@@ -38,14 +38,18 @@ module MarkdownExec
       name = fcb.oname
       shell = fcb.fetch(:shell, '')
 
+      ### filter in menu, not in source code
+      filters[:depth] =
+        fcb.fetch(:depth,
+                  0).positive? && !options[:menu_include_imported_blocks]
       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
+    rescue StandardError
+      warn("ERROR ** Filter::fcb_select?(); #{$!.inspect}")
+      raise ArgumentError, $!
     end
 
     # Applies name-based filters to determine whether to include or
@@ -68,14 +72,16 @@ module MarkdownExec
       end
 
       if name.present? && filters[:name_select].nil? && options[:select_by_name_regex].present?
-        filters[:name_select] = !!(name =~ /#{options[:select_by_name_regex]}/)
+        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]}/)
+      filters[:name_exclude] =
+        !!(name =~ /#{options[:exclude_by_name_regex]}/)
     end
 
     # Applies shell-based filters to determine whether to include or
@@ -90,12 +96,16 @@ module MarkdownExec
       filters[:shell_expect] = shell == 'expect'
 
       if shell.present? && options[:select_by_shell_regex].present?
-        filters[:shell_select] = !!(shell =~ /#{options[:select_by_shell_regex]}/)
+        filters[:shell_select] =
+          !!(shell =~ /#{options[:select_by_shell_regex]}/)
       end
 
-      return unless shell.present? && options[:exclude_by_shell_regex].present?
+      unless shell.present? && options[:exclude_by_shell_regex].present?
+        return
+      end
 
-      filters[:shell_exclude] = !!(shell =~ /#{options[:exclude_by_shell_regex]}/)
+      filters[:shell_exclude] =
+        !!(shell =~ /#{options[:exclude_by_shell_regex]}/)
     end
 
     # Applies additional filters to determine whether to include or
@@ -138,7 +148,9 @@ module MarkdownExec
     # if it should be excluded.
     #
     def self.evaluate_filters(options, filters)
-      if filters[:fcb_chrome] == true
+      if filters[:depth] == true
+        false
+      elsif filters[:fcb_chrome] == true
         !options[:no_chrome]
       elsif options[:exclude_expect_blocks] && filters[:shell_expect] == true
         false
@@ -160,15 +172,18 @@ module MarkdownExec
       end
     end
 
-    # blocks for menu, without missing exit and back chrome
-    # remove hidden blocks
+    # check if a block is not in the menu based on multiple match patterns
     #
-    def self.prepared_not_in_menu?(options, fcb)
-      fcb[:shell] == BlockType::BASH &&
-        ((options[:block_name_include_match].present? &&
-                  fcb[:oname] =~ /#{options[:block_name_include_match]}/) ||
-         (options[:block_name_wrapper_match].present? &&
-                  fcb[:oname] =~ /#{options[:block_name_wrapper_match]}/))
+    # @param options [Hash] Options hash containing various settings
+    # @param fcb [Hash] Hash representing a file code block
+    # @param match_patterns [Array<String>] Array of regular expression patterns for matching
+    # @return [Boolean] True if the block should not be in the menu, false otherwise
+    def self.prepared_not_in_menu?(options, fcb, match_patterns)
+      return false unless fcb[:shell] == BlockType::BASH
+
+      match_patterns.any? do |pattern|
+        options[pattern].present? && fcb[:oname] =~ /#{options[pattern]}/
+      end
     end
   end
 end

data/lib/fout.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+# stdout manager
+#
+# module FOut
+class FOut
+  def initialize(config)
+    @config = config
+  end
+
+  def approved_fout?(level)
+    level <= fetch_display_level
+  end
+
+  # integer value for comparison
+  #
+  def fetch_display_level
+    @config.fetch(:display_level, 1)
+  end
+
+  # integer value for comparison
+  #
+  def fetch_display_level_xbase_prefix
+    @config.fetch(:level_xbase_prefix, '')
+  end
+
+  # standard output; not for debug
+  #
+  def fout(str)
+    puts str
+  end
+
+  def fout_list(str)
+    puts str
+  end
+
+  def fout_section(name, data)
+    puts "# #{name}"
+    puts data.to_yaml
+  end
+
+  # display output at level or lower than filter (DISPLAY_LEVEL_DEFAULT)
+  #
+  def lout(str, level: DISPLAY_LEVEL_BASE)
+    return unless approved_fout?(level)
+
+    fout level == DISPLAY_LEVEL_BASE ? str : fetch_display_level_xbase_prefix + str
+  end
+end