praxis 2.0.pre.11 → 2.0.pre.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7bbd374311046cf8d12c68d564382de6cbfd0c1032c45bbc8c1ac00d7a02e68a
-  data.tar.gz: e33676f45266facdbcae595c2c05ca94ae8dfa34134aa9e4113e5a5d9d729052
+  metadata.gz: cf4b54b686373509e0920a93d482e29f4c198491f88d382b6ff429e5128d6574
+  data.tar.gz: '08b2d7342069e8584676e03c828e144b99eb9282b193113b987d8060cb143cfd'
 SHA512:
-  metadata.gz: 5db86e95bd0b723560036435ded99b893fd92bd55f20dc4b49e326d96e7c9422549124ba986eb3248ff746d6bf928a60e6677b854c8761a34c026c7430a578bb
-  data.tar.gz: 39677f252617f79d3d054fd2286562d3355310d8161096c7c73294d2b242cee4ebdf749b462d7f1c5261fc487e80ba473dcd258dcb77a510c47db7e698275cad
+  metadata.gz: ef7cd7fe985d4af76cf7ec6459e58990b8dbc6f3c4fac5c26ce04d56e23a3d743a0f4bb776f4d5c913224e031567e9993ad52e611e4258ee853cdf86b3099255
+  data.tar.gz: f4fe45f97c9bc26aa513a24ee358b04dc114af0e7f4849071f699c0c22df460253452dd54e9bcb510fc4f977aa9104774f70c882f46b8aa937404e79814d6f3d

data/.ruby-version

@@ -1 +1 @@
-2.6.3
+2.7.1

data/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## next
 
+## 2.0.pre.12
+
+* Rebuilt API filters to support a much richer syntax. One can now use ANDs and ORs (with ANDs having order precedence), as well as group them with parenthesis. The same individual filter operands are supported. For example: 'email=*@gmail.com&(friends.first_name=Joe*,Patty|friends.last_name=Smith)
+
 ## 2.0.pre.11
 
 - Remove MapperPlugin's `set_selectors` (made `selector_generator` lazy instead), and ensure it includes the rendering extensions to the Controllers. Less things to configure if you opt into the Mapper way.

data/lib/praxis/extensions/attribute_filtering/active_record_filter_query_builder.rb

@@ -23,14 +23,16 @@ module Praxis
       end
 
       class ActiveRecordFilterQueryBuilder
-      attr_reader :query, :model, :filters_map
+      attr_reader :model, :filters_map
 
         # Base query to build upon
         def initialize(query: , model:, filters_map:, debug: false)
-          @query = query
+          # Note: Do not make the initial_query an attr reader to make sure we don't count/leak on modifying it. Easier to mostly use class methods
+          @initial_query = query
           @model = model
           @filters_map = filters_map
           @logger = debug ? Logger.new(STDOUT) : nil
+          @active_record_version_maj = ActiveRecord.gem_version.segments[0]
         end
         
         def debug_query(msg, query)
@@ -40,26 +42,97 @@ module Praxis
         def generate(filters)
           # Resolve the names and values first, based on filters_map
           root_node = _convert_to_treenode(filters)
-          craft_filter_query(root_node, for_model: @model)
-          debug_query("SQL due to filters: ", @query.all)
-          @query
+          crafted = craft_filter_query(root_node, for_model: @model)
+          debug_query("SQL due to filters: ", crafted.all)
+          crafted
         end
 
         def craft_filter_query(nodetree, for_model:)
           result = _compute_joins_and_conditions_data(nodetree, model: for_model)
-          @query = query.joins(result[:associations_hash]) unless result[:associations_hash].empty?
+          return @initial_query if result[:conditions].empty?
 
-          result[:conditions].each do |condition|
-            filter_name = condition[:name]
-            filter_value = condition[:value]
+          
+          # Find the root group (usually an AND group) but can be an OR group, or nil if there's only 1 condition
+          root_parent_group = result[:conditions].first[:node_object].parent_group || result[:conditions].first[:node_object]
+          while root_parent_group.parent_group != nil
+            root_parent_group = root_parent_group.parent_group
+          end
+
+          # Process the joins
+          query_with_joins = result[:associations_hash].empty? ? @initial_query : @initial_query.joins(result[:associations_hash])
+
+          # Proc to apply a single condition
+          apply_single_condition = Proc.new do |condition, associated_query|
+            colo = condition[:model].columns_hash[condition[:name].to_s]
             column_prefix = condition[:column_prefix]
