list_matcher 1.0.5 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34630b608a56f9a22605ff55956ed8da7793ed73
-  data.tar.gz: 160a5e81d4c9e3bbd0ba2a516e97a0ec9048d27f
+  metadata.gz: 393f3b81be1503c0af7b583119e063ff2c91276a
+  data.tar.gz: 66a79b3b020f17b9da3fcd6a8465c8b5966088ac
 SHA512:
-  metadata.gz: 5a1523c2c3a36424bd76ba465345466993404c4e3b3e4e531b7ca2b9ea3765e392567df809f188af3bcb2ab8f58d1fe8c21b1dae3eed1087133f9d68767b922e
-  data.tar.gz: 917e5620134c0726880ba789db20bfe39f850ce11493d2cea17f690bbc5501ec18f5c66f72e41c8b745051e1776c341f86a8805c4e74b48db6486061c8706dc9
+  metadata.gz: 23e71cd30a236c5a247d2f6e12c6e9f7bd5f3adb3c1dcf2c4eff781561ed7ec1bb123a720e9161dc6dba7d597c315c0bdac403663a0bb68b2fb957863cce30ef
+  data.tar.gz: db2306c5f2cf514961971566446de1de8e746fe157b472f8314c6a82f24063b4d7c1bb0c7ed4e632108ce4ef253c00e1c69c3b74c4e6d5cc64530c2035c4287a

data/README.md

