list_matcher 1.0.3 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bb59b6999ba70e7b3548710341764da658e460b3
-  data.tar.gz: d0781937d67e22497b6c0005497c4e734a39582a
+  metadata.gz: 621a7ac90f1ec09b2b73fd4b233f16953c0e958e
+  data.tar.gz: e8512d9fb2232a7951ee8cad6608eb082675ece6
 SHA512:
-  metadata.gz: 5e564cd5377d7018748417535b90f4fcd6347ed129ab8739590a038c8109039e1fd53b8f66ea740331cae0a2dbf48d9d55142c21f6c105106a496ff28e55f5b8
-  data.tar.gz: 5357e73c0623e503befdf927d26c11d052105368f7ad12b9325c8e0b9eb192c4430c9e1aee920a6442e58862e94a54040e02cabdd454938b39fa5cecea40688e
+  metadata.gz: 8042b06b05edacc8ecceb31ac2057c14333c4a84c6c09f83f52858368e8733a7081dfc60c2afc7775fd3b62337c79b07afd96938fdf701fc9722a6d241d74a86
+  data.tar.gz: fcade9f49ae41f514cf8078766932068c3dc44d0cb0f53b5cedbad55c6f4e689828f8650828c58e3935d75015eab784f90edd6e286caae32eff76086e92ae475

data/README.md

