praxis 2.0.pre.18 → 2.0.pre.19

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

@@ -1,8 +1,11 @@
+# frozen_string_literal: true
+
 module Praxis
   module Extensions
     module AttributeFiltering
       class FilterTreeNode
         attr_reader :path, :conditions, :children
+
         # 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: [])
@@ -12,9 +15,9 @@ module Praxis
           children_data = {} # Hash with keys as names of the first level component of the children nodes (and values as array of matching filters)
           parsed_filters.map do |hash|
             *components = hash[:name].to_s.split('.')
-            if components.empty?
-              return
-            elsif components.size == 1
+            next if components.empty?
+
+            if components.size == 1
               @conditions << hash.slice(:name, :op, :value, :fuzzy, :node_object)
             else
               children_data[components.first] ||= []
@@ -27,10 +30,10 @@ module Praxis
               _parent, *rest = item[:name].to_s.split('.')
               item.merge(name: rest.join('.'))
             end
-            hash[name] = self.class.new(sub_filters, path: path + [name] )
+            hash[name] = self.class.new(sub_filters, path: path + [name])
           end
         end
       end
     end
   end
-end
+end

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

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
+
 require 'praxis/extensions/attribute_filtering/filters_parser'
 
 #
 # 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.
 # It also alows you to define exacly what fields (from that MediaType) are allowed, an what operations are
 # supported for each of them. Includes most in/equalities and fuzzy matching options(i.e., leading/trailing `*` )
@@ -18,6 +19,8 @@ require 'praxis/extensions/attribute_filtering/filters_parser'
 #   filter 'name', using: ['=', '!=', '!', '!!]
 #   filter 'children.created_at', using: ['>', '>=', '<', '<=']
 #   filter 'display_name', using: ['=', '!='], fuzzy: true
+#   # Or glob any single leaf attribute into one
+#   any 'updated_at', using: ['>', '>=', '<', '<=', '=']
 # end
 
 module Praxis
@@ -26,7 +29,7 @@ module Praxis
       class FilteringParams
         include Attributor::Type
         include Attributor::Dumpable
-  
+
         attr_reader :parsed_array
 
         class DSLCompiler < Attributor::DSLCompiler
@@ -37,97 +40,108 @@ module Praxis
           def filter(name, using: nil, fuzzy: false)
             target.add_filter(name.to_sym, operators: Set.new(using), fuzzy: fuzzy)
           end
+
+          def any(name, using: nil, fuzzy: false)
+            target.add_any(name.to_sym, operators: Set.new(using), fuzzy: fuzzy)
+          end
         end
-  
+
         VALUE_OPERATORS = Set.new(['!=', '>=', '<=', '=', '<', '>']).freeze
-        NOVALUE_OPERATORS = Set.new(['!','!!']).freeze
-        AVAILABLE_OPERATORS = Set.new(VALUE_OPERATORS+NOVALUE_OPERATORS).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
         # :operators => an array of operators allowed (if empty, means all)
         # :value_type => a type class which the value should match
         # :fuzzy_match => weather or not we allow a "like" type query (for prefix or suffix matching)
         class << self
-          attr_reader :media_type
-          attr_reader :allowed_filters
-  
+          attr_reader :media_type, :allowed_filters, :allowed_leaves
+
           def for(media_type, **_opts)
             unless media_type < Praxis::MediaType
               raise ArgumentError, "Invalid type: #{media_type.name} for Filters. " \
                 'Using the .for method for defining a filter, requires passing a subclass of a MediaType'
             end
-  
+
             ::Class.new(self) do
               @media_type = media_type
               @allowed_filters = {}
+              @allowed_leaves = {}
             end
           end
-  
+
           def json_schema_type
             :string
           end
-      
+
           def add_filter(name, operators:, fuzzy:)
             components = name.to_s.split('.').map(&:to_sym)
-            attribute, enclosing_type = find_filter_attribute(components, media_type)
+            attribute, _enclosing_type = find_filter_attribute(components, media_type)
             raise 'Invalid set of operators passed' unless AVAILABLE_OPERATORS.superset?(operators)