@@ -192,9 +192,6 @@ List::Matcher.pattern (1...1000).to_a, bound: { test: /\d/, left: '(?<!\d)', rig
 As with the predefined boundaries -- `:word_left`, `:line_right`, `:string_left`, etc. -- you can bound items only at one
 margin, in this case by providing only the `left:` or `right:` key-value pair.
 
-**NOTE** Because boundary tests cannot be applied to symbols, the bound option will give you strange results if you use it
-with a list any of whose items have a symbol at their leading or trailing margin.
-
 ### strip 
 
 ```ruby
@@ -271,6 +268,38 @@ List::Matcher.pattern [ 'Catch foo', 'foo', 'Fahrenheit foo' ], symbols: { foo:
 Because it is possible for symbol sequences to overlap, sequences with string or symbol keys are evaluated before `Regexps`, and longer keys are
 evaluated before shorter ones.
 
+`List::Matcher` doesn't parse regex strings to determine whether they need to be grouped before any iteration suffix
+can be added or to determine whether it is sensible to add boundary sequences before or after them. By default it assumes
+that they need grouping if they repeat and that boundary markers don't make sense. You can override this behavior, however.
+You specify the characteristics of the pattern as a hash with the following keys:
+
+**`:pattern`**
+
+The value is the pattern to substitute for the symbol.
+
+**`:atomic`**
+
+The pattern needs no grouping if the value is true.
+
+**`:left`**
+
+A character to test for the left boundary condition.
+
+**`:right`**
+
+A character to test for the right boundary condition.
+
+For example:
+
+```ruby
+List::Matcher.pattern %w(dddd ddddddd), 
+  bound: :word, 
+  symbols: { d: { pattern: '\d', atomic: true, left: '0', right: '0' } },   # <-- this
+  atomic: false
+
+# \b\d{4}(?:\d{3})?\b
+```
+
 ### name
 
 If you assign your pattern a name, it will be constructed with a named group such that you can extract
@@ -311,11 +340,12 @@ date_20th_century = m.rx(
   ],
   normalize_whitespace: true,
   atomic: true,
+  bound:  true,
   symbols: {
-    year: year,
-    mday: mday,
-    wday: wday,
-    mo:   mo
+    year: { pattern: year, atomic: true, left: '1', right: '1' },
+    mday: { pattern: mday, atomic: true, left: '1', right: '1' },
+    wday: { pattern: wday, atomic: true, left: 'a', right: 'a' },
+    mo:   { pattern: mo,   atomic: true, left: 'a', right: 'a' }
   }
 )
 

data/lib/list_matcher.rb

@@ -197,7 +197,7 @@ module List
     def tree(list, symbols)
       if list.size == 1
         leaves = list[0].chars.map do |c|
-          symbols.symbols(c) || Leaf.new( self, c )
+          symbols[c] || Leaf.new( self, c )
         end
         if leaves.length == 1
           leaves.first
@@ -205,7 +205,7 @@ module List
           Sequence.new self, *leaves
         end
       elsif list.all?{ |w| w.length == 1 }
-        chars = list.select{ |w| !symbols.symbols(w) }
+        chars = list.select{ |w| !symbols[w] }
         if chars.size > 1
           list -= chars
           c = CharClass.new self, chars
@@ -231,7 +231,7 @@ module List
         Sequence.new self, c1, c2
       else
         grouped = list.group_by{ |w| w[0] }
-        chars = grouped.select{ |_, w| w.size == 1 && w[0].size == 1 && !symbols.symbols(w[0]) }.map{ |v, _| v }
+        chars = grouped.select{ |_, w| w.size == 1 && w[0].size == 1 && !symbols[w[0]] }.map{ |v, _| v }
         if chars.size > 1
           list -= chars
           c = CharClass.new self, chars
@@ -257,7 +257,7 @@ module List
         Hash[o.map{ |k, v| [ deep_dup(k), deep_dup(v) ] }]
       elsif o.is_a?(Array)
         o.map{ |v| deep_dup v }
-      elsif o.nil? || o.is_a?(Symbol)
+      elsif o.nil? || o.is_a?(Symbol) || o.is_a?(TrueClass) || o.is_a?(FalseClass)
         o
       else
         o.dup
@@ -326,11 +326,9 @@ module List
     end
 
     class Special
-      attr_reader :engine
+      attr_reader :engine, :special_map
       attr_accessor :specials, :list, :left, :right
 
-      NULL = Regexp.new '(?!)'
-
       def initialize( engine, specials, list )
         @engine = engine
         @list = list
@@ -360,11 +358,11 @@ module List
               pat = opts.delete :pattern
               raise Error, "symbol #{var} requires a pattern" unless pat || var.is_a?(Regexp)
               pat ||= var.to_s
-              SpecialPattern.new engine, c, var, pat, **opts
+              SymbolPattern.new engine, c, var, pat, **opts
             elsif opts.is_a? String
-              SpecialPattern.new engine, c, var, opts
+              SymbolPattern.new engine, c, var, opts
             elsif var.is_a?(Regexp) && opts.nil?
-              SpecialPattern.new engine, c, var, nil
+              SymbolPattern.new engine, c, var, nil
             else
               raise Error, "symbol #{var} requires a pattern"
             end
@@ -374,15 +372,16 @@ module List
         if engine.bound
           if engine.left_bound
             c = ( max += 1 ).chr
-            @left = SpecialPattern.new engine, c, c, engine.left_bound
+            @left = SymbolPattern.new engine, c, c, engine.left_bound
             @specials << @left
           end
           if engine.right_bound
             c = ( max += 1 ).chr
-            @right = SpecialPattern.new engine, c, c, engine.right_bound
+            @right = SymbolPattern.new engine, c, c, engine.right_bound
             @specials << @right
           end
         end
+        @special_map = Hash[@specials.map{ |s| [ s.char, s ] }]
       end
 
       # confirm that all special patterns are legitimate regexen
@@ -396,58 +395,51 @@ module List
         end
       end
 
-      def special_map
-        @special_map ||= {}
-      end
-
-      def symbols(s)
+      # maps a symbol character back to the symbol object
+      def [](s)
         special_map[s]
       end
 
       # reduce the list to a version ready for pattern generation
       def normalize
         rx = if specials.empty?
-          NULL
+          /(?!)/
         else
           Regexp.new '(' + specials.map(&:var).map(&:to_s).join('|') + ')'
         end
-        l = r = false
         list = self.list.uniq.map do |w|
-          parts = w.split rx
+          parts = w.split(rx).select{ |p| p.length > 0 }
           e = parts.size - 1
           (0..e).map do |i|
             p = parts[i]
             if rx === p
               p = specials.detect{ |sp| sp.var === p }
-              special_map[p.char] = p
               if engine.bound
-                if i == 0 && engine.left_bound && p.left
-                  p = "#{left}#{p}" if t
-                  l = true
+                s = p
+                if i == 0 && engine.left_bound && engine.word_test === p.left
+                  s = "#{left}#{s}"
                 end
-                if i == e && engine.right_bound && p.right
-                  p = "#{p}#{right}"
-                  r = true
+                if i == e && engine.right_bound && engine.word_test === p.right
+                  s = "#{s}#{right}"
                 end
+                p = s
               end
             else
               p = p.downcase if engine.case_insensitive
               if engine.bound
+                s = p
                 if i == 0 && engine.left_bound && engine.word_test === p[0]
-                  p = "#{left}#{p}"
-                  l = true
+                  s = "#{left}#{s}"
                 end
                 if i == e && engine.right_bound && engine.word_test === p[-1]
-                  p = "#{p}#{right}"
-                  r = true
+                  s = "#{s}#{right}"
                 end
+                p = s
               end
             end
             p
           end.join
         end.uniq.sort
-        special_map[left.char] = left if l
-        special_map[right.char] = right if r
         list
       end
     end
@@ -522,29 +514,21 @@ module List
 
     end
 
-    class SpecialPattern < Node
+    class SymbolPattern < Node
       attr_accessor :char, :var, :left, :right, :pat, :symbol
-      def initialize(engine, char, var, pat, atomic: (var.is_a?(Regexp) && pat.nil?), word_left: false, word_right: false)
+      def initialize(engine, char, var, pat, atomic: (var.is_a?(Regexp) && pat.nil?), left: nil, right: nil)
         super(engine, nil)
         @char   = char
         @symbol = var.to_s
         @var    = var.is_a?(String) || var.is_a?(Symbol) ? Regexp.new(Regexp.quote(var.to_s)) : var
         @pat    = pat || var.to_s
         @atomic = !!atomic
-        @left   = !!word_left
-        @right  = !!word_right
+        @left   = left
+        @right  = right
       end
 
       def dup
-        self.class.new engine, char, var, pat, atomic: atomic?, word_left: left?, word_right: right?
-      end
-
-      def left?
-        @left
-      end
-
-      def right?
-        @right
+        self.class.new engine, char, var, pat, atomic: atomic?, left: left, right: right
       end
 
       def atomic?

data/lib/list_matcher/version.rb

@@ -1,3 +1,3 @@
 module ListMatcher
-  VERSION = "1.0.5"
+  VERSION = "1.0.6"
 end

data/test/basic_test.rb

@@ -289,4 +289,24 @@ class BasicTest < Minitest::Test
     assert rx === ' '
     assert rx === '#'
   end
+
+  def test_symbol_bound
+    rx = List::Matcher.pattern %w(1 2 3 d), bound: :word, symbols: { d: { pattern: '\d{4}', left: '0', right: '0' } }, atomic: false
+    assert_equal '\b(?:[1-3]|\d{4})\b', rx
+  end
+
+  def test_symbol_bound_left
+    rx = List::Matcher.pattern %w(1 2 3 d), bound: :word_left, symbols: { d: { pattern: '\d{4}', left: '0', right: '0' } }, atomic: false
+    assert_equal '\b(?:[1-3]|\d{4})', rx
+  end
+
+  def test_symbol_bound_right
+    rx = List::Matcher.pattern %w(1 2 3 d), bound: :word_right, symbols: { d: { pattern: '\d{4}', left: '0', right: '0' } }, atomic: false
+    assert_equal '(?:[1-3]|\d{4})\b', rx
+  end
+
+  def test_sort_bound_word
+    rx = List::Matcher.pattern %w(a), bound: :word, atomic: false
+    assert_equal '\ba\b', rx
+  end
 end

data/test/doc_test.rb

@@ -68,11 +68,12 @@ class DocTest < Minitest::Test
       ],
       normalize_whitespace: true,
       atomic: true,
+      bound:  true,
       symbols: {
-        year: year,
-        mday: mday,
-        wday: wday,
-        mo:   mo
+        year: { pattern: year, atomic: true, left: '1', right: '1' },
+        mday: { pattern: mday, atomic: true, left: '1', right: '1' },
+        wday: { pattern: wday, atomic: true, left: 'a', right: 'a' },
+        mo:   { pattern: mo,   atomic: true, left: 'a', right: 'a' }
       }
     )
 
@@ -103,6 +104,12 @@ class DocTest < Minitest::Test
     assert_equal "(?:\\Acat)", List::Matcher.pattern( %w(cat), bound: :string_left )
     assert_equal "(?:cat$)", List::Matcher.pattern( %w(cat), bound: :line_right )
     assert_equal "(?:\\#@%|\\bcat\\b)", List::Matcher.pattern( %w( cat #@% ), bound: :word )
+    rx = List::Matcher.pattern %w(dddd ddddddd), 
+      bound: :word, 
+      symbols: { d: { pattern: '\d', atomic: true, left: '0', right: '0' } },   # <-- this
+      atomic: false
+    assert_equal '\b\d{4}(?:\d{3})?\b', rx
+
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: list_matcher
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
 platform: ruby
 authors:
 - dfhoughton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-02 00:00:00.000000000 Z
+date: 2015-09-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler