markdown_exec 2.1.0 → 2.3.0

data/lib/hierarchy_string.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+# Class representing a hierarchy of substrings stored as Hash nodes
+class HierarchyString
+  attr_accessor :substrings
+
+  # Initialize with a single hash or an array of hashes
+  def initialize(substrings)
+    @substrings = parse_substrings(substrings)
+  end
+
+  def map_substring_text_yield(tree, &block)
+    case tree
+    when Array
+      tree.each.with_index do |node, ind|
+        case node
+        when String
+          tree[ind] = yield node
+        else
+          map_substring_text_yield(node, &block)
+        end
+      end
+    when Hash
+      text = yield tree[:text]
+      tree[:text] = text
+
+      tree
+    when String
+      yield tree
+    else
+      raise ArgumentError, 'Invalid type.'
+    end
+  end
+
+  # operate on substring
+  def replace_text!
+    map_substring_text_yield(@substrings) do |node|
+      case node
+      when Hash
+        text = yield node[:text]
+        node[:text] = text
+      when String
+        yield node
+      end
+    end
+  end
+
+  # Method to concatenate all substrings into a single string
+  def concatenate
+    concatenate_substrings(@substrings)
+  end
+
+  # Method to decorate all substrings into a single string
+  def decorate
+    decorate_substrings(@substrings)
+  end
+
+  # Handle string inspection methods and pass them to the concatenated string
+  def method_missing(method_name, *arguments, &block)
+    if ''.respond_to?(method_name)
+      concatenate.send(method_name, *arguments, &block)
+    else
+      super
+    end
+  end
+
+  # Ensure proper handling of method checks
+  def respond_to_missing?(method_name, include_private = false)
+    ''.respond_to?(method_name) || super
+  end
+
+  private
+
+  # Parse the input substrings into a nested array of hashes structure
+  def parse_substrings(substrings)
+    case substrings
+    when Hash
+      [substrings]
+    when Array
+      substrings.map { |s| parse_substrings(s) }
+    else
+      substrings
+      # raise ArgumentError, 'Invalid input type. Expected Hash or Array.'
+    end
+  end
+
+  # Recursively concatenate substrings
+  def concatenate_substrings(substrings)
+    substrings.map do |s|
+      case s
+      when Hash
+        s[:text]
+      when Array
+        concatenate_substrings(s)
+      end
+    end.join
+  end
+
+  # Recursively decorate substrings
+  def decorate_substrings(substrings, prior_color = '')
+    substrings.map do |s|
+      case s
+      when Hash
+        if s[:color]
+          s[:text].send(s[:color]) + prior_color
+        else
+          s[:text]
+        end
+      when Array
+        decorate_substrings(s, prior_color)
+      end
+    end.join
+  end
+end
+
+return if $PROGRAM_NAME != __FILE__
+
+# require 'bundler/setup'
+# Bundler.require(:default)
+
+# require 'fcb'
+# require 'minitest/autorun'
+
+# Usage
+hierarchy = HierarchyString.new([{ text: 'Hello ', color: :red },
+                                 [{ text: 'World', color: :upcase },
+                                  { text: '!' }]])
+puts hierarchy.decorate
+puts hierarchy.length
+# puts hierarchy.concatenate           # Outputs: Hello World!
+# puts hierarchy.upcase                # Outputs: HELLO WORLD!
+# puts hierarchy.length                # Outputs: 12
+# puts hierarchy.gsub('World', 'Ruby') # Outputs: Hello Ruby!

data/lib/input_sequencer.rb

@@ -79,7 +79,8 @@ class InputSequencer
     )
     exit_when_bq_empty = !bq_is_empty? # true when running blocks from cli; unless "stay" is used
     loop do
-      break if run_yield(:parse_document, now_menu.document_filename, &block) == :break
+      break if run_yield(:parse_document, now_menu.document_filename,
+                         &block) == :break
 
       # self.imw_ins now_menu, 'now_menu'
 
@@ -92,7 +93,8 @@ class InputSequencer
         choice = run_yield :user_choice, &block
 
         raise 'Block not recognized.' if choice.nil?
-        break if run_yield(:exit?, choice&.downcase, &block) # Exit loop and method to terminate the app
+        # Exit loop and method to terminate the app
+        break if run_yield(:exit?, choice&.downcase, &block)
 
         next_state = run_yield :execute_block, choice, &block
         # imw_ins next_state, 'next_state'

data/lib/link_history.rb

@@ -2,10 +2,13 @@
 # frozen_string_literal: true
 
 # encoding=utf-8
