praxis 2.0.pre.11 → 2.0.pre.16

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)
@@ -218,10 +222,9 @@ module Praxis
             value_type = attr_filters[:value_type]
             next unless value_type == Attributor::String
 
-            value = item[:value]
-            unless value.empty?
+            if item[:value].presence
               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/mapper/resource.rb

@@ -46,8 +46,8 @@ module Praxis::Mapper
       end
     end
 
-    def self.property(name, **options)
-      self.properties[name] = options
+    def self.property(name, dependencies: nil, through: nil)
+      self.properties[name] = {dependencies: dependencies, through: through}
     end
 
     def self._finalize!

data/lib/praxis/media_type_identifier.rb

@@ -198,10 +198,20 @@ module Praxis
       obj = self.class.new
       obj.type = self.type
       obj.subtype = self.subtype
-      obj.suffix = suffix || self.suffix || ''
+      target_suffix = suffix || self.suffix
+      obj.suffix = redundant_suffix(target_suffix) ? '' : target_suffix
       obj.parameters = self.parameters.merge(parameters)
 
       obj
     end
+
+    def redundant_suffix(suffix)
+      # application/json does not need to be suffixed with +json (same for application/xml)
+      # we're supporting text/json and text/xml for older formats as well
+      if (self.type == 'application' || self.type == 'text') && self.subtype == suffix
+        return true
+      end
+      false
+    end
   end
 end

data/lib/praxis/response_definition.rb

@@ -55,52 +55,36 @@ module Praxis
       end
     end
 
-    def location(loc=nil)
-      return @spec[:location] if loc.nil?
-      unless ( loc.is_a?(Regexp) || loc.is_a?(String) )
-        raise Exceptions::InvalidConfiguration.new(
-          "Invalid location specification. Location in response must be either a regular expression or a string."
-        )
-      end
-      @spec[:location] = loc
-    end
+    def location(loc=nil, description: nil)
+      return  headers.dig('Location',:value) if loc.nil?
 
-    def headers(hdrs = nil)
-      return @spec[:headers] if hdrs.nil?
+      header('Location', loc, description: description)
+    end
 
-      case hdrs
-      when Array
-        hdrs.each {|header_name| header(header_name) }
-      when Hash
-        header(hdrs)
-      when String
-        header(hdrs)
-      else
-        raise Exceptions::InvalidConfiguration.new(
-          "Invalid headers specification: Arrays, Hash, or String must be used. Received: #{hdrs.inspect}"
-        )
-      end
+    def headers
+      @spec[:headers]
     end
 
-    def header(hdr)
-      case hdr
-      when String
-        @spec[:headers][hdr] = true
-      when Hash
-        hdr.each do | k, v |
-          unless v.is_a?(Regexp) || v.is_a?(String)
-            raise Exceptions::InvalidConfiguration.new(
-              "Header definitions for #{k.inspect} can only match values of type String or Regexp. Received: #{v.inspect}"
-            )
-          end
-          @spec[:headers][k] = v
-        end
+    def header(name, value, description: nil)
+      the_type, args = case value
+      when nil,String
+        [String, {}]
+      when Regexp
+        # A regexp means it's gonna be a String typed, attached to a regexp
+        [String, { regexp: value }]
       else
         raise Exceptions::InvalidConfiguration.new(
-          "A header definition can only take a String (to match the name) or" +
-          " a Hash (to match both the name and the value). Received: #{hdr.inspect}"
+          "A header definition for a response can only take String, Regexp or nil values (to match anything)." +
+          "Received the following value for header name #{name}: #{value}"
         )
       end
+
+      info = { 
+        value: value, 
+        attribute: Attributor::Attribute.new(the_type, **args)
+      }
+      info[:description] = description if description
+      @spec[:headers][name] = info
     end
 
     def example(context=nil)
@@ -123,13 +107,14 @@ module Praxis
         :status => status,
         :headers => {}
       }
-      content[:location] = _describe_header(location) unless location == nil
 
       unless headers == nil
         headers.each do |name, value|
           content[:headers][name] = _describe_header(value)
         end
       end
+      content[:location] = content[:headers]['Location']
+
 
       if self.media_type
         payload = media_type.describe(true)
@@ -173,14 +158,14 @@ module Praxis
     end
 
     def _describe_header(data)
-      data_type = data.is_a?(Regexp) ? :regexp : :string
-      data_value = data.is_a?(Regexp) ? data.inspect : data
+
+      data_type = data[:value].is_a?(Regexp) ? :regexp : :string
+      data_value = data[:value].is_a?(Regexp) ? data[:value].inspect : data[:value]
       { :value => data_value, :type => data_type }
     end
 
     def validate(response, validate_body: false)
       validate_status!(response)
-      validate_location!(response)
       validate_headers!(response)
       validate_content_type!(response)
       validate_parts!(response)
@@ -222,23 +207,13 @@ module Praxis
       end
     end
 
-
-    # Validates 'Location' header
-    #
-    # @raise [Exceptions::Validation] When location header does not match to the defined one.
-    #
-    def validate_location!(response)
-      return if location.nil? || location === response.headers['Location']
-      raise Exceptions::Validation.new("LOCATION does not match #{location.inspect}")
-    end
-
-
     # Validates Headers
     #
     # @raise [Exceptions::Validation]  When there is a missing required header..
     #
     def validate_headers!(response)
       return unless headers
+
       headers.each do |name, value|
         if name.is_a? Symbol
           raise Exceptions::Validation.new(
@@ -252,20 +227,25 @@ module Praxis
           )
         end
 
-        case value
-        when String
-          if response.headers[name] != value
-            raise Exceptions::Validation.new(
-              "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}."
-            )
-          end
-        when Regexp
-          if response.headers[name] !~ value
-            raise Exceptions::Validation.new(
-              "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name].inspect}."
-            )
-          end
+        errors = value[:attribute].validate(response.headers[name])
+
+        unless errors.empty? 
+          raise Exceptions::Validation.new("Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}.")
         end
+        # case value
+        # when String
+        #   if response.headers[name] != value
+        #     raise Exceptions::Validation.new(
+        #       "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name]}."
+        #     )
+        #   end
+        # when Regexp
+        #   if response.headers[name] !~ value
+        #     raise Exceptions::Validation.new(
+        #       "Header #{name.inspect}, with value #{value.inspect} does not match #{response.headers[name].inspect}."
+        #     )
+        #   end
+        # end
       end
     end