@@ -151,6 +151,22 @@ Each item should match the entire string compared against, so the boundary symbo
 List::Matcher.pattern %w(cat), bound: :string   # "(?:\\Acat\\z)"
 ```
 
+**NOTE** for each of these variants, `:word`, `:line`, and `:string` there are `left` and `right` subvarieties that
+only append their boundary marker to that side of the word:
+
+```ruby
+List::Matcher.pattern %w(cat), bound: :word_left     # "(?:\\bcat)"
+List::Matcher.pattern %w(cat), bound: :string_left   # "(?:\\Acat)"
+List::Matcher.pattern %w(cat), bound: :line_right    # "(?:cat$)"
+```
+
+Note also that `List::Matcher` will only append the boundary marker when it is appropriate according to
+the test, so items for which the test fails will not receive a boundary marker of any sort:
+
+```ruby
+List::Matcher.pattern %w( cat #@% ), bound: :word   # "(?:\\#@%|\\bcat\\b)"
+```
+
 ```ruby
 bound: { test: /\d/, left: '(?<!\d)', right: '(?!\d)'}
 ```
@@ -163,6 +179,9 @@ List::Matcher.pattern (1...1000).to_a, bound: { test: /\d/, left: '(?<!\d)', rig
 # "(?:(?<!\\d)[1-9](?:\\d\\d?)?(?!\\d))"
 ```
 
+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.
 

data/lib/list_matcher/version.rb

@@ -1,3 +1,3 @@
 module ListMatcher
-  VERSION = "1.0.3"
+  VERSION = "1.0.4"
 end

data/lib/list_matcher.rb

@@ -49,23 +49,40 @@ module List
           @name = name
         end
       end
-      if bound == :string
-        @word_test   = /./
-        @left_bound  = '\A'
-        @right_bound = '\z'
-      elsif bound == :line
-        @word_test   = /./
-        @left_bound  = '^'
-        @right_bound = '$'
-      elsif bound.is_a? Hash
-        @word_test   = bound[:test]  || raise(SyntaxError.new('no boundary test provided'))
-        @left_bound  = bound[:left]  || raise(SyntaxError.new('no left boundary expression provided'))
-        @right_bound = bound[:right] || raise(SyntaxError.new('no right boundary expression provided'))
-      elsif bound === true || bound == :word
+      case bound
+      when TrueClass
         @word_test   = /\w/
         @left_bound  = '\b'
         @right_bound = '\b'
-      elsif !( bound === false )
+      when FalseClass
+      when Symbol
+        case bound
+        when :string, :string_left, :string_right
+          @word_test   = /./
+          @left_bound  = '\A'
+          @right_bound = '\z'
+        when :line, :line_left, :line_right
+          @word_test   = /./
+          @left_bound  = '^'
+          @right_bound = '$'
+        when :word, :word_left, :word_right
+          @word_test   = /\w/
+          @left_bound  = '\b'
+          @right_bound = '\b'
+        else
+          raise "unfamiliar value for :bound option: #{bound.inspect}"
+        end
+        if /_left/ === bound.to_s
+          @right_bound = nil
+        elsif /_right/ === bound.to_s
+          @left_bound = nil
+        end
+      when Hash
+        @word_test   = bound[:test] || raise('no boundary test provided')
+        @left_bound  = bound[:left]
+        @right_bound = bound[:right]
+        raise 'neither bound provided' unless @left_bound || @right_bound
+      else
         raise "unfamiliar value for :bound option: #{bound.inspect}"
       end
       symbols.keys.each do |k|
@@ -339,12 +356,16 @@ module List
           end
         end
         if engine.bound
-          c = ( max += 1 ).chr
-          @left = SpecialPattern.new engine, c, c, engine.left_bound
-          @specials << @left
-          c = ( max += 1 ).chr
-          @right = SpecialPattern.new engine, c, c, engine.right_bound
-          @specials << @right
+          if engine.left_bound
+            c = ( max += 1 ).chr
+            @left = SpecialPattern.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
+            @specials << @right
+          end
         end
       end
 
@@ -384,11 +405,11 @@ module List
               p = specials.detect{ |sp| sp.var === p }
               special_map[p.char] = p
               if engine.bound
-                if i == 0 && p.left
+                if i == 0 && engine.left_bound && p.left
                   p = "#{left}#{p}" if t
                   l = true
                 end
-                if i == e && p.right
+                if i == e && engine.right_bound && p.right
                   p = "#{p}#{right}"
                   r = true
                 end
@@ -396,11 +417,11 @@ module List
             else
               p = p.downcase if engine.case_insensitive
               if engine.bound
-                if i == 0 && engine.word_test === p[0]
+                if i == 0 && engine.left_bound && engine.word_test === p[0]
                   p = "#{left}#{p}"
                   l = true
                 end
-                if i == e && engine.word_test === p[-1]
+                if i == e && engine.right_bound && engine.word_test === p[-1]
                   p = "#{p}#{right}"
                   r = true
                 end

data/test/basic_test.rb

@@ -149,6 +149,16 @@ class BasicTest < Minitest::Test
     assert ' cat ' !~ rx, 'word boundaries do not suffice'
   end
 
+  def test_string_left_bound
+    rx = List::Matcher.pattern ['cat'], bound: :string_left
+    assert_equal '(?:\Acat)', rx
+  end
+
+  def test_string_right_bound
+    rx = List::Matcher.pattern ['cat'], bound: :string_right
+    assert_equal '(?:cat\z)', rx
+  end
+
   def test_line_bound
     rx = List::Matcher.pattern ['cat'], bound: :line
     assert_equal '(?:^cat$)', rx
@@ -158,6 +168,31 @@ class BasicTest < Minitest::Test
     assert ' cat ' !~ rx, 'word boundaries do not suffice'
   end
 
+  def test_line_left_bound
+    rx = List::Matcher.pattern ['cat'], bound: :line_left
+    assert_equal '(?:^cat)', rx
+  end
+
+  def test_line_right_bound
+    rx = List::Matcher.pattern ['cat'], bound: :line_right
+    assert_equal '(?:cat$)', rx
+  end
+
+  def test_word_bound
+    rx = List::Matcher.pattern %w( cat dog ), bound: :word
+    assert_equal '(?:\b(?:cat|dog)\b)', rx
+  end
+
+  def test_word_left_bound
+    rx = List::Matcher.pattern %w( cat dog ), bound: :word_left
+    assert_equal '(?:\b(?:cat|dog))', rx
+  end
+
+  def test_word_right_bound
+    rx = List::Matcher.pattern %w( cat dog ), bound: :word_right
+    assert_equal '(?:(?:cat|dog)\b)', rx
+  end
+
   def test_dup_atomic
     m = List::Matcher.new atomic: true
     rx = m.pattern %w( cat dog ), atomic: false

data/test/doc_test.rb

@@ -99,6 +99,10 @@ class DocTest < Minitest::Test
     assert_nil date_20th_century.match('this is not actually a date')
     assert_equal "(?:\\#\\ is\\ sometimes\\ called\\ the\\ pound\\ symbol|cat\\ and\\ dog)", (List::Matcher.pattern [ 'cat and dog', '# is sometimes called the pound symbol' ])
     assert_equal "(?-x:cat and dog|# is sometimes called the pound symbol)", (List::Matcher.pattern [ 'cat and dog', '# is sometimes called the pound symbol' ], not_extended: true)
+    assert_equal "(?:\\bcat)", List::Matcher.pattern( %w(cat), bound: :word_left )
+    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 )
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: list_matcher
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 1.0.4
 platform: ruby
 authors:
 - dfhoughton
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-18 00:00:00.000000000 Z
+date: 2015-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler