marked-conductor 1.0.26 → 1.0.28

data/lib/conductor/hash.rb

@@ -1,10 +1,25 @@
 # frozen_string_literal: true
 
+# Hash helpers
 class ::Hash
+  ##
+  ## Destructive version of #symbolize_keys
+  ##
+  ## @see        #symbolize_keys
+  ##
+  ## @return     [Hash] hash with keys as symbols
+  ##
   def symbolize_keys!
     replace symbolize_keys
   end
 
+  ##
+  ## Convert all keys in hash to symbols. Works on nested hashes
+  ##
+  ## @see        #symbolize_keys!
+  ##
+  ## @return     [Hash] hash with keys as symbols
+  ##
   def symbolize_keys
     each_with_object({}) { |(k, v), hsh| hsh[k.to_sym] = (v.is_a?(Hash) || v.is_a?(Array)) ? v.symbolize_keys : v }
   end

data/lib/conductor/script.rb

@@ -22,7 +22,7 @@ module Conductor
     ## @param      path  The path
     ##
     def path=(path)
-      @path = if %r{^[%/]}.match?(path)
+      @path = if %r{^[~/.]}.match?(path)
                 File.expand_path(path)
               else
                 script_dir = File.expand_path("~/.config/conductor/scripts")
@@ -56,7 +56,7 @@ module Conductor
     ## @return     [String] script results (STDOUT)
     ##
     def run
-      stdin = Conductor.stdin
+      stdin = Conductor.stdin unless /\$\{?file\}?/.match?(args)
 
       raise "Script path not defined" unless @path
 

data/lib/conductor/string.rb

@@ -15,6 +15,11 @@ class ::String
     split(/,/).map { |s| Shellwords.shellsplit(s) }
   end
 
+  ##
+  ## Normalize positional string to symbol
+  ##
+  ## @return     [Symbol] position symbol (:start, :h1, :h2, :end)
+  ##
   def normalize_position
     case self
     when /^(be|s|t)/
@@ -28,6 +33,11 @@ class ::String
     end
   end
 
+  ##
+  ## Normalize a file include string to symbol
+  ##
+  ## @return     [Symbol] include type symbol (:code, :raw, :file)
+  ##
   def normalize_include_type
     case self
     when /^c/
@@ -61,7 +71,7 @@ class ::String
   ## @return     [Boolean] test result
   ##
   def date?
-    dup.force_encoding("utf-8").match?(/^\d{4}-\d{2}-\d{2}( \d\d:\d\d)?$/)
+    dup.force_encoding("utf-8") =~ /^\d{4}-\d{2}-\d{2}( \d{1,2}(:\d\d)? *([ap]m)?)?$/ ? true : false
   end
 
   ##
@@ -70,7 +80,7 @@ class ::String
   ## @return     [Boolean] test result
   ##
   def time?
-    dup.force_encoding("utf-8").match(/ \d{1,2}(:\d\d)? *([ap]m)?/i)
+    dup.force_encoding("utf-8") =~ / \d{1,2}(:\d\d)? *([ap]m)?/i ? true : false
   end
 
   ##
@@ -92,6 +102,11 @@ class ::String
     dup.force_encoding("utf-8").sub(/ \d{1,2}(:\d\d)? *([ap]m)?/i, "")
   end
 
+  ##
+  ## Round a date string to a day
+  ##
+  ## @param      time [Symbol]  :start or :end
+  ##
   def to_day(time = :end)
     t = time == :end ? "23:59" : "00:00"
     Chronic.parse("#{strip_time} #{t}")
@@ -134,13 +149,12 @@ class ::String
   end
 
   ##
-  ## Destructive version of #to_bool
+  ## Test if a string starts with Pandoc metadata
   ##
+  ## @return     [Boolean] test result
   ##
-  ## @see        #to_bool
-  ##
-  def to_bool!
-    replace to_bool
+  def pandoc?
+    dup.force_encoding('utf-8').match?(/^% \S/m)
   end
 
   ##
@@ -149,11 +163,40 @@ class ::String
   ## @return     [Boolean] Bool representation of the object.
   ##
   def to_bool