-  
+
             @allowed_filters[name] = {
               value_type: attribute.type,
               operators: operators,
               fuzzy_match: fuzzy
             }
           end
+
+          def add_any(name, operators:, fuzzy:)
+            raise 'Invalid set of operators passed' unless AVAILABLE_OPERATORS.superset?(operators)
+
+            @allowed_leaves[name] = {
+              operators: operators,
+              fuzzy_match: fuzzy
+            }
+          end
         end
-    
+
         def self.native_type
           self
         end
-  
+
         def self.name
           'Praxis::Types::FilteringParams'
         end
-  
+
         def self.display_name
           'Filtering'
         end
-  
+
         def self.family
           'string'
         end
-  
+
         def self.constructable?
           true
         end
-  
+
         def self.construct(definition, **options)
           return self if definition.nil?
-  
+
           DSLCompiler.new(self, **options).parse(*definition)
           self
         end
-  
+
         def self.find_filter_attribute(name_components, type)
           type = type.member_type if type < Attributor::Collection
           first, *rest = name_components
           first_attr = type.attributes[first]
-          unless first_attr
-            raise "Error, you've requested to filter by field #{first} which does not exist in the #{type.name} mediatype!\n"
-          end
-  
+          raise "Error, you've requested to filter by field '#{first}' which does not exist in the #{type.name} mediatype!\n" unless first_attr
+
           return find_filter_attribute(rest, first_attr.type) if rest.present?
-  
+
           [first_attr, type] # Return the attribute and associated enclosing type
         end