+            #Mark where clause referencing the appropriate alias
+            associated_query = associated_query.references(build_reference_value(column_prefix, query: associated_query))
+            self.class.add_clause(
+              query: associated_query, 
+              column_prefix: column_prefix, 
+              column_object: colo, 
+              op: condition[:op], 
+              value: condition[:value]
+            )
+          end
 
-            colo = condition[:model].columns_hash[filter_name.to_s]
-            add_clause(column_prefix: column_prefix,  column_object: colo, op: condition[:op], value: filter_value)
+          if @active_record_version_maj < 6
+            # ActiveRecord < 6 does not support '.and' so no nested things can be done
+            # But we can still support the case of 1+ flat conditions of the same AND/OR type
+            if root_parent_group.is_a?(FilteringParams::Condition)
+              # A Single condition it is easy to handle
+              apply_single_condition.call(result[:conditions].first, query_with_joins)
+            elsif root_parent_group.items.all?{|i| i.is_a?(FilteringParams::Condition)}
+              # Only 1 top level root, with only with simple condition items
+              if root_parent_group.type == :and
+                result[:conditions].reverse.inject(query_with_joins) do |accum, condition|
+                  apply_single_condition.call(condition, accum)
+                end
+              else
+                # To do a flat OR, we need to apply the first condition to the incoming query
+                # and then apply any extra ORs to it. Otherwise Book.or(X).or(X) still matches all books
+                cond1, *rest = result[:conditions].reverse
+                start_query = apply_single_condition.call(cond1, query_with_joins)
+                rest.inject(start_query) do |accum, condition|
+                  accum.or(apply_single_condition.call(condition, query_with_joins))
+                end
+              end
+            else
+              raise "Mixing AND and OR conditions is not supported for ActiveRecord <6."
+            end
+          else #  ActiveRecord 6+
+            # Process the conditions in a depth-first order, and return the resulting query
+            _depth_first_traversal(
+              root_query: query_with_joins, 
+              root_node: root_parent_group, 
+              conditions: result[:conditions], 
+              &apply_single_condition
+            )
           end
         end
 
         private
+        def _depth_first_traversal(root_query:, root_node:, conditions:, &block)
+          # Save the associated query for non-leaves 
+          root_node.associated_query = root_query if root_node.is_a?(FilteringParams::ConditionGroup)
+          
+          if root_node.is_a?(FilteringParams::Condition)
+            matching_condition = conditions.find {|cond| cond[:node_object] == root_node }
+
+            # The simplified case of a single top level condition (without a wrapping group)
+            # will need to pass the root query itself
+            associated_query = root_node.parent_group ? root_node.parent_group.associated_query : root_query
+            return yield matching_condition, associated_query
+          else
+            first_query, *rest_queries = root_node.items.map do |child|
+              _depth_first_traversal(root_query: root_query, root_node: child, conditions: conditions, &block)
+            end
+
+            rest_queries.each.inject(first_query) do |q, a_query|
+              root_node.type == :and ? q.and(a_query) : q.or(a_query)
+            end
+          end
+        end
 
         def _mapped_filter(name)
           target = @filters_map[name]
@@ -89,7 +162,9 @@ module Praxis
               if mapped_value.is_a?(Proc)
                 result = mapped_value.call(filter)
                 # Result could be an array of hashes (each hash has name/op/value to identify a condition)
-                result.is_a?(Array) ? result : [result]
+                result_from_proc = result.is_a?(Array) ? result : [result]
+                # Make sure we tack on the node object associated with the filter
+                result_from_proc.map{|hash| hash.merge(node_object: filter[:node_object])}
               else
                 # For non-procs there's only 1 filter and 1 value (we're just overriding the mapped value)
                 [filter.merge( name: mapped_value)]
@@ -117,51 +192,51 @@ module Praxis
           {associations_hash: h, conditions: conditions}
         end
 
-        def add_clause(column_prefix:, column_object:, op:, value:)
-          @query = @query.references(build_reference_value(column_prefix)) #Mark where clause referencing the appropriate alias
+        def self.add_clause(query:, column_prefix:, column_object:, op:, value:)
           likeval = get_like_value(value)
           case op
