praxis 2.0.pre.8 → 2.0.pre.13

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
+                CGI.unescape(values.first[:value].to_s)
+              else
+                values.map{|e| CGI.unescape(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] == []) ? '' : CGI.unescape(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

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/field_expansion.rb

@@ -7,53 +7,20 @@ module Praxis
         Praxis::ActionDefinition.send(:include, ActionDefinitionExtension)
       end
 
-
       def expanded_fields
         @expansion ||= request.action.expanded_fields(self.request, self.media_type)
       end
 
-
       module ActionDefinitionExtension
         extend ActiveSupport::Concern
 
         def expanded_fields(request, media_type)
-          use_fields = self.params && self.params.attributes.key?(:fields)
-          use_view = self.params && self.params.attributes.key?(:view)
-
-          # Determine what, if any, fields to display.
-          fields = if use_fields
-            request.params.fields.fields
-          else
-            true
-          end
+          uses_fields = self.params && self.params.attributes.key?(:fields)
+          fields = uses_fields ? request.params.fields.fields : true
 
-          # Determine the view that COULD be applicable.
-          view = if use_view && (view_name = request.params.view)
-            media_type.views[view_name]
-          else
-            media_type.views[:default]
-          end
-
-          expandable = if fields == true
-            # We want to show ALL of the available fields.
-            # This can never be applied to the type (it's likely infinitely recursive).
-            # So use view_name determimed above.
-            view
-          else
-            # We want to show SOME of fields available on a view or type.
-            if use_view && request.params.view
-              # Use the requested view.
-              view
-            else
-              # Use the type.
-              media_type
-            end
-          end
-
-          Praxis::FieldExpander.expand(expandable,fields)
+          Praxis::FieldExpander.expand(media_type,fields)
         end
       end
-
     end
   end
 end

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 = handle_pagination( 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 handle_pagination(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.

data/lib/praxis/extensions/pagination/ordering_params.rb

@@ -115,7 +115,7 @@ module Praxis
         def self.construct(pagination_definition, **options)
           return self if pagination_definition.nil?
 
-          DSLCompiler.new(self, options).parse(*pagination_definition)
+          DSLCompiler.new(self, **options).parse(*pagination_definition)
           self
         end
 

data/lib/praxis/extensions/pagination/pagination_params.rb

@@ -202,7 +202,7 @@ module Praxis
         def self.construct(pagination_definition, **options)
           return self if pagination_definition.nil?
 
-          DSLCompiler.new(self, options).parse(*pagination_definition)
+          DSLCompiler.new(self, **options).parse(*pagination_definition)
           self
         end
 
@@ -221,10 +221,11 @@ module Praxis
 
                      selectable = mt_example.object.keys & simple_attrs.keys
                      by = selectable.sample(1).first
-                     from = media_type.attributes[by].example(parent: mt_example)
+                     from = media_type.attributes[by].example(parent: mt_example).to_s
                      # Make sure to encode the value of the from, as it can contain commas and such
-                     from = CGI.escape(from) if from.is_a? String
-                     "by=#{by},from=#{from},items=#{defaults[:page_size]}"
+                     # Only add the from parameter if it's not empty (an empty from is not allowed and it's gonna blow up in load)
+                     optional_from_component = (from && !from.empty?) ? ",from=#{CGI.escape(from)}" : ''
+                     "by=#{by}#{optional_from_component},items=#{defaults[:page_size]}"
                    else
                      "by=id,from=20,items=100"
                    end
@@ -360,6 +361,7 @@ module Praxis
                 else
                   s = "by=#{@by}"
                   s += ",from=#{@from}" if @from
+                  s
                 end
           str += ",items=#{items}" if @items
           str += ",total_count=true" if @total_count

data/lib/praxis/field_expander.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+module Praxis
+  class FieldExpander
+    def self.expand(object, fields = true)
+      new.expand(object, fields)
+    end
+
+    attr_reader :stack
+    attr_reader :history
+
+    def initialize
+      @stack = Hash.new do |hash, key|
+        hash[key] = Set.new
+      end
+      @history = Hash.new do |hash, key|
+        hash[key] = {}
+      end
+    end
+
+    def expand(object, fields = true)
+      if stack[object].include? fields
+        return history[object][fields] if history[object].include? fields
+        # We should probably never get here, since we should have a record
+        # of the history of an expansion if we're trying to redo it,
+        # but we should also be conservative and raise here just in case.
+        raise "Circular expansion detected for object #{object.inspect} with fields #{fields.inspect}"
+      else
+        stack[object] << fields
+      end
+
+      result = if object.is_a? Attributor::Attribute
+                 expand_type(object.type, fields)
+               else
+                 expand_type(object, fields)
+               end
+
+      result
+    ensure
+      stack[object].delete fields
+    end
+
+    def expand_fields(attributes, fields)
+      raise ArgumentError, 'expand_fields must be given a block' unless block_given?
+
+      unless fields == true
+        attributes = attributes.select do |k, _v|
+          fields.key?(k)
+        end
+      end
+
+      attributes.each_with_object({}) do |(name, dumpable), hash|
+        sub_fields = case fields
+                     when true
+                       true
+                     when Hash
+                       fields[name] || true
+                     end
+        hash[name] = yield(dumpable, sub_fields)
+      end
+    end
+
+    def expand_type(object, fields = true)
+      unless object.respond_to?(:attributes)
+        if object.respond_to?(:member_attribute)
+          return expand_type(object.member_attribute.type, fields)
+        else
+          return true
+        end
+      end
+
+      # just include the full thing if it has no attributes
+      return true if object.attributes.empty?
+
+      # True, expands to the default fieldset for blueprints
+      fields = object.default_fieldset if object < Praxis::Blueprint && fields == true
+
+      return history[object][fields] if history[object].include? fields
+
+      history[object][fields] = {}
+      result = expand_fields(object.attributes, fields) do |dumpable, sub_fields|
+        expand(dumpable.type, sub_fields)
+      end
+      unless fields == true 
+        non_matching = fields.keys - object.attributes.keys
+        raise "FieldExpansion error: attribute(s) #{non_matching} do not exist in #{object}" unless non_matching.empty?
+      end
+      history[object][fields].merge!(result)
+    end
+  end
+end