markdown_exec 1.3.7 → 1.3.9

data/lib/fcb.rb

@@ -18,7 +18,9 @@ module MarkdownExec
         body: nil,
         call: nil,
         headings: [],
+        dname: nil,
         name: nil,
+        oname: nil,
         reqs: [],
         shell: '',
         title: '',
@@ -27,39 +29,9 @@ module MarkdownExec
       }.merge(options)
     end
 
-    def to_h
-      @attrs
-    end
-
-    def to_yaml
-      @attrs.to_yaml
-    end
-
-    private
-
-    # 2023-10-07 proposed but not functional with code
-    #
-    # def method_missing(method, *args, &block)
-    #   method_name = method.to_s
-
-    #   if method_name[-1] == '='
-    #     @attrs[method_name.chop.to_sym] = args[0]
-    #   elsif @attrs.key?(method_name.to_sym)
-    #     @attrs[method_name.to_sym]
-    #   else
-    #     super
-    #   end
-    # rescue StandardError => err
-    #   warn(error = "ERROR ** FCB.method_missing(method: #{method_name}, *args: #{args.inspect}, &block)")
-    #   warn err.inspect
-    #   warn(caller[0..4])
-    #   raise err  # Here, we simply propagate the original error instead of wrapping it in a StandardError.
-    # 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] == '='
@@ -79,6 +51,14 @@ module MarkdownExec
     def respond_to_missing?(method_name, _include_private = false)
       @attrs.key?(method_name.to_sym) || super
     end
+
+    def to_h
+      @attrs
+    end
+
+    def to_yaml
+      @attrs.to_yaml
+    end
   end
 end
 
@@ -92,7 +72,9 @@ if $PROGRAM_NAME == __FILE__
         body: 'Sample body',
         call: 'Sample call',
         headings: %w[Header1 Header2],
+        dname: 'Sample name',
         name: 'Sample name',
+        oname: 'Sample name',
         reqs: %w[req1 req2],
         shell: 'bash',
         text: 'Sample Text',

data/lib/filter.rb

@@ -6,13 +6,22 @@
 module MarkdownExec
   # Filter
   #
-  # The Filter class provides utilities to determine the inclusion of fenced code blocks (FCB)
-  # based on a set of provided options. The primary function, `fcb_select?`, checks
-  # various properties of an FCB and decides whether to include or exclude it.
+  # The Filter class provides utilities to determine the inclusion of
+  # fenced code blocks (FCB) based on a set of provided options. The
+  # primary function, `fcb_select?`, checks various properties of an
+  # FCB and decides whether to include or exclude it.
   #
   # :reek:UtilityFunction
-
   class Filter
+    # Determines whether to include or exclude a fenced code block
+    # (FCB) based on the provided options.
+    #
+    # @param options [Hash] The options used for filtering FCBs.
+    # @param fcb [Hash] The fenced code block to be evaluated.
+    # @return [Boolean] True if the FCB should be included; false if
+    # it should be excluded.
+    # @raise [StandardError] If an error occurs during the evaluation.
+    #
     def self.fcb_select?(options, fcb)
       filters = {
         name_default: true,
@@ -21,13 +30,15 @@ module MarkdownExec
         shell_default: true,
         shell_exclude: nil,
         shell_select: nil,
-        hidden_name: nil
+        hidden_name: nil,
+        include_name: nil,
+        wrap_name: nil
       }
 
-      name = fcb.fetch(:name, '')
+      name = fcb.oname
       shell = fcb.fetch(:shell, '')
 
-      apply_name_filters(options, filters, name)
+      apply_name_filters(options, filters, name) #if shell == 'bash'
       apply_shell_filters(options, filters, shell)
       apply_other_filters(options, filters, fcb)
 
@@ -37,6 +48,14 @@ module MarkdownExec
       raise err
     end
 
