term_color 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6271321446e52dfcff7f4ed2e996586653731e79103a94504910df3823b1ec48
-  data.tar.gz: 4bde610a032d25a836096bb389163c66d2dcacb81ad7c605366fbbf0dab491f0
+  metadata.gz: 5ca92238dae771cacd8dd2165975e084ac10aac980cdb3ce36f52da3d76742e4
+  data.tar.gz: 2e800af8a7aefbc39895d29ac25a8dcc67501b9a48a7827d76fbc017ae6ae9fc
 SHA512:
-  metadata.gz: d9d58ee125d900d753fe50574b61c5314bb9d78c5e2ec7a2e350bf9913f3ce3c00e7ffdd5cff49fe7c2075c2e85c3ea24073c9246dcd216c214c3210035e0062
-  data.tar.gz: 70d3f8cebf1834534a991c8c82ab17975103b1c346f03fa8527ccf58d128a9613c0ff866e95fcd2c234b9008b0d6ddf8bf81d0c586be078032e696e7b5256643
+  metadata.gz: 3bc3d2a0e78014e06c21d0be5ed18a5ca081c712ee456080b4eddca3c216b75e5986d2b909807d6e286edbcb3236626183a5f4a9af61465659b3ca6fb2cc376f
+  data.tar.gz: dd06e1eba2e21496090f4681b7c4c79dcd80a5211dba25129cf106a181ce0df26cd68c1298c12afac53a20ec05546abac2025d8fc4be9f3751a0ec2e56f92cbf

data/README.md

@@ -2,6 +2,8 @@
 
 Rule-based text coloring/styling library for terminal text
 