-    case self.force_encoding('utf-8')
+    case self.dup.force_encoding('utf-8')
     when /^[yt]/i
       true
     else
       false
     end
   end
+
+  ##
+  ## Convert a string to a regular expression
+  ##
+  ## If the string matches /xxx/, it will be interpreted
+  ## directly as a regex. Otherwise it will be escaped and
+  ## converted to regex.
+  ##
+  ## @return     [Regexp] Regexp representation of the string.
+  ##
+  def to_rx
+    if self =~ %r{^/(.*?)/([im]+)?$}
+      m = Regexp.last_match
+      regex = m[1]
+      flags = m[2]
+      Regexp.new(regex, flags)
+    else
+      Regexp.new(Regexp.escape(self))
+    end
+  end
+
+  ##
+  ## Convert a string containing $1, $2 to a Regexp replace pattern
+  ##
+  ## @return     [String] Pattern representation of the object.
+  ##
+  def to_pattern
+    gsub(/\$(\d+)/, '\\\\\1').gsub(/(^["']|["']$)/, "")
+  end
 end

data/lib/conductor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Conductor
-  VERSION = '1.0.26'
+  VERSION = "1.0.28"
 end

data/lib/conductor/{yui-compressor.rb → yui_compressor.rb}

@@ -1,42 +1,54 @@
+# frozen_string_literal: true
+#
 # This is a Ruby port of the YUI CSS compressor
 # See LICENSE for license information
 
 module YuiCompressor
   # Compress CSS rules using a variety of techniques
-
   class Yui
     attr_reader :input_size, :output_size
 
+    ##
+    ## Instantiate compressor
+    ##
+    ## @return     [Yui] self
+    ##
     def initialize
-      @preservedTokens = []
+      @preserved_tokens = []
       @comments = []
       @input_size = 0
       @output_size = 0
     end
 
+    ##
+    ## YUI Compress string
+    ##
+    ## @param      css          [String] The css
+    ## @param      line_length  [Integer] The line length
+    ##
     def compress(css, line_length = 0)
       @input_size = css.length
 
       css = process_comments_and_strings(css)
 
       # Normalize all whitespace strings to single spaces. Easier to work with that way.
-      css.gsub!(/\s+/, ' ')
+      css.gsub!(/\s+/, " ")
 
       # Remove the spaces before the things that should not have spaces before them.
       # But, be careful not to turn "p :link {...}" into "p:link{...}"
       # Swap out any pseudo-class colons with the token, and then swap back.
       css.gsub!(/(?:^|\})[^{:]+\s+:+[^{]*\{/) do |match|
-        match.gsub(':', '___PSEUDOCLASSCOLON___')
+        match.gsub(":", "___PSEUDOCLASSCOLON___")
       end
       css.gsub!(/\s+([!{};:>+()\],])/, '\1')
       css.gsub!(/([!{}:;>+(\[,])\s+/, '\1')
-      css.gsub!('___PSEUDOCLASSCOLON___', ':')
+      css.gsub!("___PSEUDOCLASSCOLON___", ":")
 
       # special case for IE
       css.gsub!(/:first-(line|letter)(\{|,)/, ':first-\1 \2')
 
       # no space after the end of a preserved comment
-      css.gsub!(%r{\*/ }, '*/')
+      css.gsub!(%r{\*/ }, "*/")
 
       # If there is a @charset, then only allow one, and push to the top of the file.
       css.gsub!(/^(.*)(@charset "[^"]*";)/i, '\2\1')
@@ -44,10 +56,10 @@ module YuiCompressor
 
       # Put the space back in some cases, to support stuff like
       # @media screen and (-webkit-min-device-pixel-ratio:0){
-      css.gsub!(/\band\(/i, 'and (')
+      css.gsub!(/\band\(/i, "and (")
 
       # remove unnecessary semicolons
-      css.gsub!(/;+\}/, '}')
+      css.gsub!(/;+\}/, "}")
 
       # Replace 0(%, em, ex, px, in, cm, mm, pt, pc) with just 0.
       css.gsub!(/([\s:])([+-]?0)(?:%|em|ex|px|in|cm|mm|pt|pc)/i, '\1\2')
@@ -56,8 +68,9 @@ module YuiCompressor
       css.gsub!(/:(?:0 )+0(;|\})/, ':0\1')
 
       # Restore background-position:0 0; if required
-      css.gsub!(/(background-position|transform-origin|webkit-transform-origin|moz-transform-origin|o-transform-origin|ms-transform-origin):0(;|\})/i) {
- "#{::Regexp.last_match(1).downcase}:0 0#{::Regexp.last_match(2)}" }
+      css.gsub!(/(background-position|(?:(?:webkit|moz|o|ms)-)?transform-origin):0(;|\})/i) do
+        "#{::Regexp.last_match(1).downcase}:0 0#{::Regexp.last_match(2)}"
+      end
 
       # Replace 0.6 with .6, but only when preceded by : or a space.
       css.gsub!(/(:|\s)0+\.(\d+)/, '\1.\2')
@@ -65,7 +78,7 @@ module YuiCompressor
       # Shorten colors from rgb(51,102,153) to #336699
       # This makes it more likely that it'll get further compressed in the next step.
       css.gsub!(/rgb\s*\(\s*([0-9,\s]+)\s*\)/) do |_match|
-        '#' << ::Regexp.last_match(1).scan(/\d+/).map {|n| n.to_i.to_s(16).rjust(2, '0') }.join
+        "#".dup << ::Regexp.last_match(1).scan(/\d+/).map { |n| n.to_i.to_s(16).rjust(2, "0") }.join
       end
 
       # Shorten colors from #AABBCC to #ABC. Note that we want to make sure
@@ -77,34 +90,35 @@ module YuiCompressor
       css.gsub!(/([^"'=\s])(\s?)\s*#([0-9a-f])\3([0-9a-f])\4([0-9a-f])\5/i, '\1\2#\3\4\5')
 
       # border: none -> border:0
-      css.gsub!(/(border|border-top|border-right|border-bottom|border-right|outline|background):none(;|\})/i) {
- "#{::Regexp.last_match(1).downcase}:0#{::Regexp.last_match(2)}" }
+      css.gsub!(/(border|border-(top|right|bottom)|outline|background):none(;|\})/i) do
+        "#{::Regexp.last_match(1).downcase}:0#{::Regexp.last_match(2)}"
+      end
 
       # shorter opacity IE filter
-      css.gsub!(/progid:DXImageTransform\.Microsoft\.Alpha\(Opacity=/i, 'alpha(opacity=')
+      css.gsub!(/progid:DXImageTransform\.Microsoft\.Alpha\(Opacity=/i, "alpha(opacity=")
 
       # Remove empty rules.
-      css.gsub!(%r{[^\};\{/]+\{\}}, '')
+      css.gsub!(%r{[^\};\{/]+\{\}}, "")
 
-      if line_length > 0
+      if line_length.positive?
         # Some source control tools don't like it when files containing lines longer
         # than, say 8000 characters, are checked in. The linebreak option is used in
         # that case to split long lines after a specific column.
-        startIndex = 0
-        index = 0
+        start_index = 0
+        idx = 0
         length = css.length
-        while index < length
-          index += 1
-          if css[index - 1, 1] === '}' && index - startIndex > line_length
-            css = css.slice(0, index) + "\n" + css.slice(index, length)
-            startIndex = index
+        while idx < length
+          idx += 1
+          if css[idx - 1, 1] == "}" && idx - start_index > line_length
+            css = "#{css.slice(0, idx)}\n#{css.slice(idx, length)}"
+            start_index = idx
           end
         end
       end
 
       # Replace multiple semi-colons in a row by a single one
       # See SF bug #1980989
-      css.gsub!(/;+/, ';')
+      css.gsub!(/;+/, ";")
 
       # restore preserved comments and strings
       css = restore_preserved_comments_and_strings(css)
@@ -116,26 +130,28 @@ module YuiCompressor
       css
     end
 
+    ##
+    ## Replace comments and strings with placeholders
+    ##
+    ## @param      css_text  [String] The css text
+    ##
+    ## @return [String] css text with strings replaced
     def process_comments_and_strings(css_text)
-      css = css_text.clone
+      css = css_text.dup.force_encoding("ISO-8859-1").encode("utf-8", replace: nil)
 
-      startIndex = 0
-      endIndex = 0
-      i = 0
-      max = 0
-      token = ''
+      start_index = 0
+      token = ""
       totallen = css.length
-      placeholder = ''
+      placeholder = ""
 
       # collect all comment blocks
-      while (startIndex = css.index(%r{/\*}, startIndex))
-        endIndex = css.index(%r{\*/}, startIndex + 2)
-        endIndex = totallen unless endIndex
-        token = css.slice(startIndex + 2..endIndex - 1)
+      while (start_index = css.index(%r{/\*}, start_index))
+        end_index = css.index(%r{\*/}, start_index + 2)
+        end_index ||= totallen
+        token = css.slice(start_index + 2..end_index - 1)
         @comments.push(token)
-        css = css.slice(0..startIndex + 1).to_s + '___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_' + (@comments.length - 1).to_s + '___' + css.slice(
-endIndex, totallen).to_s
-        startIndex += 2
+        css =  "#{css.slice(0..start_index + 1)}___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_#{@comments.length - 1}___#{css.slice(end_index, totallen)}"
+        start_index += 2
       end
 
       # preserve strings so their content doesn't get accidentally minified
@@ -146,82 +162,86 @@ endIndex, totallen).to_s
         # maybe the string contains a comment-like substring?
         # one, maybe more? put'em back then
         if string =~ /___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_/
-          @comments.each_index do |index|
-            string.gsub!(/___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_#{index}___/, @comments[index])
+          @comments.each_index do |idx|
+            string.gsub!(/___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_#{idx}___/, @comments[idx])
           end
         end
 
         # minify alpha opacity in filter strings
-        string.gsub!(/progid:DXImageTransform\.Microsoft\.Alpha\(Opacity=/i, 'alpha(opacity=')
-        @preservedTokens.push(string)
+        string.gsub!(/progid:DXImageTransform\.Microsoft\.Alpha\(Opacity=/i, "alpha(opacity=")
+        @preserved_tokens.push(string)
 
-        quote + '___YUICSSMIN_PRESERVED_TOKEN_' + (@preservedTokens.length - 1).to_s + '___' + quote
+        "#{quote}___YUICSSMIN_PRESERVED_TOKEN_#{@preserved_tokens.length - 1}___#{quote}"
       end
 
-      # used to jump one index in loop
-      ie5_hack = false
+      # # used to jump one index in loop
+      # ie5_hack = false
       # strings are safe, now wrestle the comments
-      @comments.each_index do |index|
-        if ie5_hack
-          ie5_hack = false
-          next
-        end
+      @comments.each_index do |idx|
+        # if ie5_hack
+        #   ie5_hack = false
+        #   next
+        # end
 
-        token = @comments[index]
-        placeholder = '___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_' + index.to_s + '___'
+        token = @comments[idx]
+        placeholder = "___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_#{idx}___"
 
         # ! in the first position of the comment means preserve
         # so push to the preserved tokens keeping the !
-        if token[0, 1] === '!'
-          @preservedTokens.push(token)
-          css.gsub!(/#{placeholder}/i, '___YUICSSMIN_PRESERVED_TOKEN_' + (@preservedTokens.length - 1).to_s + '___')
+        if token[0, 1] == "!"
+          @preserved_tokens.push(token)
+          css.gsub!(/#{placeholder}/i, "___YUICSSMIN_PRESERVED_TOKEN_#{@preserved_tokens.length - 1}___")
           next
         end
 
-        # \ in the last position looks like hack for Mac/IE5
-        # shorten that to /*\*/ and the next one to /**/
-        if token[-1, 1] === '\\'
-          @preservedTokens.push('\\')
-          css.gsub!(/#{placeholder}/, '___YUICSSMIN_PRESERVED_TOKEN_' + (@preservedTokens.length - 1).to_s + '___')
-          # keep the next comment but remove its content
-          @preservedTokens.push('')
-          css.gsub!(/___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_#{index + 1}___/, 
-'___YUICSSMIN_PRESERVED_TOKEN_' + (@preservedTokens.length - 1).to_s + '___')
-          ie5_hack = true
-          next
-        end
-
-        # keep empty comments after child selectors (IE7 hack)
-        # e.g. html >/**/ body
-        if (token.length === 0) && (startIndex = css.index(/#{placeholder}/))
-          if startIndex > 2
-            if css[startIndex - 3, 1] === '>'
-              @preservedTokens.push('')
-              css.gsub!(/#{placeholder}/, '___YUICSSMIN_PRESERVED_TOKEN_' + (@preservedTokens.length - 1).to_s + '___')
-            end
-          end
-        end
+        # # \ in the last position looks like hack for Mac/IE5
+        # # shorten that to /*\*/ and the next one to /**/
+        # if token[-1, 1] == "\\"
+        #   @preserved_tokens.push("\\")
+        #   css.gsub!(/#{placeholder}/, "___YUICSSMIN_PRESERVED_TOKEN_#{@preserved_tokens.length - 1}___")
+        #   # keep the next comment but remove its content
+        #   @preserved_tokens.push("")
+        #   css.gsub!(/___YUICSSMIN_PRESERVE_CANDIDATE_COMMENT_#{idx + 1}___/,
+        #             "___YUICSSMIN_PRESERVED_TOKEN_#{@preserved_tokens.length - 1}___")
+        #   ie5_hack = true
+        #   next
+        # end
+
+        # # keep empty comments after child selectors (IE7 hack)
+        # # e.g. html >/**/ body
+        # if token.empty? && (start_index = css.index(/#{placeholder}/)) &&
+        #    (start_index > 2) && (css[start_index - 3, 1] == ">")
+        #   @preserved_tokens.push("")
+        #   css.gsub!(/#{placeholder}/, "___YUICSSMIN_PRESERVED_TOKEN_#{@preserved_tokens.length - 1}___")
+        # end
 
         # in all other cases kill the comment
-        css.gsub!(%r{/\*#{placeholder}\*/}, '')
+        css.gsub!(%r{/\*#{placeholder}\*/}, "")
       end
 
       css
     end
 
+    ##
+    ## Restore saved comments and strings
+    ##
+    ## @param      clean_css  [String] The processed css
+    ##
+    ## @return     [String] restored CSS
+    ##
     def restore_preserved_comments_and_strings(clean_css)
       css = clean_css.clone
       css_length = css.length
-      @preservedTokens.each_index do |index|
+      @preserved_tokens.each_index do |idx|
         # slice these back into place rather than regex, because
         # complex nested strings cause the replacement to fail
-        placeholder = "___YUICSSMIN_PRESERVED_TOKEN_#{index}___"
-        startIndex = css.index(placeholder, 0)
-        next unless startIndex # skip if nil
+        placeholder = "___YUICSSMIN_PRESERVED_TOKEN_#{idx}___"
+        start_index = css.index(placeholder, 0)
+        next unless start_index # skip if nil
 
-        endIndex = startIndex + placeholder.length
+        end_index = start_index + placeholder.length
 
-        css = css.slice(0..startIndex - 1).to_s + @preservedTokens[index] + css.slice(endIndex, css_length).to_s
+        css = css.slice(0..start_index - 1).to_s + @preserved_tokens[idx] + css.slice(end_index, css_length).to_s
       end
 
       css

data/lib/conductor.rb

@@ -19,16 +19,108 @@ require_relative "conductor/filter"
 require_relative "conductor/script"
 require_relative "conductor/command"
 require_relative "conductor/condition"
-require_relative "conductor/yui-compressor"
+require_relative "conductor/yui_compressor"
 
+# Main Conductor module
 module Conductor
   class << self
     attr_accessor :original_input
     attr_writer :stdin
 
+    ##
+    ## Return STDIN value, reading from STDIN if needed
+    ##
+    ## @return     [String] STDIN contents
+    ##
     def stdin
-      warn "input on STDIN required" unless $stdin.stat.size.positive? || $stdin.fcntl(Fcntl::F_GETFL, 0).zero?
+      warn "input on STDIN required" unless ENV["CONDUCTOR_TEST"] || $stdin.stat.size.positive? || $stdin.fcntl(Fcntl::F_GETFL, 0).zero?
       @stdin ||= $stdin.read.force_encoding("utf-8")
     end
+
+    ##
+    ## Execute commands/scripts in the track
+    ##
+    ## @param      track  The track
+    ##
+    ## @return     Resulting STDOUT output
+    ##
+    def execute_track(track)
+      if track[:sequence]
+        track[:sequence].each do |cmd|
+          if cmd[:script]
+            script = Script.new(cmd[:script])
+
+            res = script.run
+          elsif cmd[:command]
+            command = Command.new(cmd[:command])
+
+            res = command.run
+          elsif cmd[:filter]
+            filter = Filter.new(cmd[:filter])
+
+            res = filter.process
+          end
+
+          Conductor.stdin = res unless res.nil?
+        end
+      elsif track[:script]
+        script = Script.new(track[:script])
+
+        Conductor.stdin = script.run
+      elsif track[:command]
+        command = Command.new(track[:command])
+
+        Conductor.stdin = command.run
+      elsif track[:filter]
+        filter = Filter.new(track[:filter])
+
+        Conductor.stdin = filter.process
+      end
+
+      Conductor.stdin
+    end
+
+    ##
+    ## Main function to parse conditions and
+    ##             execute actions. Executes recursively for
+    ##             sub-tracks.
+    ##
+    ## @param      tracks     The tracks to process
+    ## @param      res        The current result
+    ## @param      condition  The current condition
+    ##
+    ## @return     [Array] result, matched condition(s)
+    ##
+    def conduct(tracks, res = nil, condition = nil)
+      tracks.each do |track|
+        cond = Condition.new(track[:condition])
+
+        next unless cond.true?
+
+        # Build "matched condition" message
+        title = track[:title] || track[:condition]
+        condition ||= [""]
+        condition << title
+        condition.push(track.key?(:continue) ? " -> " : ", ")
+
+        res = execute_track(track)
+
+        if track[:tracks]
+          ts = track[:tracks]
+
+          res, condition = conduct(ts, res, condition)
+
+          next if res.nil?
+        end
+
+        break unless track[:continue]
+      end
+
+      if res&.strip == Conductor.original_input.strip
+        [nil, "No change in output"]
+      else
+        [res, condition]
+      end
+    end
   end
 end

data/marked-conductor.gemspec

@@ -9,7 +9,8 @@ Gem::Specification.new do |spec|
   spec.email = ["me@brettterpstra.com"]
 
   spec.summary = "A custom processor manager for Marked 2 (Mac)"
-  spec.description = "Conductor allows easy configuration of multiple scripts that are run as custom pre/processors for Marked based on conditional statements."
+  spec.description = "Conductor allows easy configuration of multiple scripts" \
+                     "which are run as custom pre/processors for Marked based on conditional statements."
   spec.homepage = "https://github.com/ttscoff/marked-conductor"
   spec.license = "MIT"
   spec.required_ruby_version = ">= 2.6.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: marked-conductor
 version: !ruby/object:Gem::Version
-  version: 1.0.26
+  version: 1.0.28
 platform: ruby
 authors:
 - Brett Terpstra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-24 00:00:00.000000000 Z
+date: 2024-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: awesome_print
@@ -184,7 +184,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.5.0
-description: Conductor allows easy configuration of multiple scripts that are run
+description: Conductor allows easy configuration of multiple scriptswhich are run
   as custom pre/processors for Marked based on conditional statements.
 email:
 - me@brettterpstra.com
@@ -218,7 +218,7 @@ files:
 - lib/conductor/script.rb
 - lib/conductor/string.rb
 - lib/conductor/version.rb
-- lib/conductor/yui-compressor.rb
+- lib/conductor/yui_compressor.rb
 - marked-conductor.gemspec
 - src/_README.md
 - test.sh