+
+$pd = false unless defined?($pd)
+
 module MarkdownExec
   class LinkState
     attr_accessor :block_name, :display_menu, :document_filename,
-                  :inherited_block_names, :inherited_dependencies, :inherited_lines,
+                  :inherited_block_names, :inherited_dependencies,
                   :prior_block_was_link
 
     # Initialize the LinkState with keyword arguments for each attribute.
@@ -45,6 +48,36 @@ module MarkdownExec
         other.inherited_lines == inherited_lines &&
         other.prior_block_was_link == prior_block_was_link
     end
+
+    def inherited_lines
+      @inherited_lines.tap { |ret| pp ['LinkState.inherited_lines() ->', ret] if $pd }
+    end
+
+    def inherited_lines=(value)
+      @inherited_lines = value.tap { |ret| pp ['LinkState.inherited_lines=() ->', ret] if $pd }
+    end
+
+    def inherited_lines_append(value)
+      @inherited_lines = ((@inherited_lines || []) + value).tap { |ret| pp ['LinkState.inherited_lines_append() ->', ret] if $pd }
+    end
+
+    def inherited_lines_block
+      @inherited_lines.join("\n").tap { |ret| pp ['LinkState.inherited_lines_block() ->', ret] if $pd }
+    end
+
+    def inherited_lines_count
+      (@inherited_lines&.count || 0).tap { |ret| pp ['LinkState.inherited_lines_count() ->', ret] if $pd }
+    end
+
+    def inherited_lines_map
+      @inherited_lines.map do |line|
+        yield line
+      end.tap { |ret| pp ['LinkState.inherited_lines_map() ->', ret] if $pd }
+    end
+
+    def inherited_lines_present?
+      @inherited_lines.present?.tap { |ret| pp ['LinkState.inherited_lines_present?() ->', ret] if $pd }
+    end
   end
 
   class LinkHistory

data/lib/markdown_exec/version.rb

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

data/lib/markdown_exec.rb

@@ -45,6 +45,8 @@ tap_config envvar: MarkdownExec::TAP_DEBUG
 $stderr.sync = true
 $stdout.sync = true
 
+$pd = false unless defined?($pd)
+
 ARGV_SEP = '--'
 
 # custom error: file specified is missing
@@ -86,20 +88,6 @@ def extract_named_captures_from_option(str, option)
   str.match(Regexp.new(option))&.named_captures&.sym_keys
 end
 
-# :reek:UtilityFunction
-def list_recent_output(saved_stdout_folder, saved_stdout_glob,
-                       list_count)
-  SavedFilesMatcher.most_recent_list(saved_stdout_folder,
-                                     saved_stdout_glob, list_count)
-end
-
-# :reek:UtilityFunction
-def list_recent_scripts(saved_script_folder, saved_script_glob,
-                        list_count)
-  SavedFilesMatcher.most_recent_list(saved_script_folder,
-                                     saved_script_glob, list_count)
-end
-
 # execute markdown documents
 #
 module MarkdownExec
@@ -137,7 +125,10 @@ module MarkdownExec
       return if max <= min # Ensure the range is valid
 
       # Normalize the value within the range 0 to 1
-      normalized_value = [0, [(integer_value - min).to_f / (max - min), 1].min].max
+      normalized_value = [
+        0,
+        [(integer_value - min).to_f / (max - min), 1].min
+      ].max
 
       # Calculate how many characters should be filled
       filled_length = (normalized_value * width).round
@@ -158,21 +149,25 @@ module MarkdownExec
       @o_color = :red
     end
 
-    def build_menu(file_names, directory_names, found_in_block_names, files_in_directories, vbn)
+    def build_menu(file_names, directory_names, found_in_block_names,
+                   files_in_directories, vbn)
       choices = []
 
       # Adding section title and data for file names
-      choices << { disabled: '', name: "in #{file_names[:section_title]}".send(@chrome_color) }
+      choices << { disabled: '',
+                   name: "in #{file_names[:section_title]}".send(@chrome_color) }
       choices += file_names[:data].map { |str| FileInMenu.for_menu(str) }
 
       # Conditionally add directory names if data is present
       unless directory_names[:data].count.zero?
-        choices << { disabled: '', name: "in #{directory_names[:section_title]}".send(@chrome_color) }
+        choices << { disabled: '',
+                     name: "in #{directory_names[:section_title]}".send(@chrome_color) }
         choices += files_in_directories
       end
 
       # Adding found in block names
-      choices << { disabled: '', name: "in #{found_in_block_names[:section_title]}".send(@chrome_color) }
+      choices << { disabled: '',
+                   name: "in #{found_in_block_names[:section_title]}".send(@chrome_color) }
 
       choices += vbn
 
