tiered_category_expressions 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5501de321cdb8513c0913ceb5163822615701500
-  data.tar.gz: 24748da10d31e3f935e315582cbc98cc6c6c069f
+  metadata.gz: f0f9c42ee667e337270f971d95cc4dccb1592225
+  data.tar.gz: 665b8e13ae7e67176d111f0879a8705a5e598fb2
 SHA512:
-  metadata.gz: 6829ffcf02a4b9bc5fb9d0dd1ef0c80161fed35220eaee6689c867b817261bfcd2d2fcb8f4329a02fc4df887d706e42ccc58cadfb0dd55dda75c60450ce9cc5d
-  data.tar.gz: 49fc8d928beabb5d4a165aa5d9f4a0f7ff11156e5e11006667ed83cec416dbd5d0386f6c5785beb7e3cbbc5f9c5b49740da2349a25345f435fa0eed309d90625
+  metadata.gz: c31e3b5c6595d2be8abc3df8a13b29a7d5c0079aef2e7ed74d8a3b26e3475ca5a62106e9a4c1cf90a43052197d4ed1a1fb90abe8dd8cbc5d4806c5795b4e6afc
+  data.tar.gz: 0b7b3f3ffc5e589341f2a92568b565ee6ba5de499bec30a42d861c3366ff76c8b8ea1d671dd68e3c72d0d29d92926bd78d73a6e63a35928278994de933104576

data/LANGREF.md

@@ -1,4 +1,4 @@
-# TCE language reference
+# TCE v1.1 language reference
 
 ## Introduction
 
@@ -14,6 +14,7 @@ TCEs follow the same structure. They consist of category tier names separated by
 
   - `agf > groente`
   - `agf > groente > komkommer`
+  - `agf > groente > komkommer.`
   - `agf > groente > kom%`
   - `agf > groente | fruit > komkommer`
   - `agf > groente > !tomaat`
@@ -105,6 +106,41 @@ Note that TCEs are considered equal if they match the same categories. E.g. thes
 ["Rucola"]
 ```
 
+### Explicit last tier(s) `.`
+```ruby
+"agf > groente > komkommer."
+
+# Matches
+["AGF", "Groente", "Komkommer"]
+
+# Does not match
+["AGF", "Groente", "Komkommer", "Snack komkommer"]
+```
+
+```ruby
+"agf > groente. > komkommer"
+
+# Matches
+["AGF", "Groente"]
+["AGF", "Groente", "Komkommer"]
+["AGF", "Groente", "Komkommer", "Snack komkommer"]
+
+# Does not match
+["AGF", "Groente", "Tomaat"]
+```
+
+```ruby
+"agf > groente. > komkommer."
+
+# Matches
+["AGF", "Groente"]
+["AGF", "Groente", "Komkommer"]
+
+# Does not match
+["AGF", "Groente", "Tomaat"]
+["AGF", "Groente", "Komkommer", "Snack komkommer"]
+```
+
 ### Combining patterns
 ```ruby
 "groente > seizoensgroente > %"
@@ -142,3 +178,21 @@ Note that TCEs are considered equal if they match the same categories. E.g. thes
 ["Nonfood", "Diervoeding"]
 ["Nonfood"]
 ```
+
+```ruby
+"voeding. >> %voeding."
+
+# Matches
+["Voeding"]
+["Voeding", "Babyvoeding"]
+["Voeding", "Diervoeding"]
+["Voeding", "Baby", "Babyvoeding"]
+["Voeding", "Dier", "Diervoeding"]
+
+# Does not match
+["Voeding", "AGF"]
+["Voeding", "Babyvoeding", "Newborn"]
+["Voeding", "Diervoeding", "Hond"]
+["Voeding", "Baby", "Babyvoeding", "Newborn"]
+["Voeding", "Dier", "Diervoeding", "Hond"]
+```

data/README.md

@@ -1,6 +1,8 @@
+<img src="https://travis-ci.com/q-m/tiered_category_expressions.svg?branch=master" align="right" />
+
 # Tiered Category Expressions
 
-Work with TCEs in Ruby.
+Work with TCE v1.1 in Ruby.
 
 ## Installation
 
@@ -39,7 +41,7 @@ require 'tiered_category_expressions/core'
 
 ```ruby
 tce = TCE("groceries > nonfood | pharmacy >> !baby formula")
-# => TieredCategoryExpressions::Expression[groceries > nonfood | pharmacy >> !baby formula]
+# => TieredCategoryExpressions::Expression
 
 tce.matches?(["Groceries", "Non-food", "Cleaning", "Soap"])
 # => true
@@ -51,13 +53,13 @@ tce.matches?(["Groceries", "Pharmacy", "Baby", "Pacifiers"])
 # => true
 
 tce.to_regexp
-# => /^(groceries)>(nonfood|pharmacy)>(?!(.+>)*(babyformula)>).+>/i
+# => Regexp
 
 tce.as_regexp
