markdown_exec 1.6 → 1.8

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/directory_searcher.rb

@@ -0,0 +1,239 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+require 'find'
+
+# Formats and highlights a list of dependencies. Dependencies are presented with indentation,
+# and specific items can be highlighted in a specified color, while others are shown in a plain color.
+#
+# @param dependencies [Hash] A hash of dependencies, where each key is a dependency name,
+#        and its value is an array of sub-items.
+# @param highlight_color_sym [Symbol] The color method to apply to highlighted items.
+#        Default is :exception_color_detail.
+# @param plain_color_sym [Symbol] The color method for non-highlighted items.
+#        Default is :menu_chrome_color.
+# @param label [String] The label to prefix the list of dependencies with.
+#        Default is 'Dependencies:'.
+# @param highlight [Array] An array of items to highlight. Each item in this array will be
+#        formatted with the specified highlight color.
+# @param line_prefix [String] Prefix for each line. Default is '  '.
+# @param line_postfix [String] Postfix for each line. Default is ''.
+# @param detail_sep [String] Separator for items in the sub-list. Default is '  '.
+# @return [String] A formatted string representation of the dependencies with highlighted items.
+def format_and_highlight_dependencies(
+  dependencies,
+  highlight_color_sym: :exception_color_detail,
+  plain_color_sym: :menu_chrome_color,
+  label: 'Dependencies:',
+  highlight: [],
+  line_prefix: '  ',
+  line_postfix: '',
+  detail_sep: '  '
+)
+  formatted_deps = dependencies&.map do |dep_name, sub_items|
+    formatted_sub_items = sub_items.map do |item|
+      color_sym = highlight.include?(item) ? highlight_color_sym : plain_color_sym
+      string_send_color(item, color_sym)
+    end.join(detail_sep)
+
+    "#{line_prefix}- #{string_send_color(dep_name,
+                                         highlight.include?(dep_name) ? highlight_color_sym : plain_color_sym)}: #{formatted_sub_items}#{line_postfix}"
+  end || []
+
+  "#{line_prefix}#{string_send_color(label,
+                                     highlight_color_sym)}#{line_postfix}\n" + formatted_deps.join("\n")
+end
+# warn menu_blocks.to_yaml.sub(/^(?:---\n)?/, "MenuBlocks:\n")
+
+IndexedLine = Struct.new(:index, :line) do
+  def to_s
+    line
+  end
+end
+
+# Class DirectorySearcher
+# This class provides methods to search for a specified pattern
+# in directory names, file names, and contents of files within given paths.
+class DirectorySearcher
+  attr_reader :pattern, :paths, :include_subdirectories, :filename_glob
+
+  # Constructor
+  # @param pattern [Regexp] The regular expression pattern to search for.
+  # @param paths [Array<String>] List of directories to search in.
+  # @param include_subdirectories [Boolean] Whether to search in subdirectories.
+  # @param filename_glob [String, nil] Glob pattern for file names.
+  def initialize(pattern, paths, include_subdirectories: true, filename_glob: '*.[Mm][Dd]') #'*.md'
+    @pattern = pattern
+    @paths = paths
+    @include_subdirectories = include_subdirectories
+    @filename_glob = filename_glob
+  end
+
+  # Searches for the pattern in directory names.
+  # @return [Array<String>] List of matching directory names.
+  def search_in_directory_names
+    match_dirs = []
+    @paths.each do |path|
+      Find.find(path) do |p|
+        # p 'search_in_directory_names', p
+        # Find.prune unless @include_subdirectories || path == p
+        match_dirs << p if File.directory?(p) && p.match?(@pattern)
+      end
+    end
+    match_dirs
+  end
+
+  # Searches for the pattern in file names.
+  # @return [Array<String>] List of matching file names.
+  def search_in_file_names
+    match_files = []
+    @paths.each do |path|
+      Find.find(path) do |p|
+        # Find.prune unless @include_subdirectories || path == p
+        next unless File.file?(p)
+
+        file_name = File.basename(p)
+        next if @filename_glob && !File.fnmatch(@filename_glob, file_name)
+
+        begin
+          match_files << p if file_name.encode('UTF-8', invalid: :replace, undef: :replace,
+                                                        replace: '').match?(@pattern)
+        rescue EncodingError
+          # Optionally log the file with encoding issues
+          # puts "Encoding error in file: #{p}"
+        end
+      end
+    end
+    match_files
+  end
+
+  # Searches for the pattern in the contents of the files and returns matches along with their file paths and line numbers.
+  # @return [Hash] A hash where each key is a file path and each value is an array of hashes with :line_number and :line keys.
+  def search_in_file_contents
+    match_details = {}
+
+    @paths.each do |path|
+      Find.find(path) do |p|
+        Find.prune unless @include_subdirectories || path == p
+        next unless File.file?(p)
+
+        next if @filename_glob && !File.fnmatch(@filename_glob, File.basename(p))
+
+        begin
+          File.foreach(p).with_index(1) do |line, line_num| # Index starts from 1 for line numbers
+            line_utf8 = line.encode('UTF-8', invalid: :replace, undef: :replace, replace: '')
+            if line_utf8.match?(@pattern)
+              match_details[p] ||= []
+              # match_details[p] << { number: line_num, line: line_utf8.chomp }
+              match_details[p] << IndexedLine.new(line_num, line_utf8.chomp)
+            end
+          end
+        rescue EncodingError
+          # Optionally log the file with encoding issues
+          # puts "Encoding error in file: #{p}"
+        end
+      end
+    end
+
+    match_details
+  end
+
+  # # Searches for the pattern in the contents of the files.
+  # # @return [Array<String>] List of matching lines from files.
+  # def search_in_file_contents
+  #   match_lines = []
+  #   @paths.each do |path|
+  #     Find.find(path) do |p|
+  #       Find.prune unless @include_subdirectories || path == p
+  #       next unless File.file?(p)
+
+  #       next if @filename_glob && !File.fnmatch(@filename_glob, File.basename(p))
+
+  #       begin
+  #         File.foreach(p).with_index do |line, _line_num|
+  #           line_utf8 = line.encode('UTF-8', invalid: :replace, undef: :replace, replace: '')
+  #           match_lines << line_utf8.chomp if line_utf8.match?(@pattern)
+  #         end
+  #       rescue EncodingError
+  #         # Optionally log the file with encoding issues
+  #         # puts "Encoding error in file: #{p}"
+  #       end
+  #     end
+  #   end
+  #   match_lines
+  # end
+end
+
+if $PROGRAM_NAME == __FILE__
+  require 'bundler/setup'
+  Bundler.require(:default)
+
+  require 'minitest/autorun'
+  # require 'mocha/minitest'
+  # require_relative 'directory_searcher'
+
+  # Test class for DirectorySearcher
+  class DirectorySearcherTest < Minitest::Test
+    # Setup method to initialize common test data
+    def setup
+      @pattern = /test_pattern/
+      @paths = ['./spec']
+      @searcher = DirectorySearcher.new(@pattern, @paths)
+    end
+
+    # Test search_in_directory_names method
+    def test_search_in_directory_names
+      # Add assertions based on your test directory structure and expected results
+      assert_equal [], @searcher.search_in_directory_names
+    end
+
+    # Test search_in_file_names method
+    def test_search_in_file_names
+      # Add assertions based on your test directory structure and expected results
+      assert_equal [], @searcher.search_in_file_names
+    end
+
+    # Test search_in_file_contents method
+    def test_search_in_file_contents
+      # Add assertions based on your test directory structure and expected results
+      assert_equal ({}), @searcher.search_in_file_contents
+    end
+  end
+
+  # Test class for DirectorySearcher
+  class DirectorySearcherTest2 < Minitest::Test
+    # Setup method to initialize common test data
+    def setup
+      @pattern_spec = /spec/
+      @paths = ['./spec']
+      @filename_glob = nil
+      @searcher_spec = DirectorySearcher.new(@pattern_spec, @paths,
+                                             filename_glob: @filename_glob)
+    end
+
+    # Test search_in_directory_names method for 'spec'
+    def test_search_in_directory_names_for_spec
+      # Replace with actual expected directory names containing 'spec'
+      expected_dirs = ['./spec']
+      assert_equal expected_dirs, @searcher_spec.search_in_directory_names
+    end
+
+    # Test search_in_file_names method for 'spec'
+    def test_search_in_file_names_for_spec
+      # Replace with actual expected file names containing 'spec'
+      expected_files = ['./spec/cli_spec.rb', './spec/env_spec.rb',
+                        './spec/markdown_exec_spec.rb', './spec/tap_spec.rb']
+      assert_equal expected_files, @searcher_spec.search_in_file_names
+    end
+
+    # # Test search_in_file_contents method for 'spec'
+    # def test_search_in_file_contents_for_spec
+    #   # Replace with actual expected lines containing 'spec'
+    #   expected_lines = {['Line with spec 1', 'Line with spec 2']}
+    #   assert_equal expected_lines, @searcher_spec.search_in_file_contents
+    # end
+  end
+
+end

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

data/lib/hash.rb

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+# hash with keys sorted by name
+# add Hash.sym_keys
+#
+class Hash
+  unless defined?(sort_by_key)
+    def sort_by_key
+      keys.sort.to_h { |key| [key, self[key]] }
+    end
+  end
+
+  unless defined?(sym_keys)
+    def sym_keys
+      transform_keys(&:to_sym)
+    end
+  end
+end