@@ -186,16 +181,22 @@ module MarkdownExec
       {
         section_title: 'directory names',
         data: matched_directories,
-        formatted_text: [{ content: AnsiFormatter.new(search_options).format_and_highlight_array(matched_directories, highlight: [highlight_value]) }]
+        formatted_text: [{ content: AnsiFormatter.new(search_options).format_and_highlight_array(
+          matched_directories, highlight: [highlight_value]
+        ) }]
       }
     end
 
-    def found_in_block_names(search_options, highlight_value, formspec: '=%<index>4.d: %<line>s')
+    def found_in_block_names(search_options, highlight_value,
+                             formspec: '=%<index>4.d: %<line>s')
       matched_contents = (find_file_contents do |line|
-                            read_block_name(line, search_options[:fenced_start_and_end_regex], search_options[:block_name_match], search_options[:block_name_nick_match])
+                            read_block_name(line, search_options[:fenced_start_and_end_regex],
+                                            search_options[:block_name_match], search_options[:block_name_nick_match])
                           end).map.with_index do |(file, contents), index|
         # [file, contents.map { |detail| format(formspec, detail.index, detail.line) }, index]
-        [file, contents.map { |detail| format(formspec, { index: detail.index, line: detail.line }) }, index]
+        [file, contents.map do |detail|
+                 format(formspec, { index: detail.index, line: detail.line })
+               end, index]
       end
       {
         section_title: 'block names',
@@ -222,7 +223,8 @@ module MarkdownExec
       }
     end
 
-    def read_block_name(line, fenced_start_and_end_regex, block_name_match, block_name_nick_match)
+    def read_block_name(line, fenced_start_and_end_regex, block_name_match,
+                        block_name_nick_match)
       return unless line.match(fenced_start_and_end_regex)
 
       bm = extract_named_captures_from_option(line, block_name_match)
@@ -241,7 +243,6 @@ module MarkdownExec
   ##
   #
   # :reek:DuplicateMethodCall { allow_calls: ['block', 'item', 'lm', 'opts', 'option', '@options', 'required_blocks'] }
-  # rubocop:enable Layout/LineLength
   # :reek:MissingSafeMethod { exclude: [ read_configuration_file! ] }
   # :reek:TooManyInstanceVariables ### temp
   # :reek:TooManyMethods ### temp
@@ -267,6 +268,20 @@ module MarkdownExec
       )
     end
 
+    # :reek:UtilityFunction
+    def list_recent_output(saved_stdout_folder, saved_stdout_glob,
+                           list_count)
+      SavedFilesMatcher.most_recent_list(saved_stdout_folder,
+                                         saved_stdout_glob, list_count)
+    end
+
+    # :reek:UtilityFunction
+    def list_recent_scripts(saved_script_folder, saved_script_glob,
+                            list_count)
+      SavedFilesMatcher.most_recent_list(saved_script_folder,
+                                         saved_script_glob, list_count)
+    end
+
     def warn_format(name, message, opts = {})
       Exceptions.warn_format(
         "CachedNestedFileReader.#{name} -- #{message}",
@@ -390,8 +405,6 @@ module MarkdownExec
                              },
         pwd: -> { @fout.fout File.expand_path('..', __dir__) },
         run_last_script: -> { run_last_script },
-        select_recent_output: -> { select_recent_output },
-        select_recent_script: -> { select_recent_script },
         tab_completions: -> { @fout.fout tab_completions },
         menu_export: -> { @fout.fout menu_export }
       }
@@ -456,7 +469,8 @@ module MarkdownExec
                                                                   :menu_chrome_color)}"
       searcher = SearchResultsReport.new(value, [find_path])
       file_names = searcher.file_names(options, value)
-      found_in_block_names = searcher.found_in_block_names(options, value, formspec: '%<line>s')
+      found_in_block_names = searcher.found_in_block_names(options, value,
+                                                           formspec: '%<line>s')
       directory_names = searcher.directory_names(options, value)
 
       ### search in file contents (block names, chrome, or text)
@@ -480,7 +494,9 @@ module MarkdownExec
         find_files('*', [dn], exclude_dirs: true)
       end.flatten(1).map { |str| FileInMenu.for_menu(str) }
 
-      return { exit: true } unless file_names[:data]&.count.positive? || files_in_directories&.count.positive? || found_in_block_names[:data]&.count.positive?
+      unless file_names[:data]&.count.positive? || files_in_directories&.count.positive? || found_in_block_names[:data]&.count.positive?
+        return { exit: true }
+      end
 
       vbn = found_in_block_names[:matched_contents].map do |matched_contents|
         filename, details, = matched_contents