+[![Gem Version](https://badge.fury.io/rb/term_color.svg)](https://badge.fury.io/rb/term_color)
+
 ## Overview
 
 ### Justifying Features
@@ -16,11 +18,40 @@ Rule-based text coloring/styling library for terminal text
 
 ## Concepts/Syntax
 
-Rules are grouped into `RuleSets`, which are represented by instances of {TermColor::RuleSet}.
+Rules are grouped into `RuleSets`, which are represented by instances of {TermColor::RuleSet}. Rules are applied to text using tag strings indicating start and end of rule application. There is also a tag that can be used outside of rule application to fully reset all styling options to system default.
+
+### Tags
+
+_The 'tag' strings used to specify start and end of ranges of text to apply a rule to can be customized in the `RuleSet` constructor. These details assume the defaults are used._
+
+- Open: `{%<rule name>`
+    - Ex: `{%rule1`
+- Close: `%}`
+- Reset: `%@`
+    - Only usable outside of tags. Resets all styling to default even if a previously used rule is configured to keep styling applied after close
+
+```ruby
+# Rules named :a and :b
+"Unstyled {%a Styled with a %} Normal {%bStyled with b%} normal %@ fully reset"
+```
+
+Rules can be nested. When an inner rule tag is closed, the styling of the any outer/unclosed tags will be re-applied from outer most to inner most.
+
+```ruby
+"{%aRule A{%bRule A+B{%cRule A+B+C%}A+B%}A%} Normal"
+```
+
+### Rule Sets
 
-### Rule Set
+Rule Sets contain named styling rules, any override options you chose to use (`after` behavior, open/close/reset symbols). Instances of `RuleSet` also provide methods for processing and displaying text with style tag markup via methods like `print` and `printf`
 
-A set is constructed from a Hash of rule, where they keys are rule names and the values are the rule definition hashes.
+Gemeral Usage:
+
+```ruby
+rs = TermColor.create_rule_set(<rules hash>, <named options>)
+```
+
+Constructor:
 
 ```ruby
 rules = {
@@ -33,6 +64,13 @@ rule_set = TermColor.create_rule_set(rules)
 rule_set = TermColor::RuleSet.new(rules)
 ```
 
+#### Constructor Options
+
+- `after` - Override default 'after' rule (controlling what gets reset after a style tag is closed). Default is `:auto`, which automatically determines what styling to removed based on the rule being closed
+    - `:reset` - Causes all colors and styling to be reset on close
+    - `:keep` - Causes nothing to get reset
+    - Custom Hash - Allows you to specify your own after rule as a hash containing properties valid for `after` sections (`[:fg,:bg,:reset,:enable,:disable]`)
+
 #### Applying to Text
 
 Once you've got a `RuleSet` instance, calling its `apply` or `print`/`printf` methods with a string parameter will give back a copy of that string with styles applied
@@ -43,63 +81,116 @@ __Methods__
 - `print` - {TermColor::RuleSet#print}
 - `printf` - {TermColor::RuleSet#printf}
 
-__Use__
+### Rule Definitions
 
-- To apply a style to a section of the input string, surround it with `%rule_name` and `%%`
-    - E.g.: `"%titleTitle Text%%"`
-    - `%%` indicates the end of rule application, after which any `after` rules will get applied
-    - Including `%%` when no rule is active will apply the `default` rule's `:after` options, which can either be overridden in your rule set, or make use of the built-in version which simply resets all colors and text styling to system default
-- Rule application can be nested (`"%titleTitle of %otherBook%%%%"`)
+A Rule definition is a hash consisting of two parts, `inside` and `after`. `inside` dictates styling that gets applied to text between the open and close tags for the rule, `after` allows you to override what happens when that tag closes (overrides default `after` rule as specified in constructor).
 
-### Rule Definitions
+The `after` part, when used, must always be a hash in the rule definition assigned to the key `:after`. Everything else will be automatically grouped into a `inside` key/value if not explicitly specified.
+
+```ruby
+r = { inside: { fg: :red }, after: { keep: :fg }}
+r = { fg: :red, bg: :blue }
+r = { after: { reset: :all}  }
+```
+
+### Rule Options/Actions
 
-_For more details on rule definitions, see {file:docs/rule_dsl.md Rule DSL} ([View on GitHub](https://github.com/vdtdev/term_color/blob/master/docs/rule_dsl.md))_
+#### Colors
 
-Rule definitions are just hashes that include rule options. The included options can be divided into `:inside` (applied to text rule is applied to) and `:after` (applied to text following text rule is applied to). If neither of these sub hashes are included, all options are treated as being for `:inside`, and an `:after` set is auto-generated to unapply style changes made inside rule for following text. To prevent an `:after` section from being automatically generated, either include your own `:after` section or include `after: {}`. 
+##### Attributes
+
+- `fg` - Change foreground color
+- `bg` - Change background color
+
+##### Values
+
+###### Standard Named Colors
+
+Color values can be color-name symbols as defined in {TermColor::Rule::Colors} (`:black, :red, :yellow, :blue, :magenta, :cyan, :white`)
+
+###### XTerm 256 Color Values
+
+To use XTerm 256 Color Mode values, include the color code integer inside a single item array. (E.g. for code `208`, use `[208]`)
+
+###### XTerm 16m Color Values
+
+To use XTerm 16m Color Mode RGB colors, include the red, green and blue color values in an ordered array (E.g. for 80 red, 80 green, 255 blue, use `[80,80,255]`)
+
+#### Styles
+
+##### Actions
+
+- `enable` - Style(s) to enable (Can be single item or array)
+- `disable` - Style(s) to disable (Can be single item or array)
+
+##### Values
+
+(See symbols in {TermColor::Rule::Styles})
+
+- `:bold`/`:intense`
+- `:dim`/`:dark`
+- `:italic`
+- `:underline`
+- `:inverse`
+- `:hidden`
+- `:strikethrough`
+
+#### Reset / Keep
+
+_(Only valid in `after` section)_
+
+Quick way of resetting one or more style rules. `reset`/`keep` can be given a single symbol or an array of symbols.
+
+`keep` will be ignored if included in default after rule
 
 ```ruby
-# No groups, after will be generated
-rule = { fg: :red }
-# Same as above but with groups. after will be generated
-rule = { inside: { fg: :red } }
-# No groups, skip after generation by setting it to 
-# empty hash of options
-rule = { fg: :red, after: {} }
-# Both groups, same as others but with explicitly set after options,
-# no auto-generation
-rule = { inside: { fg: :red }, after: { reset: :fg } }
+{ reset: [options] }
+{ keep: [options] }
 ```
 
-For more details on rule definitions, see {file:docs/rule_dsl.md Rule DSL} ([View on GitHub]{https://github.com/vdtdev/term_color/blob/master/docs/rule_dsl.md})
+#### Options
 
-## Examples
+- `:fg` / `:bg` - Reset foreground / background color
+- `:style` - Reset all styling
+- `:all` - Reset all colors and styling
 
 [If example images are missing, view readme on github](https://github.com/vdtdev/term_color/blob/master/README.md)
 
-### Basic
+## Examples
+
+_If images don't show up, try viewing on [Github](https://github.com/vdtdev/term_color/blob/master/README.md)_
+
+### Basic w/ Nesting (`:auto` after mode)
 
 ```ruby
 rule_set = TermColor.create_rule_set({
-    opt: { fg: :cyan },
-    err: { fg: :red }
+    yellow: { fg: :yellow },
+    ul: { enable: :ul },
+    err: { fg: :white, bg: :red, enable: [:italic] }
 })
 
-rule_set.printf "%errInvalid%% option: %opt%s%%\n", "fruit"
+rule_set.print "Test Score: {%yellow65%}\n"
+rule_set.print "{%ul{%err{%yellowNOTE:%}" +
+    "Your score is below a passing grade%}X%}\n"
 ```
 
 ![](./file/docs/example_1.png)
 ![](./docs/example_1.png)
 
-### Nested /w XTerm RGB
+### With `:keep` after mode
 
 ```ruby
 rule_set = TermColor.create_rule_set({
-    title: { fg: :yellow, enable: :underline },
-    emph: { fg: [0xa0,0xa0,0xff], enable: :italic },
-    author: { fg: :green, bg: :blue, enable: :bold }
-})
-
-rule_set.print "book: %%titleHarry Potter (%emph%%)%% by %authorJ. K. Rowling%%\n"
+    g: { fg: :green },
+    i: { enable: :inverse },
+    f: { fg: :yellow, after: { reset: :fg }}
+}, after: :keep)
+
+rule_set.print "{%gTitle%}\n"
+rule_set.print "{%i>%}"
+(1..5).each {|i| print "#{i}\n" }
+rule_set.print "{%fThis style reverts after closing%}\n"
+rule_set.print "Before Reset%@After Reset\n"
 ```
 
 ![](./file/docs/example_2.png)

data/lib/term_color/rule.rb

@@ -12,9 +12,9 @@ module TermColor
     #   # Insize: (`a:`) Foreground yellow, bg red, dark style on
     #   # After: Resets all color and style options to default,
     #   # including those set by other rules
-    #   rule = { 
+    #   rule = {
     #       a: {
-    #           fg: :yellow, bg: :red, enable: :dark 
+    #           fg: :yellow, bg: :red, enable: :dark
     #       },
     #       z: {
     #           reset: :all
@@ -45,23 +45,23 @@ module TermColor
                 ##
         # Numerical modifiers used with Color Values
         # to target foreground or background.
-        # 
+        #
         # - For {Colors Named Standard Colors}, value is added to given
         #   color's numerical value
         # - For XTerm 256/16m color codes, value is added to mode base
-        # 
+        #
         # @example Named Standard Color Background
         #   { bg: :red } #=> 40 + 1 = 41
         # @example XTerm 256 Foreground
         #   { fg: [208] } #=> 8 + 30 = 38
-        ColorTargets = { 
+        ColorTargets = {
             fg: 30, # Foreground target
             bg: 40  # Background target
         }.freeze
 
         ##
         # Style option constants
-        # (Values that can be included in style `enable` and `disable` 
+        # (Values that can be included in style `enable` and `disable`
         # rule option attributes)
         Styles = {
             bold: 1,
@@ -75,6 +75,7 @@ module TermColor
             italic: 3,
             underline: 4,
             inverse: 7,
+            hidden: 8,
             strikethrough: 9
         }.freeze
 
@@ -85,12 +86,12 @@ module TermColor
         # was used)
         # @example Disable italic
         #   (:disable) + (:italic) #=> 20 + 3 = 23
-        StyleActions = { 
+        StyleActions = {
             # Enable style(s) action
             enable: 0,
             # Disable style(s) action
-            disable: 20 
-        }
+            disable: 20
+        }.freeze
 
         ##
         # Reset option constants
@@ -101,9 +102,17 @@ module TermColor
             # Reset foreground color only
             fg: 39,
             # Reset background color only
-            bg: 49
+            bg: 49,
+            # Reset style
+            style: StyleActions[:disable]
         }.freeze
 
+        ##
+        # Operations associated with reset
+        ResetOps = [ :reset, :keep ].freeze
+
+        ResetsExtra = [ :style ].freeze
+
         ##
         # Descriptive aliases for part names
         Parts = {
@@ -111,7 +120,7 @@ module TermColor
             inside: :inside,
             # Style appled when rule close is given
             after: :after
-        }
+        }.freeze
 
         ##
         # Valid rule operations mapped to accepted const values
@@ -126,13 +135,38 @@ module TermColor
             # Disable style(s) action
             disable: Styles.keys,
             # Reset action
-            reset: [
-                :fg,    # Reset fg color 
-                :bg,    # Reset bg color
-                :style, # Reset all styles
-                :all    # Reset colors and styles
-            ]
-        }
+            reset: Resets.keys,
+            # Keep action (opposite of reset)
+            keep: Resets.keys
+        }.freeze
+
+        ##
+        # Normalize rules for ops; either `:keep` to
+        # not change original value, or `:array` to
+        # wrap single value inside array
+        OpNormalize = {
+          fg: :keep,
+          bg: :keep,
+          enable: :array,
+          disable: :array,
+          reset: :array,
+          keep: :array
+        }.freeze
+
+        ##
+        # Allowed ops by part
+        PartOps = {
+          inside: [:fg, :bg, :enable, :disable],
+          after: [:fg, :bg, :enable, :disable, :reset, :keep]
+        }.freeze
+
+        ##
+        # Operations allowed within 'after'
+        AfterOps = (Ops.filter{|k,v| PartOps[:after].include?(k)}).freeze
+
+        ##
+        # Operations allowed within 'inside'
+        InsideOps = (Ops.filter {|k,v| PartOps[:inside].include?(k)}).freeze
 
         ##
         # Value added to ColorTarget when using XTerm colors
@@ -167,10 +201,13 @@ module TermColor
         ##
         # Compile rule into frozen instance of `Compiled` struct
         # @param [Hash] rule Rule hash
+        # @param [RuleSet] rs Rule set
+        # @param [Boolean] is_reset Set to true to indicate rule is for reset
+        #   operation, and should ignore default after resolution
         # @return [Compiled] Frozen instance of `Compiled` struct
         #   containing compiled rule
-        def compile(rule)
-            evaluated = evaluate(rule)
+        def compile(rule, rs, is_reset=false)
+            evaluated = evaluate(rule,rs,is_reset)
             return Compiled.new(
                 rule,
                 evaluated,
@@ -201,16 +238,16 @@ module TermColor
                 end
             end
             codes = codes.flatten.compact.uniq
-        end                
+        end
 
         def resolve_color(color, target = :fg)
             if color.is_a?(Array)
                 color = color[0..2]
                 return xterm_color(color, target)
             end
-                
+
             if !color.is_a?(Integer)
-                
+
                 if color.is_a?(Hash) && ColorsAdvanced.keys.include?(color.keys[0])
                     return self.method(ColorsAdvanced[color.keys[0]]).call(color.values[0])
                 end
@@ -223,7 +260,10 @@ module TermColor
             if !style.is_a?(Integer)
                 style = Styles[style.to_sym].to_i
             end
-            (style + StyleActions[state.to_sym].to_i)
+            s_code = (style + StyleActions[state.to_sym].to_i)
+            # adjust so bold and dim both get 22
+            s_code = [s_code, StyleActions[:disable] + 2].max if state == :disable
+            return s_code
         end
 
         def resolve_reset(target)
@@ -257,15 +297,16 @@ module TermColor
         # Evaluate rule, returning new hash containing list of numerical
         # codes to use for inside (`:inside`) and after (`:after`)
         # @param [Hash] rule Rule hash to evaluate
+        # @param [RuleSet] rs Rule set
         # @return [Hash] evaluated version of rule, containing code numbers
-        def evaluate(rule)
+        def evaluate(rule, rs, is_reset)
             # error if not hash
             return nil if !rule.is_a?(Hash)
 
             inside_part_key = Parts[:inside]
             after_part_key = Parts[:after]
             rule_keys = rule.keys.map{|k|k.to_sym}
-            
+
             # Find 'inside' rule options
             if rule_keys.include?(inside_part_key)
                 # 'inside' key explicitly defined, so pull from that
@@ -279,15 +320,15 @@ module TermColor
             # Find 'after' rule options, using nil if not present
             # This means that if it is defined but as an empty hash,
             # no 'after' rule options will be auto-generated
-            after_part = rule.fetch(after_part_key, nil)
-
-            # Auto-generate 'after' rule options if not explicitly defined
-            if after_part.nil?
-                resets = inside_part.keys.filter { |k| ColorTargets.keys.include?(k) }
-                disables = inside_part.fetch(:enable, [])
-                after_part = {}
-                after_part[:reset] = resets if resets.length > 0
-                after_part[:disable] = disables if disables.length > 0
+            after_part = rule.fetch(after_part_key, {})
+
+            # Resolve after, either from template mixed with any
+            # overrides or an automatically generated version mixed with
+            # overrides
+            if rs.default_after == :auto
+                after_part = build_auto_after(inside_part, after_part)
+            else
+                after_part = override_after(inside_part, after_part, rs.default_after)
             end
 
             parts = {}
@@ -296,9 +337,100 @@ module TermColor
             parts[after_part_key] = evaluate_ops(after_part)
 
             return parts.merge({evaluated: true})
+        end
+
+        def normalize_part(hash,part,clean=false)
+            h = hash.dup
+            PartOps[part].each do |o|
+                if OpNormalize[o] == :array
+                h[o] = [h.fetch(o,[])].flatten
+                else
+                h[o] = h.fetch(o,nil)
+                end
+            end
+            
+            if clean
+                h = h.filter {|k,v| (v.is_a?(Array))? v.length > 0 : !v.nil? }
+            end
+            
+            return h
+        end
+        
+        def override_after(inside, override, after)
+            c_ovr = normalize_part(override, :after)
+            c_aft = normalize_part(after, :after)
+            c_inside = normalize_part(inside, :inside)
+            
+            # change reset :all to specific resets
+            if c_aft[:reset].include?(:all)
+                c_aft[:reset] = Resets.keys - [:all]
+            end
+            # change keep :all to specific resets
+            if c_ovr[:keep].include?(:all)
+                c_ovr[:keep] = Resets.keys - [:all]
+            end
+            
+            c_aft[:reset] = (c_aft[:reset] + c_ovr[:reset]).uniq
+            # remove keeps from resets
+            c_aft[:reset] -= c_ovr[:keep]
+            
+            # clear disable if keep :style
+            if c_ovr[:keep].include?(:style) ||
+                c_aft[:disable] = []
+            end
+            
+            # if override disables styles, remove blanket style reset
+            if c_ovr[:disable].length >= 1
+                c_aft[:reset] -= [:style]
+            end
+
+            # replace reset :style with style specific targets
+            if c_inside[:enable].length > 0 && c_aft[:reset].include?(:style)
+                c_aft[:reset] -= [:style]
+                c_aft[:disable] += c_inside[:enable]
+                c_aft[:enable] -= c_inside[:enable]
+            end
 
+            # If we've reached this point with reset :style, change it into
+            # disables
+            if c_aft[:reset].include?(:style)
+                c_aft[:reset] -= [:style]
+                c_aft[:disable] += Styles.keys
+            end
+            
+            # prevent enables from conflicting with disables
+            en = (c_aft[:enable] + c_ovr[:enable] - c_ovr[:disable]).uniq
+            di = (c_aft[:disable] + c_ovr[:disable] - c_ovr[:enable]).uniq
+            
+            en -= di
+            di -= en
+            
+            result = { enable: en, disable: di, reset: c_aft[:reset] }
+            ColorTargets.keys.each do |k|
+                val = (c_ovr[k] || c_aft[k])
+                result[k] = val unless val.nil?
+            end
+            
+            return normalize_part(result, :after, true)
         end
         
+        def build_auto_after(inside, after={})
+            c_inside = normalize_part(inside, :inside)
+            n_after = normalize_part({}, :after)
+            
+            if c_inside[:enable].length > 0
+                n_after[:reset] += [:style]
+            end
+            
+            ColorTargets.keys.each do |k|
+                if !c_inside[k].nil?
+                    n_after[:reset] += [k]
+                end
+            end
+
+            override_after(inside, after, n_after)
+        end
+
         ##
         # Return ANSI color codes from evaluated rule
         # @param [Hash] rule Full rule
@@ -313,4 +445,4 @@ module TermColor
             }
         end
     end
-end
+end

data/lib/term_color/rule_set.rb

@@ -5,24 +5,60 @@ module TermColor
     # @license MIT
     class RuleSet
 
+        DBG = false
+
         ##
-        # Symbol used as prefix for rule name to denote rule start
-        RULE_SYMBOL='%'
+        # Default rule symbols
+        DEFAULT_SYMBOLS = {
+          open: '{%',
+          close: '%}',
+          reset: '%@'
+        }.freeze
+
         ##
-        # String used to denote rule close / reset
-        RESET_SYMBOL='%%'
+        # Default reset rule
+        DEFAULT_RESET_RULE = {after: {reset: :all} }.freeze
 
-        DEFAULT_RESET_RULE = {z: {reset: :all} }
+        ##
+        # After preset options
+        AFTER_PRESETS = {
+          # Full reset
+          reset: {reset: :all},
+          # Automatically determine what to toggle off
+          auto: :auto,
+          # No reset
+          keep: {keep: :all}
+        }
 
-        attr_reader :rules, :regexs
+        ##
+        # Struct for rule and reset symbols
+        SymbolOptions = Struct.new(:open,:close,:reset)
+
+        ##
+        # Default after preset choice
+        DEFAULT_AFTER = :auto
+
+        attr_reader :rules, :regexs, :default_after, :symbols
 
         ##
         # Construct new rule set
         # @param [Hash] rules Hash of rule names mapping to rule hashes,
-        #   which can define before rules (`a:`), after rules (`z:`) or both.
-        #   - If neither are given, content is treated as though it was inside a `a:` key.
-        #   - If `a:` only is given, {TermColor::Rule#evaluate Rule evaluate method} attempts to
-        #       auto guess `z:`, resetting any used color or style rules from `a:`
+        #   which can define before rules (`inside:`), after rules (`after:`) or both.
+        #   - If neither are given, content is treated as though it was inside a `inside:` key.
+        #   - If `inside:` only is given, {TermColor::Rule#evaluate Rule evaluate method} attempts to
+        #       auto guess `after:`, resetting any used color or style rules from `inside:`
+        # @param [Hash] opts Optional arguments
+        # @option opts [Hash|Symbol] :after Override default `:after` rule behavior when rule has no `after:`
+        #   Options:
+        #   - `:reset` - Reset all color and styles
+        #   - `:auto` (default) - Try to automatically determine what to reset based on applied colors/styles
+        #   - `:keep` - Keel all rule styles intact
+        #   - (`Hash`) - Custom rule (formatted as Rule `after` prop, e.g. `{ reset: :fg, keep: :style }`)
+        # @option opts [Hash] :symbols Override styling symbols
+        #   Options:
+        #   - `:open` - Rule open symbol (used as symbolRulename) (default `{%`)
+        #   - `:close` - Rule close symbol (default `%}`)
+        #   - `:reset` - Symbol that can be used between rule blocks to fully reset everything (default `%@`)
         # @see TermColor::Rule
         # @example
         #   rules = RuleSet.new({
@@ -33,10 +69,10 @@ module TermColor
         #       quote: { enable: :italic },
         #       # A weird rule that will make fg red inside rule,
         #       # and change fg to blue after rule block ends
-        #       weird: { a: { fg: :red }, z: { fg: :blue }}
+        #       weird: { inside: { fg: :red }, after: { fg: :blue }}
         #   })
         #
-        #   print rules.colorize("%nameJohn%%: '%%quoteRoses are %%weirdRed%% (blue)%%.\n")
+        #   print rules.colorize("{%nameJohn%}: '{%quoteRoses are {%weirdRed%} (blue)%}.\n")
         #   # Result will be:
         #   #   fg green+underline "John"
         #   #   regular ":  "
@@ -44,9 +80,23 @@ module TermColor
         #   #   fg red (still italic) "Red"
         #   #   (fg blue)(still italic) "(blue)"
         #   #   (regular) "."
-        def initialize(rules)
+        def initialize(rules={}, **opts)
+            if rules.nil?
+              rules = opts
+              opts = {}
+            end
             @base_rules = rules
-            @base_rules[:default] = @base_rules.fetch(:default, DEFAULT_RESET_RULE)
+            @base_rules[:reset] = @base_rules.fetch(:reset, DEFAULT_RESET_RULE)
+            # binding.pry
+            after = opts.fetch(:after, nil)
+            after = DEFAULT_AFTER if after.nil? || (after.is_a?(Symbol) && !AFTER_PRESETS.has_key?(after))
+            @default_after = (after.is_a?(Hash))? after : AFTER_PRESETS[after]
+            sym_opts = opts.fetch(:symbols,{})
+            @symbols = SymbolOptions.new(
+              sym_opts.fetch(:open, DEFAULT_SYMBOLS[:open]),
+              sym_opts.fetch(:close, DEFAULT_SYMBOLS[:close]),
+              sym_opts.fetch(:reset, DEFAULT_SYMBOLS[:reset])
+            )
             evaluate_rules
             build_regexs
         end
@@ -57,33 +107,54 @@ module TermColor
         # @return [String] Text with ANSI style codes injected
         def apply(text)
             raw = process_text(text)
-            last_rule = nil
+            rule_stack = []
             str = ''
+            rule_names = @rules.keys
             raw.each do |r|
-                if r.is_a?(Symbol)
-                    # if (r == :close_rule && !last_rule.nil?)
-                    #     str.concat(Rule.codes(@rules[last_rule][:z]))
-                    #     last_rule = nil
-                    # elsif  r == :default
-                    #     str.concat(Rule.codes(@rules[r][:z]))
-                    #     last_rule = nil
-                    # else
-                    #     last_rule = r
-                    #     str.concat(Rule.codes(@rules[r][:a]))
-                    # end
-                    if (r == :default) && !last_rule.nil?
-                        str.concat(@rules[last_rule].codes(Rule::Parts[:after]))
-                        last_rule = nil
-                    elsif  r == :default
-                        str.concat(@rules[r].codes(Rule::Parts[:after]))
-                        last_rule = nil
-                    else
-                        last_rule = r
-                        str.concat(@rules[r].codes(Rule::Parts[:inside]))
+              if r.is_a?(Symbol)
+                # Part is a rule
+                dprint "\tRule Symbol #{r}\n"
+                if r == :close && rule_stack.length >= 1
+                  # Rule close with 1+ opened rules
+                  opened = rule_stack.pop
+                  opened_after = @rules[opened].codes(Rule::Parts[:after])
+                  dprint "\t\tClose, opened rule '#{opened}'\n"
+                  dprint "\t\t\tClosing rule '#{opened}' with After\n"
+                  dprint 4,"After: #{opened_after.inspect}\n"
+                  str.concat(opened_after)
+                  unless rule_stack.length == 0
+                    rule_stack.each do |outer|
+                      outer_inside = @rules[outer].codes(Rule::Parts[:inside])
+                      # Closed rule was nested in another open rule
+                      dprint 3, "Outer rule '#{outer}' still open. Restoring Inside\n"
+                      dprint 4, "Inside: #{outer_inside.inspect}\n}"
+                      str.concat(outer_inside)
                     end
-                else
-                    str.concat(r)
+                  end
+                    # binding.pry
+                    # outer = rule_stack[-1]
+                    # outer_inside = @rules[outer].codes(Rule::Parts[:inside])
+                    # # Closed rule was nested in another open rule
+                    # dprint 3, "Outer rule '#{outer}' still open. Restoring Inside\n"
+                    # dprint 4, "Inside: #{outer_inside.inspect}\n}"
+                    # str.concat(outer_inside)
+                    # # binding.pry
+                  # end
+                elsif r == :reset && rule_stack.length == 0
+                  # no opened outer rules, reset symbol given
+                  dprint "\t\tReset, no opened rule\n"
+                  str.concat(@rules[r].codes(Rule::Parts[:after]))
+                elsif rule_names.include?(r)
+                  # New rule to apply
+                  dprint "\t\tApplying new rule '#{r}'\n"
+                  dprint 3, "Previous active rule `#{rule_stack[-1]}`\n"
+                  rule_stack.push r
+                  str.concat(@rules[r].codes(Rule::Parts[:inside]))
                 end
+              else
+                # Part is text
+                str.concat(r)
+              end
             end
             str
         end
@@ -104,7 +175,7 @@ module TermColor
         # Wraps STDOUT printf method, passing output of `apply` to `print`
         # Doesn't actually use `printf`, instead passes result of
         # `format_string % args` to `print`.
-        # @param [String] format_string printf format string, 
+        # @param [String] format_string printf format string,
         #   including TermColor style tags
         # @param [Array] args printf values to use with format string
         # @param [Hash] opts Optional params
@@ -115,23 +186,35 @@ module TermColor
 
             # Sanitize rule symbols
             sanitized = format_string.dup
-            @rules.keys.each { |k| sanitized.gsub!("#{RULE_SYMBOL}#{k.to_s}","#{255.chr}#{k.to_s}") }
-            sanitized.gsub!(RESET_SYMBOL, 255.chr*2)
-            
+            @rules.keys.each { |k| sanitized.gsub!("#{@symbols.rule}#{k.to_s}","#{255.chr}#{k.to_s}") }
+            sanitized.gsub!(@symbols.reset, 255.chr*2)
+
             t = sanitized % args
             # Reinstate rule symbols
-            @rules.keys.each { |k| t.gsub!("#{255.chr}#{k.to_s}","#{RULE_SYMBOL}#{k.to_s}") }
-            t.gsub!(255.chr*2,RESET_SYMBOL)
-            
+            @rules.keys.each { |k| t.gsub!("#{255.chr}#{k.to_s}","#{@symbols.rule}#{k.to_s}") }
+            t.gsub!(255.chr*2,@symbols.reset)
+
             stdout.print apply(t)
         end
-            
+
         private
 
+        def dprint(*v)
+          if DBG
+            if v.length == 2
+              tc,t=v
+              tabs = "\t" * tc
+              print "#{tabs}#{t}"
+            else
+              print v[0]
+            end
+          end
+        end
+
         def evaluate_rules
             @rules = {}
             @base_rules.each_pair do |k,v|
-                @rules[k] = Rule.compile(v)
+                @rules[k] = Rule.compile(v, self)
             end
         end
 
@@ -140,11 +223,14 @@ module TermColor
             src = @rules
             src.each_pair do |k,v|
                 @regexs[k] = Regexp.compile(
-                    "(?<#{k.to_s}>(#{RULE_SYMBOL}#{k.to_s}))"
+                    "(?<#{k.to_s}>(#{@symbols.open}#{k.to_s}))"
                 )
             end
-            @regexs[:default] = Regexp.compile(
-                "(?<default>(#{RESET_SYMBOL}))"
+            @regexs[:close] = Regexp.compile(
+                "(?<default>(#{@symbols.close}))"
+            )
+            @regexs[:reset] = Regexp.compile(
+                "(?<default>(#{@symbols.reset}))"
             )
         end
 
@@ -203,7 +289,7 @@ module TermColor
                 if !is_last
                     end_pos = locations[i+1][:begin] - 1
                 end
-    
+
                 working << l[:symbol]
                 working << text[l[:continue_pos]..end_pos]
             end
@@ -211,4 +297,4 @@ module TermColor
         end
 
     end
-end
+end

data/lib/term_color.rb

@@ -9,8 +9,10 @@ module TermColor
     ##
     # Alias for constructing a new RuleSet
     # @see TermColor::RuleSet
-    def create_rule_set(rules={})
-        TermColor::RuleSet.new(rules)
+    def create_rule_set(rules=nil,**opts)
+      TermColor::RuleSet.new(rules,opts)
     end
 
-end
+
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: term_color
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Wade H.
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-26 00:00:00.000000000 Z
+date: 2020-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -46,7 +46,7 @@ licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/vdtdev/term_color
-  documentation_uri: https://rubydoc.info/gems/term_color/0.0.2
+  documentation_uri: https://rubydoc.info/gems/term_color/0.0.3
 post_install_message: 
 rdoc_options: []
 require_paths: