markdown_exec 2.3.0 → 2.4.0

data/lib/colorize.rb

@@ -13,15 +13,25 @@ class String
   # @return [String] The formatted string.
   def method_missing(method_name, *args, &block)
     case method_name.to_s
+    # when /^bg_rgb_/
+    #   bytes = $'.split('_')
+    #   bg_rgb_color(bytes[0..2].join(';'))
     when /^fg_bg_rgb_/
+      pp [__LINE__, caller[0]]; binding.irb
       bytes = $'.split('_')
       fg_bg_rgb_color(bytes[0..2].join(';'), bytes[3..5].join(';'))
     when /^fg_bg_rgbh_/
+      pp [__LINE__, caller[0]]; binding.irb
       hex_to_fg_bg_rgb($')
     when /^fg_rgb_/
+      pp [__LINE__, caller[0]]; binding.irb
       fg_rgb_color($'.gsub('_', ';'))
     when /^fg_rgbh_/
+      pp [__LINE__, caller[0]]; binding.irb
       hex_to_rgb($')
+
+    when 'to_a', 'to_ary', 'to_hash', 'to_int', 'to_io', 'to_regexp'
+      nil
     else
       super
     end
@@ -31,14 +41,24 @@ class String
   #
   # @return [String] The string wrapped in an ANSI control sequence.
   def ansi_control_sequence
+    pp [__LINE__, caller[0]]; binding.irb
     "\033[#{self}\033[0m"
   end
 
+  # # Applies a 24-bit RGB background color to the string.
+  # #
+  # # @param rgb [String] The RGB color, expressed as a string like "1;2;3".
+  # # @return [String] The string with the applied RGB foreground color.
+  # def bg_rgb_color(rgb)
+  #   "48;2;#{rgb}m#{self}".ansi_control_sequence
+  # end
+
   # Applies a 24-bit RGB foreground color to the string.
   #
   # @param rgb [String] The RGB color, expressed as a string like "1;2;3".
   # @return [String] The string with the applied RGB foreground color.
   def fg_bg_rgb_color(fg_rgb, bg_rgb)
+    pp [__LINE__, caller[0]]; binding.irb
     "38;2;#{fg_rgb}m\033[48;2;#{bg_rgb}m#{self}".ansi_control_sequence
   end
 
@@ -47,6 +67,7 @@ class String
   # @param rgb [String] The RGB color, expressed as a string like "1;2;3".
   # @return [String] The string with the applied RGB foreground color.
   def fg_rgb_color(rgb)
+    pp [__LINE__, caller[0]]; binding.irb
     "38;2;#{rgb}m#{self}".ansi_control_sequence
   end
 
@@ -55,6 +76,7 @@ class String
   # @param hex_str [String] The RGB color, expressed as a hex string like "FF00FF".
   # @return [String] The string with the applied RGB foreground color.
   def hex_to_fg_bg_rgb(hex_str)
+    pp [__LINE__, caller[0]]; binding.irb
     values = hex_str.split('_').map { |hex| hex.to_i(16).to_s }
     fg_bg_rgb_color(
       values[0..2].join(';'),
@@ -67,6 +89,7 @@ class String
   # @param hex_str [String] The RGB color, expressed as a hex string like "FF00FF".
   # @return [String] The string with the applied RGB foreground color.
   def hex_to_rgb(hex_str)
+    pp [__LINE__, caller[0]]; binding.irb
     fg_rgb_color(
       hex_str.split('_').map { |hex| hex.to_i(16).to_s }.join(';')
     )
@@ -76,6 +99,7 @@ class String
   #
   # @return [String] The original string.
   def plain
+    pp [__LINE__, caller[0]]; binding.irb
     self
   end
 
@@ -102,16 +126,20 @@ class String
   def violet;  fg_rgbh_94_00_D3; end
   def yellow;  fg_rgbh_FF_FF_00; end
 
+  def x
+    pp [__LINE__, caller[1]]; binding.irb
+  end
+
   # graphics modes
-  def bold;             "\033[1m#{self}\033[22m"; end
-  def bold_italic;      "\033[1m\033[3m#{self}\033[22m\033[23m"; end
-  def bold_underline;   "\033[1m\033[4m#{self}\033[22m\033[24m"; end
-  def dim;              "\033[2m#{self}\033[22m"; end
-  def italic;           "\033[3m#{self}\033[23m"; end
-  def underline;        "\033[4m#{self}\033[24m"; end
-  def underline_italic; "\033[4m\033[3m#{self}\033[23m\033[24m"; end
-  def blinking;         "\033[5m#{self}\033[25m"; end
-  def inverse;          "\033[7m#{self}\033[27m"; end
-  def hidden;           "\033[8m#{self}\033[28m"; end
-  def strikethrough;    "\033[9m#{self}\033[29m"; end
+  def bold;             x; "\033[1m#{self}\033[22m"; end
+  def bold_italic;      x; "\033[1m\033[3m#{self}\033[22m\033[23m"; end
+  def bold_underline;   x; "\033[1m\033[4m#{self}\033[22m\033[24m"; end
+  def dim;              x; "\033[2m#{self}\033[22m"; end
+  def italic;           x; "\033[3m#{self}\033[23m"; end
+  def underline;        x; "\033[4m#{self}\033[24m"; end
+  def underline_italic; x; "\033[4m\033[3m#{self}\033[23m\033[24m"; end
+  def blinking;         x; "\033[5m#{self}\033[25m"; end
+  def inverse;          x; "\033[7m#{self}\033[27m"; end
+  def hidden;           x; "\033[8m#{self}\033[28m"; end
+  def strikethrough;    x; "\033[9m#{self}\033[29m"; end
 end

data/lib/constants.rb

@@ -5,6 +5,22 @@
 
 require_relative 'block_types'
 
+class AppInterrupt < StandardError; end
+class BlockMissing < StandardError; end
+
+class ArgPro
+  ActFileIsMissing = :file_missing
+  ActFind = :find
+  ActSetBlockName = :block_name
+  ActSetFileName = :set_filename
+  ActSetOption = :set_option
+  ActSetPath = :set_path
+  ArgIsOption = :option
+  ArgIsPosition = :position
+  CallProcess = :proc_name
+  ConvertValue = :convert
+end
+
 class ExecutionStreams
   STD_ERR = :stderr
   STD_IN  = :stdin
@@ -30,6 +46,7 @@ class LinkKeys
 end
 
 class LoadFile
+  EXIT = :exit
   LOAD = true
   REUSE = false
 end

data/lib/directory_searcher.rb

@@ -155,11 +155,13 @@ class DirectorySearcher
         Find.prune unless @include_subdirectories || path == p
         next unless File.file?(p)
 
-        next if @filename_glob && !File.fnmatch(@filename_glob, File.basename(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: '')
+            line_utf8 = line.encode('UTF-8', invalid: :replace,
+                                             undef: :replace, replace: '')
 
             line_utf8 = yield(line_utf8) if block_given?
 

data/lib/doh.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# encoding=utf-8
+
+class DOH < Hash
+  # Initialize with an optional hash and a block
+  def initialize(initial_hash = {}, &block)
+    super()  # Initialize the parent Hash
+    self.merge!(initial_hash)  # Merge the initial hash into the current hash
+    self.default_proc = block if block_given?
+  end
+
+  # Override method_missing to pass undefined methods to the parent Hash
+  def method_missing(method_name, *args, &block)
+# sc = caller[0].split; pp ['DOH.mm',method_name,sc[-1],sc[-2].split('/')[-1].split(':')[0..1].join(':')]
+    if Hash.instance_methods.include?(method_name)
+      super
+    else
+      raise NoMethodError, "undefined method `#{method_name}` for #{self}:#{self.class}"
+    end
+  end
+
+  # Ensure respond_to_missing? is correctly implemented
+  def respond_to_missing?(method_name, include_private = false)
+# sc = caller[0].split; pp ['DOH.rtm?',method_name,sc[-1],sc[-2].split('/')[-1].split(':')[0..1].join(':')]
+    Hash.instance_methods.include?(method_name) || super
+  end
+end
+
+# class DOH < Hash
+#   # Initialize with an optional hash and a block
+#   def initialize(initial_hash = {}, &block)
+#     super()  # Initialize the parent Hash
+#     self.merge!(initial_hash)  # Merge the initial hash into the current hash
+#     self.default_proc = block if block_given?
+#   end
+
+#   # Override method_missing to pass undefined methods to the parent Hash
+#   def method_missing(method_name, *args, &block)
+# # pp ['DOH.mm',method_name]
+#     if self.respond_to?(method_name)
+#       self.send(method_name, *args, &block)
+#     else
+#       super
+#     end
+#   end
+
+#   # Ensure respond_to_missing? is correctly implemented
+# # pp ['DOH.rtm?',method_name]
+
+#   def respond_to_missing?(method_name, include_private = false)
+#     self.respond_to?(method_name) || super
+#   end
+# end
+
+# class LayeredHash
+#   def initialize(table = {}, layers: %i[main])
+#     @layers = layers.map { |layer| [layer, {}] }.to_h
+#     @current_layer = layers.first
+#     @layers[@current_layer] = table
+#   end
+
+#   private
+
+#   def method_missing(method, *args, &block)
+#     method_name = method.to_s
+#     if @layers.respond_to?(method_name)
+#       @layers.send(method_name, *args, &block)
+#     elsif method_name[-1] == '='
+#       @layers[method_name.chop.to_sym] = args[0]
+#     elsif @layers.respond_to?(method_name)
+#       @layers.send(method_name, *args)
+#     else
+#       @layers[method_name.to_sym]
+#     end
+#   rescue StandardError => err
+#     warn("ERROR ** LayeredHash.method_missing(method: #{method_name}," \
+#          " *args: #{args.inspect}, &block)")
+#     warn err.inspect
+#     warn(caller[0..4])
+#     raise err
+#   end
+
+#   public
+
+#   # Retrieves the value of a key from the current layer using hash notation
+#   def [](key)
+#     raise "Current layer not set" unless @current_layer
+
+#     get_from_layer(@current_layer, key)
+#   end
+
+#   # Sets a key-value pair in the current layer using hash notation
+#   def []=(key, value)
+#     raise "Current layer not set" unless @current_layer
+
+#     set(@current_layer, key, value)
+#   end
+
+#   def fetch(key, *args)
+#     key_sym = key.to_sym
+#     if respond_to?("get_#{key}")
+#       send("get_#{key}")
+#     # elsif @table.key?(key_sym)
+#     elsif @layers[@current_layer].key?(key_sym)
+#       # @table[key_sym]
+#       @layers[@current_layer][key_sym]
+#     elsif block_given?
+#       yield key_sym
+#     elsif args.count.positive?
+# # binding.irb
+#       args.first
+#     else
+# binding.irb
+#       raise KeyError, "key not found: #{key}"
+#     end.tap{|ret| pp([__LINE__,"Poly.fetch #{key} #{args}",'->',ret]) if $pd }
+#   end
+
+#   # Retrieves the value of a key from the highest priority layer that has a value
+#   def get(key)
+#     @layers.reverse_each do |_, hash|
+#       return hash[key] if hash.key?(key)
+#     end
+#     nil
+#   end
+
+#   # Retrieves the value of a key from the specified layer
+#   def get_from_layer(layer, key)
+#     if @layers.key?(layer)
+#       @layers[layer][key]
+#     else
+#       raise ArgumentError, "Layer #{layer} does not exist"
+#     end
+#   end
+
+#   def merge(*args)
+#     @layers.merge(*args).tap{|ret| pp([__LINE__,"LayeredHash.merge",'->',ret]) if $pd }
+#   end
+
+#   def respond_to_missing?(method_name, include_private = false)
+#     @layers.key?(method_name.to_sym) || super
+#   end
+
+#   # Sets a key-value pair in the specified layer
+#   def set(layer, key, value)
+#     if @layers.key?(layer)
+#       @layers[layer][key] = value
+#     else
+#       raise ArgumentError, "Layer #{layer} does not exist"
+#     end
+#   end
+
+#   # Sets the current layer for use with hash notation ([])
+#   def set_current_layer(layer)
+#     if @layers.key?(layer)
+#       @current_layer = layer
+#     else
+#       raise ArgumentError, "Layer #{layer} does not exist"
+#     end
+#   end
+
+#   def to_h
+#     @layers.to_h
+#   end
+# end
+
+return if $PROGRAM_NAME != __FILE__
+
+# layered_hash = LayeredHash.new(layers: %i[low high])
+
+# # Set current layer
+# layered_hash.set_current_layer(:low)
+
+# # Set values in the current layer using hash notation
+# layered_hash[:key1] = 'low_value'
+# layered_hash[:key2] = 'low_only_value'
+
+# # Switch current layer
+# layered_hash.set_current_layer(:high)
+
+# # Set values in the new current layer using hash notation
+# layered_hash[:key1] = 'high_value'
+
+# # Get value from the specific current layer using hash notation
+# puts layered_hash[:key1] # Output: 'high_value'
+
+# # Get value from the highest priority layer
+# puts layered_hash.get(:key1) # Output: 'high_value'
+# puts layered_hash.get(:key2) # Output: 'low_only_value'

data/lib/env.rb

@@ -18,7 +18,7 @@ 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

@@ -3,10 +3,13 @@
 
 # encoding=utf-8
 
+require_relative 'ansi_string'
+
 module Exceptions
   def self.error_handler(name = '', opts = {}, backtrace: $@, format_string: "\nError: %{name} -- %{message}", color_symbol: :red, take_count: 16)
-    warn(error = format(format_string,
-                        { name: name, message: $! }).send(color_symbol))
+    warn(error = AnsiString.new(format(format_string,
+                                       { name: name,
+                                         message: $! })).send(color_symbol))
     if backtrace
       warn(backtrace.select do |s|
              s.include? 'markdown_exec'
@@ -21,10 +24,10 @@ module Exceptions
 
   def self.warn_format(message = '', opts = {})
     warn(
-      error = format(
-        opts.fetch(:format_string, "\nError: %{error}"),
-        { error: message }
-      ).send(opts.fetch(:color_symbol, :yellow))
+      error = AnsiString.new(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}" })
 

data/lib/fcb.rb

@@ -4,7 +4,6 @@
 # encoding=utf-8
 require 'digest'
 require_relative 'namer'
-# require_relative 'poly'
 
 module MarkdownExec
   class Error < StandardError; end
@@ -159,201 +158,3 @@ if $PROGRAM_NAME == __FILE__
     # end
   end
 end
-
-# #!/usr/bin/env ruby
-# # frozen_string_literal: true
-
-# # encoding=utf-8
-# require 'digest'
-# require_relative 'poly'
-
-# # require 'ostruct'
-
-# module MarkdownExec
-#   class Error < StandardError; end
-
-#   # Fenced Code Block (FCB)
-#   #
-#   # This class represents a fenced code block in a markdown document.
-#   # It allows for setting and getting attributes related to the code block,
-#   # such as body, call, headings, and more.
-#   #
-#   class FCB
-#     def initialize(options = {})
-#       # @attrs = ({
-#       @attrs = Poly.new({
-#         body: nil,
-#         call: nil,
-#         headings: [],
-#         dname: nil,
-#         indent: '',
-#         name: nil,
-#         nickname: nil,
-#         oname: nil,
-#         reqs: [],
-#         shell: '',
-#         title: '',
-#         random: Random.new.rand,
-#         text: nil # displayable in menu
-#       }.merge(options))
-#     end
-
-# def is?(name)
-#   (save_name == name).tap{|ret|pp [__LINE__,"is?(#{name})",'->',ret]}
-# end
-
-# # fenced_name: text from code
-# # save_name: for file system
-# # logical_name: used for requires, not displayed
-# # menu_name: displayed in menu
-
-# # used for requires, not displayed
-# def logical_name
-#   (@attrs.fetch(:nickname, nil) || @attrs.fetch(:oname, nil)).tap{|ret|pp [__LINE__,"logical_name()",'->',ret]}
-# end
-
-# # displayed in menu
-# def menu_name #  displayed in menu
-#   @attrs.fetch(:nickname, nil).tap{|ret|pp [__LINE__,"menu_name()",'->',ret]}
-# end
-
-# # for file system
-# # block name in commands and documents
-# def save_name(id_len: 4, max_len: 48)
-#   full = @attrs.fetch(:nickname, nil) || @attrs.fetch(:oname, nil)
-#   trimmed = if full && full[max_len]
-#     r = rand((10**(id_len - 1) + 1)..10**id_len).to_s
-#     dig = Digest::MD5.hexdigest(full)[0, id_len]
-#     full[0..max_len - id_len] + dig
-#   else
-#     full
-#   end
-
-#   trimmed&.to_blockname.tap{|ret|pp [__LINE__,"save_name()",'->',ret]}
-# 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
-#       unless (body_content = @attrs[:body])
-#         # empty body -> empty title
-#         @attrs[:title] = ''
-#         return
-#       end
-
-#       # body -> title
-#       @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
-#       if @attrs.respond_to?(method_name)
-#         @attrs.send(method_name, *args, &block)
-#       elsif method_name[-1] == '='
-#         @attrs[method_name.chop.to_sym] = args[0]
-#       else
-#         @attrs[method_name.to_sym]
-#       end
-#     rescue StandardError => err
-#       warn("ERROR ** FCB.method_missing(method: #{method_name}," \
-#            " *args: #{args.inspect}, &block)")
-#       warn err.inspect
-#       warn(caller[0..4])
-#       # raise StandardError, error
-#       raise err # Here, we simply propagate the original error instead of wrapping it in a StandardError.
-#     end
-
-#     public
-
-#     def respond_to_missing?(method_name, include_private = false)
-#       @attrs.key?(method_name.to_sym) || super
-#     end
-
-#     def to_h
-#       @attrs.to_h
-#     end
-
-#     def to_yaml
-#       @attrs.to_yaml
-#     end
-#   end
-# end
-
-# if $PROGRAM_NAME == __FILE__
-#   require 'bundler/setup'
-#   Bundler.require(:default)
-
-#   require 'minitest/autorun'
-#   require 'yaml'
-
-#   class FCBTest < Minitest::Test
-#     def setup
-#       @fcb_data = {
-#         body: 'Sample body',
-#         call: 'Sample call',
-#         headings: %w[Header1 Header2],
-#         dname: 'Sample name',
-#         indent: '',
-#         nickname: nil,
-#         name: 'Sample name',
-#         oname: 'Sample name',
-#         reqs: %w[req1 req2],
-#         shell: 'bash',
-#         text: 'Sample Text',
-#         title: 'Sample Title'
-#       }
-#       @fcb = MarkdownExec::FCB.new(@fcb_data)
-#     end
-
-#     def test_initialization_with_correct_data
-#       assert_equal 'Sample body', @fcb.body
-#       assert_equal %w[Header1 Header2], @fcb.headings
-#     end
-
-#     def test_to_h_method
-#       assert_equal @fcb_data.merge({ random: @fcb.random }), @fcb.to_h
-#     end
-
-#     def test_to_yaml_method
-#       assert_equal YAML.load(@fcb_data.merge({ random: @fcb.random }).to_yaml),
-#                    YAML.load(@fcb.to_yaml)
-#     end
-
-#     def test_method_missing_getter
-#       assert_equal 'Sample Title', @fcb.title
-#     end
-
-#     def test_method_missing_setter
-#       @fcb.title = 'New Title'
-#       assert_equal 'New Title', @fcb.title
-#     end
-
-#     # 2023-10-09 does not trigger error; treats as option name
-#     #
-#     # def test_method_missing_with_unknown_method
-#     #   assert_raises(NoMethodError) { @fcb.unknown_method }
-#     # end
-#   end
-# end

data/lib/filter.rb

@@ -3,6 +3,17 @@
 
 # encoding=utf-8
 
+# Determines if a given block type is selected based on a list.
+#
+# @param selected_types [Array<String>, nil] An array of block types to
+# check against. If nil, all types are considered selected.
+# @param type [String] The block type to check for selection.
+# @return [Boolean] Returns true if the type is selected or if
+# selected_types is nil (indicating all types are selected).
+def block_type_selected?(selected_types, type)
+  !selected_types || selected_types.include?(type)
+end
+
 module MarkdownExec
   # Filter
   #
@@ -96,7 +107,8 @@ module MarkdownExec
 
       return unless shell.present? && options[:exclude_by_shell_regex].present?
 
-      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
@@ -176,14 +188,15 @@ module MarkdownExec
     end
 
     # Yields to the provided block with specified parameters if certain conditions are met.
-    # The method checks if a block is given, if the selected_messages include :blocks,
+    # The method checks if a block is given, if the selected_types include :blocks,
     # and if the fcb_select? method returns true for the given fcb.
     #
     # @param fcb [Object] The object to be evaluated and potentially passed to the block.
-    # @param selected_messages [Array<Symbol>] A collection of message types, one of which must be :blocks.
+    # @param selected_types [Array<Symbol>] A collection of message types, one of which must be :blocks.
     # @param block [Block] A block to be called if conditions are met.
-    def self.yield_to_block_if_applicable(fcb, selected_messages, configuration = {}, &block)
-      if block_given? && selected_messages.include?(:blocks) &&
+    def self.yield_to_block_if_applicable(fcb, selected_types, configuration = {}, &block)
+      if block_given? &&
+         block_type_selected?(selected_types, :blocks) &&
          fcb_select?(configuration, fcb)
         block.call :blocks, fcb
       end

data/lib/find_files.rb

@@ -28,7 +28,8 @@
 # Example:
 #   find_files('version.rb', ['lib/**', 'spec'], true, true)
 #   # This might return file paths like ['markdown_exec/version.rb', 'spec/version_spec.rb'].
-def find_files(pattern, paths = ['', Dir.pwd], base_dir: Dir.pwd, exclude_dirs: false, use_relative_paths: true)
+def find_files(pattern, paths = ['', Dir.pwd], base_dir: Dir.pwd,
+               exclude_dirs: false, use_relative_paths: true)
   matched_files = []
 
   paths.each do |path_with_wildcard|
@@ -39,10 +40,14 @@ def find_files(pattern, paths = ['', Dir.pwd], base_dir: Dir.pwd, exclude_dirs:
     files = Dir.glob(search_pattern, File::FNM_DOTMATCH)
 
     # Optionally exclude "." and ".." and directory names
-    files.reject! { |file| file.end_with?('/.', '/..') || File.directory?(file) } if exclude_dirs
+    files.reject! { |file|
+      file.end_with?('/.', '/..') || File.directory?(file)
+    } if exclude_dirs
 
     # Optionally use relative paths
-    files.map! { |file| file.sub(/^#{Regexp.escape(base_dir)}\//, '') } if use_relative_paths
+    files.map! { |file|
+      file.sub(/^#{Regexp.escape(base_dir)}\//, '')
+    } if use_relative_paths
 
     matched_files += files
   end