-  
+
         def self.example(_context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
           fields = if media_type
                      mt_example = media_type.example
                      pickable_fields = mt_example.object.keys & allowed_filters.keys
                      pickable_fields.sample(2).each_with_object([]) do |filter_name, arr|
                        op = allowed_filters[filter_name][:operators].to_a.sample(1).first
-  
+
                        # Switch this to pick the right example attribute from the mt example
                        filter_components = filter_name.to_s.split('.').map(&:to_sym)
                        mapped_attribute, _enclosing_type = find_filter_attribute(filter_components, media_type)
@@ -136,32 +150,32 @@ module Praxis
                                " MediaType #{media_type.name}"
                        end
                        if NOVALUE_OPERATORS.include?(op)
-                        arr << "#{filter_name}#{op}" # Do not add a value for the operators that don't take it
+                         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
+                         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'
                    end
           load(fields)
         end
-  
+
         def self.validate(value, context = Attributor::DEFAULT_ROOT_CONTEXT, _attribute = nil)
           instance = load(value, context)
           instance.validate(context)
         end
-  
+
         def self.load(filters, _context = Attributor::DEFAULT_ROOT_CONTEXT, **_options)
           return filters if filters.is_a?(native_type)
           return new if filters.nil? || filters.blank?
 
           parsed = Parser.new.parse(filters)
-          
+
           tree = ConditionGroup.load(parsed)
 
           rr = tree.flattened_conditions
@@ -182,15 +196,15 @@ module Praxis
               else
                 spec[:values]
               end
-            accum.push(name: attr_name, op: spec[:op], value: coerced , fuzzy: spec[:fuzzies], node_object: spec[:node_object])
+            accum.push(name: attr_name, op: spec[:op], value: coerced, fuzzy: spec[:fuzzies], node_object: spec[:node_object])
           end
           new(accum)
         end
-  
+
         def self.dump(value, **_opts)
           load(value).dump
         end
-  
+
         def self.describe(_root = false, example: nil)
           hash = super
           if allowed_filters
@@ -199,38 +213,47 @@ module Praxis
               accum[name][:fuzzy] = true if spec[:fuzzy_match]
             end
           end
-  
+
           hash
         end
-  
+
         def initialize(parsed = [])
           @parsed_array = parsed
         end
-  
+
+        def matching_leaf_filter(filter_string)
+          return nil unless allowed_leaves.keys.present?
+
+          last_component = filter_string.to_s.split('.').last.to_sym
+          allowed_leaves[last_component]
+        end
+
         def validate(_context = Attributor::DEFAULT_ROOT_CONTEXT)
           parsed_array.each_with_object([]) do |item, errors|
             attr_name = item[:name]
             attr_filters = allowed_filters[attr_name]
             unless attr_filters
-              errors << "Filtering by #{attr_name} is not allowed. You can filter by #{allowed_filters.keys.map(&:to_s).join(', ')}"
-              next
+              # does not match a complete filter, let's check if it matches an 'any' filter on the last component
+              attr_filters = matching_leaf_filter(attr_name)
+              unless attr_filters
+                msg = "Filtering by #{attr_name} is not allowed. You can filter by #{allowed_filters.keys.map(&:to_s).join(', ')}"
+                msg += " or leaf attributes matching #{allowed_leaves.keys.map(&:to_s).join(', ')}" if allowed_leaves.keys.presence
+                errors << msg
+                next
+              end
             end
             allowed_operators = attr_filters[:operators]
-            unless allowed_operators.include?(item[:op])
-              errors << "Operator #{item[:op]} not allowed for filter #{attr_name}"
-            end
+            errors << "Operator #{item[:op]} not allowed for filter #{attr_name}" unless allowed_operators.include?(item[:op])
             value_type = attr_filters[:value_type]
             next unless value_type == Attributor::String
 
-            if item[:value].presence
-              fuzzy_match = attr_filters[: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
+            next unless item[:value].presence
+
+            fuzzy_match = attr_filters[:fuzzy_match]
+            errors << "Fuzzy matching for #{attr_name} is not allowed (yet '*' was found in the value)" if item[:fuzzy] && !item[:fuzzy].empty? && !fuzzy_match
           end
         end
-  
+
         # Dump back string parseable form
         def dump
           parsed_array.each_with_object([]) do |item, arr|
@@ -238,17 +261,20 @@ module Praxis
             arr << "#{field}#{item[:op]}#{item[:value]}"
           end.join('&')
         end
-  
-        def each
-          parsed_array&.each do |filter|
-            yield filter
-          end
+
+        def each(&block)
+          parsed_array&.each(&block)
         end
-  
+
         def allowed_filters
           # Class method defined by the subclassing Class (using .for)
           self.class.allowed_filters
         end
+
+        def allowed_leaves
+          # Class method defined by the subclassing Class (using .for)
+          self.class.allowed_leaves
+        end
       end
     end
   end
@@ -260,5 +286,3 @@ module Praxis
     FilteringParams = Praxis::Extensions::AttributeFiltering::FilteringParams
   end
 end
-
-# rubocop:enable all

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'parslet'
 
 module Praxis
@@ -21,15 +23,14 @@ module Praxis
               @op = spec[:op].to_s
 
               if values.empty?
-                @values = ""
+                @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| 
+                values.each do |e|
                   val, fuz = _compute_fuzzy(e[:value].to_s)
                   @values.push val
                   @fuzzies.push fuz
@@ -38,59 +39,65 @@ module Praxis
             else # No values for the operand
               @name = triad[:name].to_sym
               @op = triad[:op].to_s
-              if ['!','!!'].include?(@op)
-                @values, @fuzzies = [nil, nil]
+              if ['!', '!!'].include?(@op)
+                @values = nil
+                @fuzzies = 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]
+                  @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
+                              [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]
+            [newval, fuzzy]
           end
+
           def flattened_conditions
-            [{name: @name, op: @op, values: @values, fuzzies: @fuzzies, node_object: self}]
+            [{ 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)
+          def _dump_value(val, fuzzy)
             case fuzzy
             when nil
               val
             when :start_end
-              '{*}' + val + '{*}'
+              "{*}#{val}{*}"
             when :start
-              '{*}' + val
+              "{*}#{val}"
             when :end
-               val +'{*}'
+              "#{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
+                     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
@@ -99,24 +106,24 @@ module Praxis
         # 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
+          attr_accessor :parent_group, :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 }
+            if node[:o]
+              compactedl = compress_tree(node: node[:l], operator: node[:o])
+              compactedr = compress_tree(node: node[:r], operator: node[:o])
+              compacted = { op: node[:o], items: compactedl + compactedr }
 
-              loaded = ConditionGroup.new(**compacted, parent_group: nil)  
+              loaded = ConditionGroup.new(**compacted, parent_group: nil)
+            else
+              loaded = Condition.new(triad: node[:triad], parent_group: nil)
             end
             loaded
           end
 
+          # rubocop:disable Naming/MethodParameterName
           def initialize(op:, items:, parent_group:)
-            @type = (op.to_s == '&') ? :and : :or
+            @type = op.to_s == '&' ? :and : :or
             @items = items.map do |item|
               if item[:op]
                 ConditionGroup.new(**item, parent_group: self)
@@ -126,35 +133,34 @@ module Praxis
             end
             @parent_group = parent_group
           end
+          # rubocop:enable Naming/MethodParameterName
 
           def dump
-            "( " + @items.map(&:dump).join(" #{type.upcase} ") + " )"
+            "( #{@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
+              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
+          # For example (&, (&, a, b), (|, c, d)) => (&, a, b, (|, c, d))
+          def self.compress_tree(node:, operator:)
+            return [node] if node[:triad]
 
             # It is an op node
-            if node[:o] == op
+            if node[:o] == operator
               # 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
+              resultl = compress_tree(node: node[:l], operator: operator)
+              resultr = compress_tree(node: node[:r], operator: operator)
+              resultl + resultr
             else
-              collected = compress_tree(node: node, op: node[:o])
-              [{op: node[:o], items: collected }]
+              collected = compress_tree(node: node, operator: node[:o])
+              [{ op: node[:o], items: collected }]
             end
           end
         end
@@ -163,31 +169,31 @@ module Praxis
           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(: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
+          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(: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) |              
+          rule(:triad) do
+            (name.as(:name) >> val_operator.as(:op) >> value).as(:triad) |
+              (name.as(:name) >> noval_operator.as(:op)).as(:triad) |
               lparen >> expression >> rparen
-            }
+          end
 
-          rule(:expression) { 
-            infix_expression(triad,  [and_kw, 2, :left], [or_kw, 1, :right])
-          }
+          rule(:expression) do
+            infix_expression(triad, [and_kw, 2, :left], [or_kw, 1, :right])
+          end
         end
       end
     end
   end
-end
+end

data/lib/praxis/extensions/attribute_filtering.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'praxis/extensions/attribute_filtering/filtering_params'
 require 'praxis/extensions/attribute_filtering/filter_tree_node'
 module Praxis
@@ -12,4 +14,4 @@ module Praxis
       end
     end
   end
-end
+end

data/lib/praxis/extensions/field_expansion.rb

@@ -1,24 +1,26 @@
+# frozen_string_literal: true
+
 module Praxis
   module Extensions
     module FieldExpansion
       extend ActiveSupport::Concern
 
       included do
-        Praxis::ActionDefinition.send(:include, ActionDefinitionExtension)
+        Praxis::ActionDefinition.include ActionDefinitionExtension
       end
 
       def expanded_fields
-        @expansion ||= request.action.expanded_fields(self.request, self.media_type)
+        @expanded_fields ||= request.action.expanded_fields(request, media_type)
       end
 
       module ActionDefinitionExtension
         extend ActiveSupport::Concern
 
         def expanded_fields(request, media_type)
-          uses_fields = self.params && self.params.attributes.key?(:fields)
+          uses_fields = params&.attributes&.key?(:fields)
           fields = uses_fields ? request.params.fields.fields : true
 
-          Praxis::FieldExpander.expand(media_type,fields)
+          Praxis::FieldExpander.expand(media_type, fields)
         end
       end
     end