-# => "^(groceries)>(nonfood|pharmacy)>(?!(.+>)*(babyformula)>).+>"
+# => String
 
 TCE("groceries > nonfood") > TCE("baby") > ">> pacifiers"
-# => TieredCategoryExpressions::Expression[groceries > nonfood > baby >> pacifiers]
+# => TieredCategoryExpressions::Expression
 ```
 
 ## Development

data/lib/tiered_category_expressions/expression.rb

@@ -36,9 +36,12 @@ module TieredCategoryExpressions
       raise ParseError, "unexpected input at character #{column}"
     end
 
+    # @param strict [Boolean] If +true+ is given then the object should not match categories with tiers that extend
+    #   beyond those specified by the TCE. This is the case when the TCE ends with ".".
     # @!visibility private
-    def initialize(tiers)
+    def initialize(tiers, strict:)
       @tiers = tiers
+      @strict = !!strict
     end
 
     # @!visibility private
@@ -46,14 +49,18 @@ module TieredCategoryExpressions
       "TieredCategoryExpressions::Expression[#{self}]"
     end
 
+    # @param implied_root [Boolean] If +true+ no leading ">" is included.
     # @return [String] String representation of the expression
-    def to_s
-      @tiers.join(" ").sub(/^>(?!>)\s*/, "") # Initial ">" is implied (but ">>" is not)
+    def to_s(implied_root: true)
+      str = @tiers.join(" ")
+      str << "." if @strict
+      str = str.sub(/^>(?!>)\s*/, "") if implied_root # Initial ">" is implied (but ">>" is not)
+      str
     end
 
     # @return [Regexp] Regexp representation of the expression as a string (does not include flags)
     def as_regexp
-      "^#{@tiers.map(&:as_regexp).join}"
+      "^#{@tiers.map(&:as_regexp).join}#{'$' if @strict}"
     end
 
     # @return [String] Regexp representation of the expression
@@ -65,6 +72,7 @@ module TieredCategoryExpressions
     #
     # @param category [Array<String>] Category to match
     # @return [Boolean]
+    #
     def matches?(category)
       to_regexp.match?(Preprocessor.call(category))
     end
@@ -89,14 +97,21 @@ module TieredCategoryExpressions
     # @return [Expression]
     #
     def >(other)
-      self.class.new(@tiers + TieredCategoryExpressions::TCE(other).tiers)
+      TieredCategoryExpressions::TCE(to_s + TieredCategoryExpressions::TCE(other).to_s(implied_root: false))
+    end
+
+    # @return [Boolean] +true+ if the TCE object does not match categories with tiers that extend beyond those
+    #   specified by the TCE. This is the case when the TCE ends with ".".
+    #
+    def strict?
+      @strict
     end
 
     # Returns an SQL LIKE query that may be used to speed up certain SQL queries.
     #
     # SQL queries that involve matching some input against stored TCE regexps can be slow. Possibly, they can be
     # optimized by applying a much faster LIKE query first, which reduces the number of regexps to apply. The LIKE
-    # query alone still yields false positives, so it must be combined with the corresponding regexp.
+    # query alone can still yield false positives, so it must be combined with the corresponding regexp.
     #
     # For instance:
     #
@@ -109,7 +124,9 @@ module TieredCategoryExpressions
     # Depending on the TCEs in the _mappings_ table.
     #
     def as_sql_like_query
-      @tiers.map(&:as_sql_like_query).join + "%"
+      q = @tiers.map(&:as_sql_like_query).join
+      q += "%" unless @strict || q.end_with?("%")
+      q
     end
 
     protected

data/lib/tiered_category_expressions/generator.rb

@@ -11,14 +11,18 @@ module TieredCategoryExpressions
       #  # => TieredCategoryExpressions::Expression[Nonfood > Baby > Baby formula]
       #
       # @param category [Array<String>]
+      # @param strict [Boolean] If +true+ is given then the resulting TCE will not match subcategories of the given
+      #   category.
       # @return [Expression, nil]
       #
-      def call(category)
+      def call(category, strict: false)
         return if category.empty?
 
         tiers = category.map { |t| sanitize_name(t) or return nil }
+        expression = tiers.join(">")
+        expression << "." if strict
 
-        TieredCategoryExpressions::TCE(tiers.join(" > "))
+        TieredCategoryExpressions::TCE(expression)
       end
 
       private

data/lib/tiered_category_expressions/parser.rb

@@ -17,9 +17,16 @@ module TieredCategoryExpressions
 
     rule(:word)      { (match["[:alnum:]"] | str("%")).repeat(1) >> space? }
     rule(:name)      { word.repeat(1).as(:name) }
-    rule(:namelist)  { (name >> (namesep >> name).repeat).as(:namelist) }
+    rule(:namelist)  { (name.repeat(1, 1) >> (namesep >> name).repeat).as(:namelist) }
+
+    rule(:stop)      { str(".") >> space? }
+
+    rule(:tier1)     { (connector | negator).maybe.as(:operator) >> namelist }
+    rule(:tier)      { connector.as(:operator) >> namelist }
+    rule(:tiers)     { tier.repeat >> (stop >> (tier.repeat(1, 1) >> tiers).as(:tail)).maybe }
+
+    rule(:tce)       { space? >> (tier1.repeat(1, 1) >> tiers).as(:tiers) >> stop.maybe.as(:eoct) }
 
-    rule(:tce)       { space? >> (((connector | negator).as(:operator).maybe >> namelist).as(:tier) >> (connector.as(:operator) >> namelist).as(:tier).repeat).as(:expression) }
     root(:tce)
   end
 end

data/lib/tiered_category_expressions/tail.rb

@@ -0,0 +1,19 @@
+module TieredCategoryExpressions
+  class Tail
+    def initialize(tiers)
+      @tiers = tiers
+    end
+
+    def to_s
+      ". " + @tiers.join(" ")
+    end
+
+    def as_regexp
+      "($|(#{@tiers.map(&:as_regexp).join}))"
+    end
+
+    def as_sql_like_query
+      "%"
+    end
+  end
+end

data/lib/tiered_category_expressions/tiers.rb

@@ -1,5 +1,18 @@
 module TieredCategoryExpressions
   class Tier < Struct.new(:operator, :namelist)
+    def self.build(operator, names)
+      klass = case operator&.to_s&.tr(" ", "")
+      when ">",  nil then Child
+      when ">!", "!" then IChild
+      when ">>"      then Descendant
+      when ">>!"     then IDescendant
+      else raise "no such operator #{operator.inspect}"
+      end
+
+      namelist = Namelist.new(names)
+      klass.new(namelist)
+    end
+
     def to_s
       "#{operator} #{namelist}"
     end
@@ -32,7 +45,7 @@ module TieredCategoryExpressions
       end
 
       def as_regexp
-        "(?!#{namelist.as_regexp}>).+>"
+        "(?!#{namelist.as_regexp}>)[a-z0-9]+>"
       end
 
       def as_sql_like_query
@@ -46,7 +59,7 @@ module TieredCategoryExpressions
       end
 
       def as_regexp
-        "(.+>)*#{namelist.as_regexp}>"
+        "([a-z0-9]+>)*#{namelist.as_regexp}>"
       end
 
       def as_sql_like_query
@@ -60,7 +73,7 @@ module TieredCategoryExpressions
       end
 
       def as_regexp
-        "(?!(.+>)*#{namelist.as_regexp}>).+>"
+        "(?!([a-z0-9]+>)*#{namelist.as_regexp}>)([a-z0-9]+>)+"
       end
 
       def as_sql_like_query

data/lib/tiered_category_expressions/transformer.rb

@@ -2,25 +2,25 @@ require "parslet"
 require "tiered_category_expressions/name"
 require "tiered_category_expressions/namelist"
 require "tiered_category_expressions/tiers"
+require "tiered_category_expressions/tail"
 require "tiered_category_expressions/expression"
 
 module TieredCategoryExpressions
   class Transformer < Parslet::Transform
-    rule(:name => simple(:name)) { Name.new(name.to_s) }
+    rule(:name => simple(:name)) do
+      Name.new(name.to_s)
+    end
 
-    rule(:tier => subtree(:tier)) do
-      klass = case tier[:operator]&.to_s&.tr(" ", "")
-      when ">",  nil then Tier::Child
-      when ">!", "!" then Tier::IChild
-      when ">>"      then Tier::Descendant
-      when ">>!"     then Tier::IDescendant
-      else raise "no such operator #{tier[:operator].inspect}"
-      end
+    rule(:operator => simple(:op), :namelist => sequence(:names)) do
+      Tier.build(op, names)
+    end
 
-      namelist = Namelist.new([tier[:namelist]].flatten)
-      klass.new(namelist)
+    rule(:tail => sequence(:tiers)) do
+      Tail.new(tiers)
     end
 
-    rule(:expression => subtree(:tiers)) { Expression.new([tiers].flatten) }
+    rule(:tiers => sequence(:tiers), :eoct => simple(:eoct)) do
+      Expression.new(tiers, strict: !!eoct)
+    end
   end
 end

data/lib/tiered_category_expressions/version.rb

@@ -1,3 +1,3 @@
 module TieredCategoryExpressions
-  VERSION = "0.1.3"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tiered_category_expressions
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Sjoerd Andringa
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-05-03 00:00:00.000000000 Z
+date: 2019-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,6 +122,7 @@ files:
 - lib/tiered_category_expressions/namelist.rb
 - lib/tiered_category_expressions/parser.rb
 - lib/tiered_category_expressions/preprocessor.rb
+- lib/tiered_category_expressions/tail.rb
 - lib/tiered_category_expressions/tiers.rb
 - lib/tiered_category_expressions/transformer.rb
 - lib/tiered_category_expressions/util.rb