-            when '!' # name! means => name IS NOT NULL (and the incoming value is nil)
-              op = '!='
-              value = nil # Enforce it is indeed nil (should be)
-            when '!!'
-              op = '='
-              value = nil # Enforce it is indeed nil (should be)
+          when '!' # name! means => name IS NOT NULL (and the incoming value is nil)
+            op = '!='
+            value = nil # Enforce it is indeed nil (should be)
+          when '!!'
+            op = '='
+            value = nil # Enforce it is indeed nil (should be)
+          end
+
+          case op
+          when '='
+            if likeval
+              add_safe_where(query: query, tab: column_prefix, col: column_object, op: 'LIKE', value: likeval)
+            else
+              quoted_right = quote_right_part(query: query, value: value, column_object: column_object, negative: false)
+              query.where("#{quote_column_path(query: query, prefix: column_prefix, column_object: column_object)} #{quoted_right}")
             end
-          @query =  case op
-                    when '='
-                      if likeval
-                        add_safe_where(tab: column_prefix, col: column_object, op: 'LIKE', value: likeval)
-                      else
-                        quoted_right = quote_right_part(value: value, column_object: column_object, negative: false)
-                        query.where("#{quote_column_path(column_prefix, column_object)} #{quoted_right}")
-                      end
-                    when '!='
-                      if likeval
-                        add_safe_where(tab: column_prefix, col: column_object, op: 'NOT LIKE', value: likeval)
-                      else
-                        quoted_right = quote_right_part(value: value, column_object: column_object, negative: true)
-                        query.where("#{quote_column_path(column_prefix, column_object)} #{quoted_right}")
-                      end
-                    when '>'
-                      add_safe_where(tab: column_prefix, col: column_object, op: '>', value: value)
-                    when '<'
-                      add_safe_where(tab: column_prefix, col: column_object, op: '<', value: value)
-                    when '>='
-                      add_safe_where(tab: column_prefix, col: column_object, op: '>=', value: value)
-                    when '<='
-                      add_safe_where(tab: column_prefix, col: column_object, op: '<=', value: value)
-                    else
-                      raise "Unsupported Operator!!! #{op}"
-                    end
-        end
-
-        def add_safe_where(tab:, col:, op:, value:)
+          when '!='
+            if likeval
+              add_safe_where(query: query, tab: column_prefix, col: column_object, op: 'NOT LIKE', value: likeval)
+            else
+              quoted_right = quote_right_part(query: query, value: value, column_object: column_object, negative: true)
+              query.where("#{quote_column_path(query: query, prefix: column_prefix, column_object: column_object)} #{quoted_right}")
+            end
+          when '>'
+            add_safe_where(query: query, tab: column_prefix, col: column_object, op: '>', value: value)
+          when '<'
+            add_safe_where(query: query, tab: column_prefix, col: column_object, op: '<', value: value)
+          when '>='
+            add_safe_where(query: query, tab: column_prefix, col: column_object, op: '>=', value: value)
+          when '<='
+            add_safe_where(query: query, tab: column_prefix, col: column_object, op: '<=', value: value)
+          else
+            raise "Unsupported Operator!!! #{op}"
+          end
+        end
+
+        def self.add_safe_where(query:, tab:, col:, op:, value:)
           quoted_value = query.connection.quote_default_expression(value,col)
-          query.where("#{quote_column_path(tab, col)} #{op} #{quoted_value}")
+          query.where("#{self.quote_column_path(query: query, prefix: tab, column_object: col)} #{op} #{quoted_value}")
         end
 
-        def quote_column_path(prefix, column_object)
+        def self.quote_column_path(query:, prefix:, column_object:)
           c = query.connection
           quoted_column = c.quote_column_name(column_object.name)
           if prefix
@@ -172,7 +247,7 @@ module Praxis
           end
         end
 
-        def quote_right_part(value:, column_object:, negative:)
+        def self.quote_right_part(query:, value:, column_object:, negative:)
           conn = query.connection
           if value.nil?
             no = negative ? ' NOT' : ''
@@ -190,7 +265,7 @@ module Praxis
         end
 
         # Returns nil if the value was not a fuzzzy pattern
-        def get_like_value(value)
+        def self.get_like_value(value)
           if value.is_a?(String) && (value[-1] == '*' || value[0] == '*')
             likeval = value.dup
             likeval[-1] = '%' if value[-1] == '*'
@@ -203,14 +278,14 @@ module Praxis
         maj, min, _ = ActiveRecord.gem_version.segments
         if maj == 5 || (maj == 6 && min == 0)
           # In AR 6 (and 6.0) the references are simple strings
-          def build_reference_value(column_prefix)
+          def build_reference_value(column_prefix, query: nil)
             column_prefix
           end
         else
           # The latest AR versions discard passing references to joins when they're not SqlLiterals ... so let's wrap it
           # with our class, so that it is a literal (already quoted), but that can still provide the expected "symbol" without quotes
           # so that our aliasing code can match it.
-          def build_reference_value(column_prefix)
+          def build_reference_value(column_prefix, query:)
             QuasiSqlLiteral.new(quoted: query.connection.quote_table_name(column_prefix), symbolized: column_prefix.to_sym)
           end
         end

data/lib/praxis/extensions/attribute_filtering/filter_tree_node.rb

@@ -3,7 +3,8 @@ module Praxis
     module AttributeFiltering
       class FilterTreeNode
         attr_reader :path, :conditions, :children
-        #   # parsed_filters is an Array of {name: X, op: , value: } ... exactly the format of the FilteringParams.load method
+        # Parsed_filters is an Array of {name: X, op: Y, value: Z} ... exactly the format of the FilteringParams.load method
+        # It can also contain a :node_object
         def initialize(parsed_filters, path: [])
           @path = path # Array that marks the tree 'path' to this node (with respect to the absolute root)
           @conditions = [] # Conditions to apply directly to this node
@@ -14,7 +15,7 @@ module Praxis
             if components.empty?
               return
             elsif components.size == 1
-              @conditions << hash.slice(:name, :op, :value)
+              @conditions << hash.slice(:name, :op, :value, :node_object)
             else
               children_data[components.first] ||= []
               children_data[components.first] << hash

data/lib/praxis/extensions/attribute_filtering/filtering_params.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
-# rubocop:disable all
+require 'praxis/extensions/attribute_filtering/filters_parser'
+
 #
-# Attributor type to define and handlea simple language to express filtering attributes in listings.
+# Attributor type to define and handle the language to express filtering attributes in listings.
 # Commonly used in a query string parameter value for listing calls.
 # 
 # The type allows you to restrict the allowable fields (and their types) based on an existing Mediatype.
@@ -14,7 +15,7 @@
 # attribute :filters,
 #           Types::FilteringParams.for(MediaTypes::MyType) do
 #   filter 'user.id', using: ['=', '!=']
-#   filter 'name', using: ['=', '!=']
+#   filter 'name', using: ['=', '!=', '!', '!!]
 #   filter 'children.created_at', using: ['>', '>=', '<', '<=']
 #   filter 'display_name', using: ['=', '!='], fuzzy: true
 # end
@@ -26,6 +27,8 @@ module Praxis
         include Attributor::Type
         include Attributor::Dumpable
   
+        attr_reader :parsed_array
+
         class DSLCompiler < Attributor::DSLCompiler
           # "account.id": { operators: ["=", "!="] },
           # name:         { operators: ["=", "!="], fuzzy_match: true },
@@ -36,9 +39,9 @@ module Praxis
           end
         end
   
-        VALUE_REGEX = /[^,&]*/
-        AVAILABLE_OPERATORS = Set.new(['!=', '>=', '<=', '=', '<', '>','!','!!']).freeze
-        FILTER_REGEX = /(?<attribute>([^=!><])+)(?<operator>!=|>=|<=|!!|=|<|>|!)(?<value>#{VALUE_REGEX}(,#{VALUE_REGEX})*)/
+        VALUE_OPERATORS = Set.new(['!=', '>=', '<=', '=', '<', '>']).freeze
+        NOVALUE_OPERATORS = Set.new(['!','!!']).freeze
+        AVAILABLE_OPERATORS = Set.new(VALUE_OPERATORS+NOVALUE_OPERATORS).freeze
   
         # Abstract class, which needs to be used by subclassing it through the .for method, to set the allowed filters
         # definition should be a hash, keyed by field name, which contains a hash that can have two pieces of metadata
@@ -52,7 +55,7 @@ module Praxis
           def for(media_type, **_opts)
             unless media_type < Praxis::MediaType
               raise ArgumentError, "Invalid type: #{media_type.name} for Filters. " \
-                'Must be a subclass of MediaType'
+                'Using the .for method for defining a filter, requires passing a subclass of a MediaType'
             end
   
             ::Class.new(self) do
@@ -77,9 +80,7 @@ module Praxis
             }
           end
         end