@@ -488,10 +504,14 @@ module MarkdownExec
           details,
           highlight: [value]
         )
-        [FileInMenu.for_menu(filename)] + nexo.map { |str| { disabled: '', name: (' ' * 20) + str } }
+        [FileInMenu.for_menu(filename)] +
+          nexo.map do |str|
+            { disabled: '', name: (' ' * 20) + str }
+          end
       end.flatten
 
-      choices = MenuBuilder.new.build_menu(file_names, directory_names, found_in_block_names, files_in_directories, vbn)
+      choices = MenuBuilder.new.build_menu(file_names, directory_names, found_in_block_names,
+                                           files_in_directories, vbn)
 
       @options[:filename] = FileInMenu.from_menu(
         select_document_if_multiple(
@@ -545,7 +565,8 @@ module MarkdownExec
         ->(_) { exit }
       when 'find', 'open'
         ->(value) {
-          exit if find_value(value, execute_chosen_found: procname == 'open').fetch(:exit, false)
+          exit if find_value(value, execute_chosen_found: procname == 'open').fetch(:exit,
+                                                                                    false)
         }
       when 'help'
         ->(_) {
@@ -571,9 +592,9 @@ module MarkdownExec
           value.instance_of?(::String) ? (value.chomp != '0') : value
         }
       when 'val_as_int'
-        ->(value) { value.to_i }
+        lambda(&:to_i)
       when 'val_as_str'
-        ->(value) { value.to_s }
+        lambda(&:to_s)
       when 'version'
         lambda { |_|
           @fout.fout MarkdownExec::VERSION
@@ -734,59 +755,26 @@ module MarkdownExec
                                            @options[:saved_filename_replacement])
     end
 
-    def select_document_if_multiple(files = list_markdown_files_in_path, prompt: options[:prompt_select_md].to_s)
+    def select_document_if_multiple(files = list_markdown_files_in_path,
+                                    prompt: options[:prompt_select_md].to_s)
       return files[0] if (count = files.count) == 1
 
       return unless count >= 2
 
       opts = options.dup
-      select_option_or_exit(HashDelegator.new(@options).string_send_color(prompt, :prompt_color_after_script_execution),
-                            files,
-                            opts.merge(per_page: opts[:select_page_height]))
-    end
-
-    # Presents a TTY prompt to select an option or exit, returns selected option or nil
-    def select_option_or_exit(prompt_text, strings, opts = {})
-      result = @options.select_option_with_metadata(prompt_text, strings,
-                                                    opts)
-      ### 2024-04-20 what for?
-      # return unless result.fetch(:option, nil)
-
-      result[:selected]
-    end
-
-    def select_recent_output
-      filename = select_option_or_exit(
-        HashDelegator.new(@options).string_send_color(@options[:prompt_select_output].to_s,
+      select_option_or_exit(
+        HashDelegator.new(@options).string_send_color(prompt,
                                                       :prompt_color_after_script_execution),
-        list_recent_output(
-          @options[:saved_stdout_folder],
-          @options[:saved_stdout_glob],
-          @options[:list_count]
-        ),
-        @options.merge({ per_page: @options[:select_page_height] })
+        files,
+        opts.merge(per_page: opts[:select_page_height])
       )
-      return unless filename.present?
-
-      `open #{filename} #{options[:output_viewer_options]}`
     end
 
-    def select_recent_script
-      filename = select_option_or_exit(
-        HashDelegator.new(@options).string_send_color(@options[:prompt_select_md].to_s,
-                                                      :prompt_color_after_script_execution),
-        list_recent_scripts(
-          @options[:saved_script_folder],
-          @options[:saved_script_glob],
-          @options[:list_count]
-        ),
-        @options.merge({ per_page: @options[:select_page_height] })
-      )
-      return if filename.nil?
-
-      saved_name_split(filename)
-
-      @options.document_inpseq ### ({ save_executed_script: false })
+    # Presents a TTY prompt to select an option or exit, returns selected option or nil
+    def select_option_or_exit(prompt_text, strings, opts = {})
+      @options.select_option_with_metadata(
+        prompt_text, strings, opts
+      )&.fetch(:selected)
     end
 
     public
@@ -827,4 +815,4 @@ if $PROGRAM_NAME == __FILE__
       assert_equal MenuState::CONTINUE, state
     end
   end # module MarkdownExec
-end  # if
+end # if