+    # Applies name-based filters to determine whether to include or
+    # exclude a fenced code block (FCB)
+    # based on the block's name and provided options.
+    #
+    # @param options [Hash] The options used for filtering FCBs.
+    # @param filters [Hash] The filter settings to be updated.
+    # @param name [String] The name of the fenced code block.
+    #
     def self.apply_name_filters(options, filters, name)
       if name.present? && options[:block_name]
         if name =~ /#{options[:block_name]}/
@@ -59,6 +78,14 @@ module MarkdownExec
       filters[:name_exclude] = !!(name =~ /#{options[:exclude_by_name_regex]}/)
     end
 
+    # Applies shell-based filters to determine whether to include or
+    # exclude a fenced code block (FCB)
+    # based on the block's shell type and provided options.
+    #
+    # @param options [Hash] The options used for filtering FCBs.
+    # @param filters [Hash] The filter settings to be updated.
+    # @param shell [String] The shell type of the fenced code block.
+    #
     def self.apply_shell_filters(options, filters, shell)
       filters[:shell_expect] = shell == 'expect'
 
@@ -71,34 +98,58 @@ module MarkdownExec
       filters[:shell_exclude] = !!(shell =~ /#{options[:exclude_by_shell_regex]}/)
     end
 
+    # Applies additional filters to determine whether to include or
+    # exclude a fenced code block (FCB)
+    # based on various criteria and provided options.
+    #
+    # @param options [Hash] The options used for filtering FCBs.
+    # @param filters [Hash] The filter settings to be updated.
+    # @param fcb [Hash] The fenced code block to be evaluated.
+    #
     def self.apply_other_filters(options, filters, fcb)
-      name = fcb.fetch(:name, '')
+      name = fcb.oname
       shell = fcb.fetch(:shell, '')
       filters[:fcb_chrome] = fcb.fetch(:chrome, false)
 
-      if name.present? && options[:hide_blocks_by_name] &&
-         options[:block_name_hidden_match].present?
-        filters[:hidden_name] = !!(name =~ /#{options[:block_name_hidden_match]}/)
-      end
-
-      if shell.present? && options[:hide_blocks_by_shell] &&
-         options[:block_shell_hidden_match].present?
-        !!(shell =~ /#{options[:block_shell_hidden_match]}/)
+      if name.present? && options[:hide_blocks_by_name]
+        filters[:hidden_name] =
+          !!(options[:block_name_hidden_match].present? &&
+                    name =~ /#{options[:block_name_hidden_match]}/)
       end
+      filters[:include_name] =
+        !!(options[:block_name_include_match].present? &&
+                  name =~ /#{options[:block_name_include_match]}/)
+      filters[:wrap_name] =
+        !!(options[:block_name_wrapper_match].present? &&
+                  name =~ /#{options[:block_name_wrapper_match]}/)
 
       return unless options[:bash_only]
 
       filters[:shell_default] = (shell == 'bash')
     end
 
+    # Evaluates the filter settings to make a final decision on
+    # whether to include or exclude a fenced
+    # code block (FCB) based on the provided options.
+    #
+    # @param options [Hash] The options used for filtering FCBs.
+    # @param filters [Hash] The filter settings to be evaluated.
+    # @return [Boolean] True if the FCB should be included; false
+    # if it should be excluded.
+    #
     def self.evaluate_filters(options, filters)
-      if options[:no_chrome] && filters[:fcb_chrome]
+      if options[:no_chrome] && filters[:fcb_chrome] == true
         false
-      elsif options[:exclude_expect_blocks] && filters[:shell_expect]
+      elsif options[:exclude_expect_blocks] && filters[:shell_expect] == true
         false
       elsif filters[:hidden_name] == true
+        false
+      elsif filters[:include_name] == true
         true
-      elsif filters[:name_exclude] == true || filters[:shell_exclude] == true || filters[:name_select] == false || filters[:shell_select] == false
+      elsif filters[:wrap_name] == true
+        true
+      elsif filters[:name_exclude] == true || filters[:shell_exclude] == true ||
+            filters[:name_select] == false || filters[:shell_select] == false
         false
       elsif filters[:name_select] == true || filters[:shell_select] == true
         true
@@ -112,70 +163,95 @@ module MarkdownExec
 end
 
 if $PROGRAM_NAME == __FILE__
+  require 'bundler/setup'
+  Bundler.require(:default)
+
+  require 'fcb'
   require 'minitest/autorun'
 
-  require_relative 'tap'
-  include Tap
+  module MarkdownExec
+    class FilterTest < Minitest::Test
+      def setup
+        @options = {}
+        @fcb = FCB.new(
+          dname: nil,
+          oname: nil
+        )
+      end
 
-  class FilterTest < Minitest::Test
-    def test_no_chrome_condition
-      options = { no_chrome: true }
-      fcb = { chrome: true }
-      refute MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      # Tests for fcb_select? method
+      def test_no_chrome_condition
+        @options[:no_chrome] = true
+        @fcb[:chrome] = true
+        refute Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_exclude_expect_blocks_condition
-      options = { exclude_expect_blocks: true }
-      fcb = { shell: 'expect' }
-      refute MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_exclude_expect_blocks_condition
+        @options[:exclude_expect_blocks] = true
+        @fcb[:shell] = 'expect'
+        refute Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_hidden_name_condition
-      options = { hide_blocks_by_name: true, block_name_hidden_match: 'hidden' }
-      fcb = { name: 'hidden_block' }
-      assert MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_hidden_name_condition
+        @options[:hide_blocks_by_name] = true
+        @options[:block_name_hidden_match] = 'hidden'
+        @fcb[:oname] = 'hidden_block'
+        refute Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_name_exclude_condition
-      options = { block_name: 'test' }
-      fcb = { name: 'sample' }
-      refute MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_include_name_condition
+        @options[:hide_blocks_by_name] = true
+        @options[:block_name_indlude_match] = 'include'
+        @fcb[:oname] = 'include_block'
+        assert Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_shell_exclude_condition
-      options = { exclude_by_shell_regex: 'exclude_this' }
-      fcb = { shell: 'exclude_this_shell' }
-      refute MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_wrap_name_condition
+        @options[:hide_blocks_by_name] = true
+        @options[:block_name_wrapper_match] = 'wrap'
+        @fcb[:oname] = 'wrap_block'
+        assert Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_name_select_condition
-      options = { select_by_name_regex: 'select' }
-      fcb = { name: 'select_this' }
-      assert MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_name_exclude_condition
+        @options[:block_name] = 'test'
+        @fcb[:oname] = 'sample'
+        refute Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_shell_select_condition
-      options = { select_by_shell_regex: 'select_this' }
-      fcb = { shell: 'select_this_shell' }
-      assert MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_shell_exclude_condition
+        @options[:exclude_by_shell_regex] = 'exclude_this'
+        @fcb[:shell] = 'exclude_this_shell'
+        refute Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_bash_only_condition_true
-      options = { bash_only: true }
-      fcb = { shell: 'bash' }
-      assert MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_name_select_condition
+        @options[:select_by_name_regex] = 'select'
+        @fcb[:oname] = 'select_this'
+        assert Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_bash_only_condition_false
-      options = { bash_only: true }
-      fcb = { shell: 'zsh' }
-      refute MarkdownExec::Filter.fcb_select?(options, fcb)
-    end
+      def test_shell_select_condition
+        @options[:select_by_shell_regex] = 'select_this'
+        @fcb[:shell] = 'select_this_shell'
+        assert Filter.fcb_select?(@options, @fcb)
+      end
+
+      def test_bash_only_condition_true
+        @options[:bash_only] = true
+        @fcb[:shell] = 'bash'
+        assert Filter.fcb_select?(@options, @fcb)
+      end
 
-    def test_default_case
-      options = {}
-      fcb = {}
-      assert MarkdownExec::Filter.fcb_select?(options, fcb)
+      def test_bash_only_condition_false
+        @options[:bash_only] = true
+        @fcb[:shell] = 'zsh'
+        refute Filter.fcb_select?(@options, @fcb)
+      end
+
+      def test_default_case
+        assert Filter.fcb_select?(@options, @fcb)
+      end
     end
   end
 end

data/lib/markdown_exec/version.rb

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