praxis 2.0.pre.10 → 2.0.pre.15

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, :fuzzy, :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,33 @@ 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(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 , fuzzy: spec[:fuzzies], node_object: spec[:node_object])
           end
-          new(parsed)
+          new(accum)
         end
   
         def self.dump(value, **_opts)
@@ -221,7 +225,7 @@ module Praxis
             value = item[:value]
             unless value.empty?
               fuzzy_match = attr_filters[:fuzzy_match]
-              if (value[-1] == '*' || value[0] == '*') && !fuzzy_match
+              if item[:fuzzy] && !item[:fuzzy].empty? && !fuzzy_match
                 errors << "Fuzzy matching for #{attr_name} is not allowed (yet '*' was found in the value)"
               end
             end

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

@@ -0,0 +1,193 @@
+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
+
+              if values.empty?
+                @values = ""
+                @fuzzies = nil
+              elsif values.size == 1
+                raw_val = values.first[:value].to_s
+                @values, @fuzzies = _compute_fuzzy(values.first[:value].to_s)
+              else
+                @values = []
+                @fuzzies = []
+                results = values.each do|e| 
+                  val, fuz = _compute_fuzzy(e[:value].to_s)
+                  @values.push val
+                  @fuzzies.push fuz
+                end
+              end
+            else # No values for the operand
+              @name = triad[:name].to_sym
+              @op = triad[:op].to_s
+              if ['!','!!'].include?(@op)
+                @values, @fuzzies = [nil, 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?
+                if triad[:value] == []
+                  @values, @fuzzies = ['', nil]
+                else
+                  @values, @fuzzies = _compute_fuzzy(triad[:value].to_s)
+                end
+              end
+            end
+          end
+          # Takes a raw val, and spits out the output val (unescaped), and the fuzzy definition
+          def _compute_fuzzy(raw_val)
+            starting = raw_val[0] == '*'
+            ending = raw_val[-1] == '*'
+            newval, fuzzy = if starting && ending
+              [raw_val[1..-2], :start_end]
+            elsif starting
+              [raw_val[1..-1], :start]
+            elsif ending
+              [raw_val[0..-2], :end]
+            else
+              [raw_val,nil]
+            end
+            newval = CGI.unescape(newval) if newval
+            [newval,fuzzy]
+          end
+          def flattened_conditions
+            [{name: @name, op: @op, values: @values, fuzzies: @fuzzies, node_object: self}]
+          end
+
+          # Dumps the value, marking where the fuzzy might be, and removing the * to differentiate from literals
+          def _dump_value(val,fuzzy)
+            case fuzzy
+            when nil
+              val
+            when :start_end
+              '{*}' + val + '{*}'
+            when :start
+              '{*}' + val
+            when :end
+               val +'{*}'
+            end
+          end
+          def dump
+            vals = if values.is_a? Array
+              dumped = values.map.with_index{|val,i| _dump_value(val, @fuzzies[i])}
+              "[#{dumped.join(',')}]" # Purposedly enclose in brackets to make sure we differentiate
+            else
+              (values == '') ? '""' : _dump_value(values,@fuzzies) # 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

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

@@ -9,7 +9,7 @@ module Praxis
       class << self
         def for(definition)
           Class.new(self) do
-            @attr_to_column = case definition
+            @filters_map = case definition
                               when Hash
                                 definition
                               when Array
@@ -18,7 +18,7 @@ module Praxis
                                 raise "Cannot use FilterQueryBuilder.of without passing an array or a hash (Got: #{definition.class.name})"
                               end
             class << self
-              attr_reader :attr_to_column
+              attr_reader :filters_map
             end
           end
         end
@@ -33,13 +33,18 @@ module Praxis
       end
 
       # By default we'll simply use the incoming op and value, and will map
-      # the attribute based on what's on the `attr_to_column` hash
+      # the attribute based on what's on the `filters_map` definition
       def generate(filters)
         raise "Not refactored yet!"
         seen_associations = Set.new
         filters.each do |(attr, spec)|
-          column_name = attr_to_column[attr]
-          raise "Filtering by #{attr} not allowed (no mapping found)" unless column_name
+          column_name = _mapped_filter(attr)
+          unless column_name
+            msg = "Filtering by #{attr} is not allowed. No implementation mapping defined for it has been found \
+              and there is not a model attribute with this name either.\n" \
+              "Please add a mapping for #{attr} in the `filters_mapping` method of the appropriate Resource class"
+            raise msg
+          end          
           if column_name.is_a?(Proc)
             bindings = column_name.call(spec)
             # A hash of bindings, consisting of a key with column name and a value to the query value
@@ -64,9 +69,16 @@ module Praxis
         add_clause(attr: column_name, op: op, value: value)
       end
 
-      def attr_to_column
-        # Class method defined by the subclassing Class (using .for)
-        self.class.attr_to_column
+      def _mapped_filter(name)
+        target = self.class.filters_map[name]
+        unless target
+          if @model.attribute_names.include?(name.to_s)
+            # Cache it in the filters mapping (to avoid later lookups), and return it.
+            self.class.filters_map[name] = name
+            target = name
+          end
+        end
+        return target
       end
 
       # Private to try to funnel all column names through `generate` that restricts

data/lib/praxis/extensions/pagination.rb

@@ -14,10 +14,9 @@ module Praxis
     module Pagination
       extend ActiveSupport::Concern
       # This PaginatedController concern should be added to controllers that have actions that define the
-      # pagination and order parameters so that calling `paginate( query: <base_query>, table: <main_table_name> )`
-      # would handle all the required logic for paginating, ordering and generating the Link and TotalCount headers.
-      # This assumes that the query object are chainable and based on ActiveRecord at the moment (although that logic)
-      # can be easily applied to other chainable query proxies.
+      # pagination and order parameters so that one can call the domain model to craft the query
+      # `domain_model.craft_pagination_query(base_query, pagination: _pagination)`
+      # This will handle all the required logic for paginating, ordering and generating the Link and TotalCount headers.
       #
       # Here's a simple example on how to use it for a fake Items controller
       # class Items < V1::Controllers::BaseController
@@ -29,7 +28,8 @@ module Praxis
       #
       #   def index(filters: nil, pagination: nil, order: nil,  **_args)
       #     items = current_user.items.all
-      #     items = _craft_pagination_query( query: items)
+      #     domain_model = self.media_type.domain_model
+      #     items = domain_model.craft_pagination_query( query: items, pagination: _pagination)
       #
       #     display(items)
       #   end
@@ -71,33 +71,6 @@ module Praxis
         @_pagination = PaginationStruct.new(pagination[:paginator], pagination[:order])
       end
 
-      # Main entrypoint: Handles all pagination pieces
-      # takes:
-      # * the query to build from and the table
-      # * the request (for link header generation)
-      # * requires the _pagination variable to be there (set by this module) to return the pagination struct
-      def _craft_pagination_query(query:, type: :active_record)
-        handler_klass = \
-          case type
-          when :active_record
-            ActiveRecordPaginationHandler
-          when :sequel
-            SequelPaginationHandler
-          else
-            raise "Attempting to use pagination but Active Record or Sequel gems found"
-          end
- 
-        # Gather and save the count if required
-        if _pagination.paginator&.total_count
-          _pagination.total_count = handler_klass.count(query.dup)
-        end
-        
-        query = handler_klass.order(query, _pagination.order)
-        # Maybe this is a class instance instead of a class method?...(of the appropriate AR/Sequel type)...
-        # self.class.paginate(query, table, _pagination)
-        handler_klass.paginate(query, _pagination)
-      end
-
       def build_pagination_headers(pagination:, current_url:, current_query_params:)
         links = if pagination.paginator.by
                   # We're assuming that the last element has a "symbol/string" field with the same name of the "by" pagination.