praxis 2.0.pre.9 → 2.0.pre.10

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

@@ -18,7 +18,7 @@ module Praxis
         end
         
         def debug(msg)
-          @logger && @logger.puts(msg)
+          @logger && @logger.info(msg)
         end
 
         def generate(filters)

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

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

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

@@ -29,7 +29,7 @@ module Praxis
       #
       #   def index(filters: nil, pagination: nil, order: nil,  **_args)
       #     items = current_user.items.all
-      #     items = handle_pagination( query: items)
+      #     items = _craft_pagination_query( query: items)
       #
       #     display(items)
       #   end
@@ -76,7 +76,7 @@ module Praxis
       # * 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)
+      def _craft_pagination_query(query:, type: :active_record)
         handler_klass = \
           case type
           when :active_record

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

data/lib/praxis/finalizable.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Praxis
+  module Finalizable
+    def self.extended(klass)
+      klass.module_eval do
+        @finalizable = Set.new
+      end
+    end
+
+    def inherited(base)
+      @finalizable << base
+      base.instance_variable_set(:@finalizable, @finalizable)
+      base.instance_variable_set(:@finalized, false)
+    end
+
+    def finalizable
+      @finalizable
+    end
+
+    def finalized?
+      @finalized
+    end
+
+    def _finalize!
+      @finalized = true
+    end
+
+    def finalize!
+      finalizable.reject(&:finalized?).each(&:_finalize!)
+
+      finalize! unless finalizable.all?(&:finalized?)
+    end
+  end
+end

data/lib/praxis/mapper/selector_generator.rb

@@ -48,7 +48,7 @@ module Praxis::Mapper
         new_fields_as_hash = association[:remote_key_columns].each_with_object({}) do|name, hash|
           hash[name] = true
         end
-        fields.merge!(new_fields_as_hash) 
+        fields = fields.merge(new_fields_as_hash) 
       end
 
       node.add(fields) unless fields == true

data/lib/praxis/media_type.rb

@@ -34,8 +34,9 @@ module Praxis
   #         description: 'The factory in which this widget was produced'
   #     end
   #
-  #     # All resources should have a default view
-  #     view :default do
+  #     # All resources will be assigned a default_fieldset (with only non-blueprint attributes)
+  #     # But one can explicitly tailor that by using the `default_fieldset` DSL
+  #     default_fieldset do
   #       attribute :id
   #       attribute :color
   #       attribute :material
@@ -44,72 +45,6 @@ module Praxis
   class MediaType < Praxis::Blueprint
 
     include Types::MediaTypeCommon
-
-    class FieldResolver
-      def self.resolve(type,fields)
-        self.new.resolve(type,fields)
-      end
-
-      attr_reader :history
-
-      def initialize
-        @history = Hash.new do |hash,key|
-          hash[key] = Hash.new
-        end
-      end
-
-      def resolve(type,fields)
-        history_key = fields
-        history_type = type
-        if fields.kind_of?(Array)
-          loop do
-            type = type.member_attribute.type
-            fields = fields.first
-            break unless fields.kind_of?(Array)
-          end
-        end
-
-        return true if fields == true
-
-        if history[history_type].include? history_key
-          return history[history_type][history_key]
-        end
-
-        result = history[history_type][history_key] = {}
-
-
-        fields.each do |name, sub_fields|
-
-          new_type = type.attributes[name].type
-          result[name] = resolve(new_type, sub_fields)
-        end
-
-        result
-      end
-
-      # perform a deep recursive *in place* merge
-      # form all values in +source+ onto +target+
-      #
-      # note: can not use ActiveSupport's Hash#deep_merge! because it does not
-      # properly do a recursive `deep_merge!`, but instead does `deep_merge`,
-      # which destroys the self-referential behavior of field hashes.
-      #
-      # note: unlike Hash#merge, doesn't take a block.
-      def deep_merge(target, source)
-        source.each do |current_key, source_value|
-          target_value = target[current_key]
-
-          target[current_key] = if target_value.is_a?(Hash) && source_value.is_a?(Hash)
-            deep_merge(target_value, source_value)
-          else
-            source_value
-          end
-        end
-        target
-      end
-
-    end
-
   end
 
 end

data/lib/praxis/plugin_concern.rb

@@ -11,7 +11,7 @@ module Praxis
       PLUGIN_CLASSES = [
         :Request,
         :Controller,
-        :ResourceDefinition,
+        :EndpointDefinition,
         :ActionDefinition,
         :Response,
         :ApiGeneralInfo

data/lib/praxis/plugins/mapper_plugin.rb

@@ -1,7 +1,6 @@
 require 'singleton'
-require 'praxis/extensions/attribute_filtering'
 
-module Praxis
+module Praxis  
   module Plugins
     module MapperPlugin
       include Praxis::PluginConcern
@@ -36,20 +35,21 @@ module Praxis
           return unless self.media_type.respond_to?(:domain_model) &&
             self.media_type.domain_model < Praxis::Mapper::Resource
 
-          resolved = Praxis::MediaType::FieldResolver.resolve(self.media_type, self.expanded_fields)
-          selector_generator.add(self.media_type.domain_model, resolved)
+          selector_generator.add(self.media_type.domain_model, self.expanded_fields)
         end
 
-        def build_query(base_query) # rubocop:disable Metrics/AbcSize
+        def build_query(base_query, type: :active_record) # rubocop:disable Metrics/AbcSize
           domain_model = self.media_type&.domain_model
           raise "No domain model defined for #{self.name}. Cannot use the attribute filtering helpers without it" unless domain_model
           
           filters = request.params.filters if request.params&.respond_to?(:filters)
+          # Handle filters
           base_query = domain_model.craft_filter_query( base_query , filters: filters )
-
+          # Handle field and nested field selection
           base_query = domain_model.craft_field_selection_query(base_query, selectors: selector_generator.selectors)
+          # handle pagination and ordering
+          base_query = _craft_pagination_query(query: base_query, type: type) if self.respond_to?(:_pagination)
 
-          # TODO: handle pagination and ordering
           base_query
         end
 

data/lib/praxis/renderer.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Praxis
+  class Renderer
+    attr_reader :include_nil
+    attr_reader :cache
+
+    class CircularRenderingError < StandardError
+      attr_reader :object
+      attr_reader :context
+
+      def initialize(object, context)
+        @object = object
+        @context = context
+
+        first = Attributor.humanize_context(context[0..10])
+        last = Attributor.humanize_context(context[-5..-1])
+        pretty_context = "#{first}...#{last}"
+        super("SystemStackError in rendering #{object.class} with context: #{pretty_context}")
+      end
+    end
+
+    def initialize(include_nil: false)
+      @cache = Hash.new do |hash, key|
+        hash[key] = {}
+      end
+
+      @include_nil = include_nil
+    end
+
+    # Renders an object using a given list of fields.
+    #
+    # @param [Object] object the object to render
+    # @param [Hash] fields the correct set of fields, as from FieldExpander
+    def render(object, fields, context: Attributor::DEFAULT_ROOT_CONTEXT)
+      if object.is_a? Praxis::Blueprint
+        @cache[object._cache_key][fields] ||= _render(object, fields, context: context)
+      else
+        if object.class < Attributor::Collection
+          object.each_with_index.collect do |sub_object, i|
+            sub_context = context + ["at(#{i})"]
+            render(sub_object, fields, context: sub_context)
+          end
+        else
+          _render(object, fields, context: context)
+        end
+      end
+    rescue SystemStackError
+      raise CircularRenderingError.new(object, context)      
+    end
+
+    def _render(object, fields, context: Attributor::DEFAULT_ROOT_CONTEXT)
+      if fields == true
+        return case object
+               when Attributor::Dumpable
+                 object.dump
+               else
+                 object
+               end
+      end
+
+      fields.each_with_object({}) do |(key, subfields), hash|
+        begin
+          value = object._get_attr(key)
+        rescue => e
+          raise Attributor::DumpError.new(context: context, name: key, type: object.class, original_exception: e)
+        end
+
+        if value.nil?
+          hash[key] = nil if self.include_nil
+          next
+        end
+
+        if subfields == true
+          hash[key] = case value
+                      when Attributor::Dumpable
+                        value.dump
+                      else
+                        value
+                      end
+        else
+          new_context = context + [key]
+          hash[key] = render(value, subfields, context: new_context)
+        end
+      end
+    end
+  end
+end