praxis 0.22.pre.1 → 2.0.pre.4

data/lib/praxis/extensions/rendering.rb

@@ -24,7 +24,7 @@ module Praxis
         response.body = render(object, include_nil: include_nil)
         response
       rescue Praxis::Renderer::CircularRenderingError => e
-          Praxis::Application.current_instance.validation_handler.handle!(
+          Praxis::Application.instance.validation_handler.handle!(
           summary: "Circular Rendering Error when rendering response. " +
                    "Please especify a view to narrow the dependent fields, or narrow your field set.",
           exception: e,

data/lib/praxis/file_group.rb

@@ -7,7 +7,7 @@ module Praxis
     def initialize(base, &block)
       if base.nil?
         raise ArgumentError, "base must not be nil." \
-          "Have you forgot to call 'setup' on the Praxis application instance?"
+          "Are you missing a call Praxis::Application.instance.setup?"
       end
 
 

data/lib/praxis/handlers/xml.rb

@@ -60,7 +60,7 @@ module Praxis
         when "symbol"
           return node.content.to_sym
         when "decimal"
-          return BigDecimal.new(node.content)
+          return BigDecimal(node.content)
         when "float"
           return Float(node.content)
         when "boolean"

data/lib/praxis/mapper/active_model_compat.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+require 'praxis/extensions/field_selection/active_record_query_selector'
+
+module Praxis
+  module Mapper
+    module ActiveModelCompat
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :_resource
+      end
+
+      module ClassMethods
+        def _filter_query_builder_class
+          Praxis::Extensions::ActiveRecordFilterQueryBuilder
+        end
+
+        def _field_selector_query_builder_class
+          Praxis::Extensions::FieldSelection::ActiveRecordQuerySelector
+        end
+
+        def _praxis_associations
+          orig = self.reflections.clone
+
+          orig.each_with_object({}) do |(k, v), hash|
+            # Assume an 'id' primary key if the system is initializing without AR connected
+            # (or without the tables created). This probably means that it's a rake task initializing or so...
+            pkey = \
+              if v.klass.connected? && v.klass.table_exists?
+                v.klass.primary_key
+              else
+                'id'
+              end
+            info = { model: v.klass, primary_key: pkey }
+            info[:type] = \
+              case v
+              when ActiveRecord::Reflection::BelongsToReflection
+                :many_to_one
+              when ActiveRecord::Reflection::HasManyReflection, ActiveRecord::Reflection::HasOneReflection
+                :one_to_many
+              when ActiveRecord::Reflection::ThroughReflection
+                :many_to_many
+              else
+                raise "Unknown association type: #{v.class.name} on #{v.klass.name} for #{v.name}"
+              end
+            # Call out any local (i.e., of this model) columns that participate in the association 
+            info[:local_key_columns] = local_columns_used_for_the_association(info[:type], v)
+            info[:remote_key_columns] = remote_columns_used_for_the_association(info[:type], v)
+
+            if v.is_a?(ActiveRecord::Reflection::ThroughReflection)
+              info[:through] = v.through_reflection.name # TODO: is this correct?
+            end
+            hash[k.to_sym] = info
+          end
+        end
+
+        private
+        def local_columns_used_for_the_association(type, assoc_reflection)
+          case type
+          when :one_to_many
+            # The associated table  will point to us by key (usually the PK, but not always)
+            [assoc_reflection.join_keys.foreign_key.to_sym]
+          when :many_to_one
+            # We have the FKs to the associated model
+            [assoc_reflection.join_keys.foreign_key.to_sym]
+          when :many_to_many
+            ref = resolve_closest_through_reflection(assoc_reflection)
+            # The associated middle table will point to us by key (usually the PK, but not always)
+            [ref.join_keys.foreign_key.to_sym] # The foreign key that the last through table points to
+          else 
+            raise "association type #{type} not supported"
+          end
+        end
+
+        def remote_columns_used_for_the_association(type, assoc_reflection)
+          # It seems that since the reflection is the target of the association, using the join_keys.key
+          # will always get us the right column
+          case type
+          when :one_to_many, :many_to_one, :many_to_many
+            [assoc_reflection.join_keys.key.to_sym]
+          else 
+            raise "association type #{type} not supported"
+          end
+        end
+  
+        # Keep following the association reflections as long as there are middle ones (i.e., through)
+        # until we come to the one next to the source
+        def resolve_closest_through_reflection(ref)
+          return ref unless ref.through_reflection?
+          resolve_closest_through_reflection( ref.through_reflection )
+        end
+      end
+    end
+  end
+end

data/lib/praxis/mapper/resource.rb

@@ -0,0 +1,242 @@
+# A resource creates a data store and instantiates a list of models that it wishes to load, building up the overall set of data that it will need.
+# Once that is complete, the data set is iterated and a resultant view is generated.
+module Praxis::Mapper
+  
+  class Resource
+    extend Praxis::Finalizable
+
+    attr_accessor :record
+
+    @properties = {}
+
+    class << self
+      attr_reader :model_map
+      attr_reader :properties
+    end
+
+    # TODO: also support an attribute of sorts on the versioned resource module. ie, V1::Resources.api_version.
+    #       replacing the self.superclass == Praxis::Mapper::Resource condition below.
+    def self.inherited(klass)
+      super
+
+      klass.instance_eval do
+        # It is expected that each versioned set of resources
+        # will have a common Base class, and so should share
+        # a model_map
+        if self.superclass == Praxis::Mapper::Resource
+          @model_map = Hash.new
+        else
+          @model_map = self.superclass.model_map
+        end
+
+        @properties = self.superclass.properties.clone
+      end
+
+    end
+
+    #TODO: Take symbol/string and resolve the klass (but lazily, so we don't care about load order)
+    def self.model(klass=nil)
+      if klass
+        raise "Model #{klass.name} must be compatible with Praxis. Use ActiveModelCompat or similar compatability plugin." unless klass.methods.include?(:_praxis_associations)
+        @model = klass
+        self.model_map[klass] = self
+      else
+        @model
+      end
+    end
+
+    def self.property(name, **options)
+      self.properties[name] = options
+    end
+
+    def self._finalize!
+      finalize_resource_delegates
+      define_model_accessors
+
+      super
+    end
+
+    def self.finalize_resource_delegates
+      return unless @resource_delegates
+
+      @resource_delegates.each do |record_name, record_attributes|
+        record_attributes.each do |record_attribute|
+          self.define_resource_delegate(record_name, record_attribute)
+        end
+      end
+    end
+
+
+    def self.define_model_accessors
+      return if model.nil?
+
+      model._praxis_associations.each do |k,v|
+        unless self.instance_methods.include? k
+          define_model_association_accessor(k,v)
+        end
+      end
+    end
+
+    def self.for_record(record)
+      return record._resource if record._resource
+
+      if resource_class_for_record = model_map[record.class]
+        return record._resource = resource_class_for_record.new(record)
+      else
+        version = self.name.split("::")[0..-2].join("::")
+        resource_name = record.class.name.split("::").last
+
+        raise "No resource class corresponding to the model class '#{record.class}' is defined. (Did you forget to define '#{version}::#{resource_name}'?)"
+      end
+    end
+
+
+    def self.wrap(records)
+      if records.nil?
+        return []
+      elsif( records.is_a?(Enumerable) )
+        return records.compact.map { |record| self.for_record(record) }
+      elsif ( records.respond_to?(:to_a) )
+        return records.to_a.compact.map { |record| self.for_record(record) }
+      else
+        return self.for_record(records)
+      end
+    end
+
+
+    def self.get(condition)
+      record = self.model.get(condition)
+
+      self.wrap(record)
+    end
+
+    def self.all(condition={})
+      records = self.model.all(condition)
+
+      self.wrap(records)
+    end
+
+
+    def self.resource_delegates
+      @resource_delegates ||= {}
+    end
+
+    def self.resource_delegate(spec)
+      spec.each do |resource_name, attributes|
+        resource_delegates[resource_name] = attributes
+      end
+    end
+
+    # Defines wrappers for model associations that return Resources
+    def self.define_model_association_accessor(name, association_spec)
+      association_model = association_spec.fetch(:model)
+      association_resource_class = model_map[association_model]
+
+      if association_resource_class
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name}
+          records = record.#{name}
+            return nil if records.nil?
+          @__#{name} ||= #{association_resource_class}.wrap(records)
+        end
+        RUBY
+      end
+    end
+
+    def self.define_resource_delegate(resource_name, resource_attribute)
+      related_model = model._praxis_associations[resource_name][:model]
+      related_association = related_model._praxis_associations[resource_attribute]
+
+      if related_association
+        self.define_delegation_for_related_association(resource_name, resource_attribute, related_association)
+      else
+        self.define_delegation_for_related_attribute(resource_name, resource_attribute)
+      end
+    end
+
+
+    def self.define_delegation_for_related_attribute(resource_name, resource_attribute)
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{resource_attribute}
+          @__#{resource_attribute} ||= if (rec = self.#{resource_name})
+          rec.#{resource_attribute}
+            end
+        end
+      RUBY
+    end
+
+    def self.define_delegation_for_related_association(resource_name, resource_attribute, related_association)
+      related_resource_class = model_map[related_association[:model]]
+      return unless related_resource_class
+
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{resource_attribute}
+          @__#{resource_attribute} ||= if (rec = self.#{resource_name})
+          if (related = rec.#{resource_attribute})
+            #{related_resource_class.name}.wrap(related)
+          end
+        end
+      end
+      RUBY
+    end
+
+    def self.define_accessor(name)
+      if name.to_s =~ /\?/
+        ivar_name = "is_#{name.to_s[0..-2]}"
+      else
+        ivar_name = "#{name}"
+      end
+
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def #{name}
+        return @__#{ivar_name} if defined? @__#{ivar_name}
+        @__#{ivar_name} = record.#{name}
+      end
+      RUBY
+    end
+
+    # TODO: this shouldn't be needed if we incorporate it with the properties of the mapper...
+    def self.filters_mapping(hash)
+      @_filter_query_builder_class = model._filter_query_builder_class.for(**hash)
+    end
+    
+    def self._filter_query_builder_class
+      @_filter_query_builder_class
+    end
+
+    def self.craft_filter_query(base_query, filters:) # rubocop:disable Metrics/AbcSize
+      if filters && _filter_query_builder_class
+        base_query = _filter_query_builder_class.new(query: base_query, model: model).build_clause(filters)
+      end
+      
+      base_query
+    end
+
+    def self.craft_field_selection_query(base_query, selectors:) # rubocop:disable Metrics/AbcSize
+      if selectors && model._field_selector_query_builder_class
+        debug = Praxis::Application.instance.config.mapper.debug_queries
+        base_query = model._field_selector_query_builder_class.new(query: base_query, selectors: selectors).generate(debug: debug)
+      end
+      
+      base_query
+    end
+
+    def initialize(record)
+      @record = record
+    end
+
+    def respond_to_missing?(name,*)
+      @record.respond_to?(name) || super
+    end
+
+    def method_missing(name,*args)
+      if @record.respond_to?(name)
+        self.class.define_accessor(name)
+        self.send(name)
+      else
+        super
+      end
+    end
+
+  end
+end

data/lib/praxis/mapper/selector_generator.rb

@@ -0,0 +1,154 @@
+module Praxis::Mapper
+
+  class SelectorGeneratorNode
+    attr_reader :select, :model, :resource, :tracks
+
+    def initialize(resource)
+      @resource = resource
+
+      @select = Set.new
+      @select_star = false
+      @tracks = Hash.new 
+    end
+
+    def add(fields)
+      fields.each do |name, field|
+        map_property(name, field)
+      end
+      self
+    end
+
+    def map_property(name, fields)
+      praxis_compat_model = resource.model && resource.model.respond_to?(:_praxis_associations)
+      if resource.properties.key?(name)
+        add_property(name, fields)
+      elsif praxis_compat_model && resource.model._praxis_associations.key?(name)
+        add_association(name, fields)
+      else
+        add_select(name)
+      end
+    end
+
+    def add_association(name, fields)
+      
+      association = resource.model._praxis_associations.fetch(name) do
+        raise "missing association for #{resource} with name #{name}"
+      end
+      associated_resource = resource.model_map[association[:model]]
+      unless associated_resource
+        raise "Whoops! could not find a resource associated with model #{association[:model]} (root resource #{resource})"
+      end
+      # Add the required columns in this model to make sure the association can be loaded
+      association[:local_key_columns].each {|col| add_select(col) }
+      
+      node = SelectorGeneratorNode.new(associated_resource)
+      if association[:remote_key_columns].nil?
+        binding.pry
+        puts association
+      end
+      unless association[:remote_key_columns].empty?
+        # Make sure we add the required columns for this association to the remote model query
+        fields = {} if fields == true
+        new_fields_as_hash = association[:remote_key_columns].each_with_object({}) do|name, hash|
+          hash[name] = true
+        end
+        fields.merge!(new_fields_as_hash) 
+      end
+
+      node.add(fields) unless fields == true
+
+      self.merge_track(name, node)
+    end
+
+    def add_select(name)
+      return @select_star = true if name == :*
+      return if @select_star
+      @select.add name
+    end
+
+    def add_property(name, fields)
+      dependencies = resource.properties[name][:dependencies]
+      # Always add the underlying association if we're overriding the name...
+      praxis_compat_model = resource.model && resource.model.respond_to?(:_praxis_associations)
+      if praxis_compat_model && resource.model._praxis_associations.key?(name)
+        add_association(name, fields)
+      end
+      if dependencies
+        dependencies.each do |dependency|
+          # To detect recursion, let's allow mapping depending fields to the same name of the property
+          # but properly detecting if it's a real association...in which case we've already added it above
+          if dependency == name
+            unless praxis_compat_model && resource.model._praxis_associations.key?(name)
+              add_select(name)
+            end
+          else
+            apply_dependency(dependency)
+          end
+        end
+      end
+
+      head, *tail = resource.properties[name][:through]
+      return if head.nil?
+
+      new_fields = tail.reverse.inject(fields) do |thing, step|
+        {step => thing}
+      end
+
+      add_association(head, new_fields)
+    end
+
+    def apply_dependency(dependency)
+      case dependency
+      when Symbol
+        map_property(dependency, true)
+      when String
+        head, tail = dependency.split('.').collect(&:to_sym)
+        raise "String dependencies can not be singular" if tail.nil?
+
+        add_association(head, {tail => true})
+      end
+    end
+
+    def merge_track( track_name, node )
+      raise "Cannot merge another node for association #{track_name}: incompatible model" unless node.model == self.model
+
+      existing = self.tracks[track_name]
+      if existing
+        node.select.each do|col_name|
+          existing.add_select(col_name)
+        end
+        node.tracks.each do |name, n|
+          existing.merge_track(name, n)
+        end
+      else
+        self.tracks[track_name] = node
+      end
+    end
+
+    def dump
+      hash = {}
+      hash[:model] = resource.model
+      if !@select.empty? || @select_star
+        hash[:columns] = @select_star ? [ :* ] : @select.to_a 
+      end
+      unless @tracks.empty?
+        hash[:tracks] = @tracks.each_with_object({}) {|(name, node), hash|  hash[name] = node.dump }
+      end
+      hash
+    end
+  end
+
+  # Generates a set of selectors given a resource and
+  # list of resource attributes.
+  class SelectorGenerator
+    # Entry point
+    def add(resource, fields)
+      @root = SelectorGeneratorNode.new(resource)
+      @root.add(fields)
+    end
+
+    def selectors
+      @root
+    end
+  end
+end