-  
-        attr_reader :parsed_array
-  
+    
         def self.native_type
           self
         end
@@ -134,11 +135,15 @@ module Praxis
                          raise "filter with name #{filter_name} does not correspond to an existing field inside " \
                                " MediaType #{media_type.name}"
                        end
-                       attr_example = filter_components.inject(mt_example) do |last, name|
-                         # we can safely do sends, since we've verified the components are valid
-                         last.send(name)
-                       end
-                       arr << "#{filter_name}#{op}#{attr_example}"
+                       if NOVALUE_OPERATORS.include?(op)
+                        arr << "#{filter_name}#{op}" # Do not add a value for the operators that don't take it
+                       else
+                        attr_example = filter_components.inject(mt_example) do |last, name|
+                          # we can safely do sends, since we've verified the components are valid
+                          last.send(name)
+                        end
+                        arr << "#{filter_name}#{op}#{attr_example}"
+                      end
                      end.join('&')
                    else
                      'name=Joe&date>2017-01-01'
@@ -153,34 +158,32 @@ module Praxis
   
         def self.load(filters, _context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
           return filters if filters.is_a?(native_type)
-          return new if filters.nil?
-          parsed = filters.split('&').each_with_object([]) do |filter_string, arr|
-            match = FILTER_REGEX.match(filter_string)
-            values = CGI.unescape(match[:value]).split(',')
-            value = if values.size > 1
-              multimatch = true
-              values
-            else
-              multimatch = false
-              values.first
-            end
-  
-            attr_name = match[:attribute].to_sym
-            coerced = if media_type
-              filter_components = attr_name.to_s.split('.').map(&:to_sym)
-              attr, _enclosing_type = find_filter_attribute(filter_components, media_type)
-              if multimatch
-                attr_coll = Attributor::Collection.of(attr.type)
-                attr_coll.load(value)
+          return new if filters.nil? || filters.blank?
+
+          parsed = Parser.new.parse(CGI.unescape(filters))
+          tree = ConditionGroup.load(parsed)
+
+          rr = tree.flattened_conditions
+          accum = []
+          rr.each do |spec|
+            attr_name = spec[:name]
+            # TODO: Do we need to CGI.unescape things? here or even before??...
+            coerced = \
+              if media_type
+                filter_components = attr_name.to_s.split('.').map(&:to_sym)
+                attr, _enclosing_type = find_filter_attribute(filter_components, media_type)
+                if spec[:values].is_a?(Array)
+                  attr_coll = Attributor::Collection.of(attr.type)
+                  attr_coll.load(spec[:values])
+                else
+                  attr.load(spec[:values])
+                end
               else
-                attr.load(value)
+                spec[:values]
               end
-            else
-              value
-            end
-            arr.push(name: attr_name, op: match[:operator], value: coerced )
+            accum.push(name: attr_name, op: spec[:op], value: coerced , node_object: spec[:node_object])
           end
-          new(parsed)
+          new(accum)
         end
   
         def self.dump(value, **_opts)

data/lib/praxis/extensions/attribute_filtering/filters_parser.rb

@@ -0,0 +1,153 @@
+require 'parslet'
+
+module Praxis
+  module Extensions
+    module AttributeFiltering
+      class FilteringParams
+        class Condition
+          attr_reader :name, :op, :values
+          attr_accessor :parent_group
+
+          # For operands with a single or no values: Incoming data is a hash with name and op
+          # For Operands with multiple values: Incoming data is an array of hashes
+          #   First hash has the spec (i.e., name and op)
+          #   The rest of the hashes contain a value each (a hash with value: X each).
+          #   Example: [{:name=>"multi"@0, :op=>"="@5}, {:value=>"1"@6}, {:value=>"2"@8}]
+          def initialize(triad:, parent_group:)
+            @parent_group = parent_group
+
+            if triad.is_a? Array # several values coming in
+              spec, *values = triad
+              @name = spec[:name].to_sym
+              @op = spec[:op].to_s
+
+              @values = if values.empty?
+                ""
+              elsif values.size == 1
+                values.first[:value].to_s
+              else
+                values.map{|e| e[:value].to_s}
+              end
+            else # No values for the operand
+              @name = triad[:name].to_sym
+              @op = triad[:op].to_s
+              if ['!','!!'].include?(@op)
+                @values = nil
+              else
+                # Value operand without value? => convert it to empty string
+                raise "Interesting, didn't know this could happen. Oops!" if triad[:value].is_a?(Array) && !triad[:value].empty?
+                @values = (triad[:value] == []) ? '' : triad[:value].to_s # TODO: could this be an array (or it always comes the other if)
+              end
+            end
+          end
+        
+          def flattened_conditions
+            [{name: @name, op: @op, values: @values, node_object: self}]
+          end
+
+          def dump
+            vals = if values.is_a? Array
+              "[#{values.join(',')}]" # Purposedly enclose in brackets to make sure we differentiate
+            else
+              (values == '') ? "\"#{values}\"" : values # Dump the empty string explicitly with quotes if we've converted no value to empty string
+            end
+            "#{name}#{op}#{vals}"
+          end
+        end
+
+        # An Object that represents an AST tree for either an OR or an AND conditions
+        # to be applied to its items children
+        class ConditionGroup
+          attr_reader :items, :type
+          attr_accessor :parent_group
+          attr_accessor :associated_query # Metadata to be used by whomever is manipulating this
+
+          def self.load(node)
+            unless node[:o]
+              loaded = Condition.new(triad: node[:triad], parent_group: nil)
+            else
+              compactedl = compress_tree(node: node[:l], op: node[:o])
+              compactedr = compress_tree(node: node[:r], op: node[:o])
+              compacted = {op: node[:o], items: compactedl + compactedr }
+
+              loaded = ConditionGroup.new(**compacted, parent_group: nil)  
+            end
+            loaded
+          end
+
+          def initialize(op:, items:, parent_group:)
+            @type = (op.to_s == '&') ? :and : :or
+            @items = items.map do |item|
+              if item[:op]
+                ConditionGroup.new(**item, parent_group: self)
+              else
+                Condition.new(triad: item[:triad], parent_group: self)
+              end
+            end
+            @parent_group = parent_group
+          end
+
+          def dump
+            "( " + @items.map(&:dump).join(" #{type.upcase} ") + " )"
+          end
+
+          # Returns an array with flat conditions from all child triad conditions
+          def flattened_conditions
+            @items.inject([]) do |accum, item|
+               accum + item.flattened_conditions
+            end
+          end
+
+          # Given a binary tree of operand conditions, transform it to a multi-leaf tree
+          # where a single condition node has potentially multiple subtrees for the same operation (instead of 2)
+          # For example (&, (&, a, b), (|, c, d)) => (&, a, b, (|, c, d)) 
+          def self.compress_tree(node:, op:)
+            if node[:triad]
+              return [node]
+            end
+
+            # It is an op node
+            if node[:o] == op
+              # compatible op as parent, collect my compacted children and return them up skipping my op
+              resultl = compress_tree(node: node[:l], op: op)
+              resultr = compress_tree(node: node[:r], op: op)
+              resultl+resultr
+            else
+              collected = compress_tree(node: node, op: node[:o])
+              [{op: node[:o], items: collected }]
+            end
+          end
+        end
+
+        class Parser < Parslet::Parser
+          root :expression
+          rule(:lparen)     { str('(') }
+          rule(:rparen)     { str(')') }
+          rule(:comma)     { str(',') }     
+          rule(:val_operator)   { str('!=') | str('>=') | str('<=') | str('=') | str('<') | str('>')}
+          rule(:noval_operator)   { str('!!') | str('!')}
+          rule(:and_kw) { str('&') }
+          rule(:or_kw) { str('|') }
+
+          def infix *args
+            Infix.new(*args)
+          end
+   
+          rule(:name)    { match('[a-zA-Z0-9_\.]').repeat(1) } # TODO: are these the only characters that we allow for names?
+          rule(:chars) { match('[^&|),]').repeat(0).as(:value) }
+          rule(:value)    { chars >> (comma >> chars ).repeat }
+
+          rule(:triad)  { 
+              (name.as(:name) >> val_operator.as(:op) >> value).as(:triad) |
+              (name.as(:name) >> noval_operator.as(:op)).as(:triad) |              
+              lparen >> expression >> rparen
+            }
+
+          rule(:expression) { 
+            infix_expression(triad,  [and_kw, 2, :left], [or_kw, 1, :right])
+          }
+        end
+      end
+    end
+  end
+end