praxis 2.0.pre.17 → 2.0.pre.21

data/lib/praxis/handlers/{xml-sample.rb → xml_sample.rb}

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 # This is an example of a handler that can load and generate 'activesupport-style' xml payloads.
-# Note that if you use your API to pass nil values for attributes as a way to unset their values, 
-# this handler will not work (as there isn't necessarily a defined "null"  value in this encoding 
+# Note that if you use your API to pass nil values for attributes as a way to unset their values,
+# this handler will not work (as there isn't necessarily a defined "null"  value in this encoding
 # (although you can probably define how to encode/decode it and use it as such)
 # Use at your own risk
 
@@ -17,7 +19,7 @@ module Praxis
         ActiveSupport::XmlMini.backend = 'Nokogiri'
       rescue LoadError
         raise Praxis::Exceptions::InvalidConfiguration,
-          "XML handler depends on builder ~> 3.2 and nokogiri ~> 1.6; please add them to your Gemfile"
+              'XML handler depends on builder ~> 3.2 and nokogiri ~> 1.6; please add them to your Gemfile'
       end
 
       # Parse an XML document into structured data.
@@ -46,35 +48,37 @@ module Praxis
 
         case type
         when nil
-          if (node.children.size == 1 && node.child.text?) || node.children.size == 0
+          if (node.children.size == 1 && node.child.text?) || node.children.size.zero?
             # leaf text node
-            return node.content
+            node.content
           else
             # A hash
-            return node.children.each_with_object({}) do |child, hash|
+            node.children.each_with_object({}) do |child, hash|
               next unless child.element? # There might be text fragments like newlines...spaces
+
               hash[child.name.underscore] = process(child, child.attributes['type'])
             end
           end
-        when "array"
-          return node.children.each_with_object([]) do |child, arr|
+        when 'array'
+          node.children.each_with_object([]) do |child, arr|
             next unless child.element? # There might be text fragments like newlines...spaces
+
             arr << process(child, child.attributes['type'])
           end
-        when "integer"
-          return Integer(node.content)
-        when "symbol"
-          return node.content.to_sym
-        when "decimal"
-          return BigDecimal(node.content)
-        when "float"
-          return Float(node.content)
-        when "boolean"
-          return ((node.content == "false") ? false : true)
-        when "date"
-          return Date.parse(node.content)
-        when "dateTime"
-          return DateTime.parse(node.content)
+        when 'integer'
+          Integer(node.content)
+        when 'symbol'
+          node.content.to_sym
+        when 'decimal'
+          BigDecimal(node.content)
+        when 'float'
+          Float(node.content)
+        when 'boolean'
+          node.content != 'false'
+        when 'date'
+          Date.parse(node.content)
+        when 'dateTime'
+          DateTime.parse(node.content)
         else
           raise ArgumentError, "Unknown attribute type: #{type}"
         end

data/lib/praxis/mapper/active_model_compat.rb

@@ -28,7 +28,7 @@ module Praxis
         end
 
         def _praxis_associations
-          orig = self.reflections.clone
+          orig = reflections.clone
 
           orig.each_with_object({}) do |(k, v), hash|
             # Assume an 'id' primary key if the system is initializing without AR connected
@@ -51,7 +51,7 @@ module Praxis
               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 
+            # 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)
 
@@ -63,8 +63,8 @@ module Praxis
         end
 
         def _join_foreign_key_for(assoc_reflection)
-          maj, min, _ = ActiveRecord.gem_version.segments
-          if maj >= 6 && min >=1
+          maj, min, = ActiveRecord.gem_version.segments
+          if maj >= 6 && min >= 1
             assoc_reflection.join_foreign_key.to_sym
           else
             assoc_reflection.join_keys.foreign_key.to_sym
@@ -72,14 +72,16 @@ module Praxis
         end
 
         def _join_primary_key_for(assoc_reflection)
-          maj, min, _ = ActiveRecord.gem_version.segments
-          if maj >= 6 && min >=1
+          maj, min, = ActiveRecord.gem_version.segments
+          if maj >= 6 && min >= 1
             assoc_reflection.join_primary_key.to_sym
           else
             assoc_reflection.join_keys.key.to_sym
           end
         end
+
         private
+
         def local_columns_used_for_the_association(type, assoc_reflection)
           case type
           when :one_to_many
@@ -92,7 +94,7 @@ module Praxis
             ref = resolve_closest_through_reflection(assoc_reflection)
             # The associated middle table will point to us by key (usually the PK, but not always)
             [_join_foreign_key_for(ref)] # The foreign key that the last through table points to
-          else 
+          else
             raise "association type #{type} not supported"
           end
         end
@@ -103,16 +105,17 @@ module Praxis
           case type
           when :one_to_many, :many_to_one, :many_to_many
             [_join_primary_key_for(assoc_reflection)]
-          else 
+          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 )
+
+          resolve_closest_through_reflection(ref.through_reflection)
         end
       end
     end

data/lib/praxis/mapper/resource.rb

@@ -1,176 +1,178 @@
+# frozen_string_literal: true
+
 # 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
+module Praxis
+  module Mapper
+    class Resource
+      extend Praxis::Finalizable
 
-    attr_accessor :record
+      attr_accessor :record
 
-    @properties = {}
+      @properties = {}
 
-    class << self
-      attr_reader :model_map
-      attr_reader :properties
-    end
+      class << self
+        attr_reader :model_map, :properties
+        # Names of the memoizable things (without the @__ prefix)
+        attr_accessor :memoized_variables
+      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
+      # 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
 
-        @properties = self.superclass.properties.clone
-        @_filters_map = {}
+        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
+          @model_map = if superclass == Praxis::Mapper::Resource
+                         {}
+                       else
+                         superclass.model_map
+                       end
+
+          @properties = superclass.properties.clone
+          @_filters_map = {}
+          @memoized_variables = []
+        end
       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)
 
-    #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
+          @model = klass
+          model_map[klass] = self
+        else
+          @model
+        end
       end
-    end
 
-    def self.property(name, dependencies: nil, through: nil)
-      self.properties[name] = {dependencies: dependencies, through: through}
-    end
+      def self.property(name, dependencies: nil, through: nil)
+        properties[name] = { dependencies: dependencies, through: through }
+      end
 
-    def self._finalize!
-      finalize_resource_delegates
-      define_model_accessors
+      def self._finalize!
+        finalize_resource_delegates
+        define_model_accessors
 
-      super
-    end
+        super
+      end
 
-    def self.finalize_resource_delegates
-      return unless @resource_delegates
+      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)
+        @resource_delegates.each do |record_name, record_attributes|
+          record_attributes.each do |record_attribute|
+            define_resource_delegate(record_name, record_attribute)
+          end
         end
       end
-    end
-
 
-    def self.define_model_accessors
-      return if model.nil?
+      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)
+        model._praxis_associations.each do |k, v|
+          define_model_association_accessor(k, v) unless instance_methods.include? k
         end
       end
-    end
 
-    def self.for_record(record)
-      return record._resource if record._resource
+      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
+        if (resource_class_for_record = model_map[record.class])
+          record._resource = resource_class_for_record.new(record)
+        else
+          version = 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}'?)"
+          raise "No resource class corresponding to the model class '#{record.class}' is defined. (Did you forget to define '#{version}::#{resource_name}'?)"
+        end
       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)
+      def self.wrap(records)
+        if records.nil?
+          []
+        elsif records.is_a?(Enumerable)
+          records.compact.map { |record| for_record(record) }
+        elsif records.respond_to?(:to_a)
+          records.to_a.compact.map { |record| for_record(record) }
+        else
+          for_record(records)
+        end
       end
-    end
-
 
-    def self.get(condition)
-      record = self.model.get(condition)
+      def self.get(condition)
+        record = model.get(condition)
 
-      self.wrap(record)
-    end
-
-    def self.all(condition={})
-      records = self.model.all(condition)
+        wrap(record)
+      end
 
-      self.wrap(records)
-    end
+      def self.all(condition = {})
+        records = model.all(condition)
 
+        wrap(records)
+      end
 
-    def self.resource_delegates
-      @resource_delegates ||= {}
-    end
+      def self.resource_delegates
+        @resource_delegates ||= {}
+      end
 
-    def self.resource_delegate(spec)
-      spec.each do |resource_name, attributes|
-        resource_delegates[resource_name] = attributes
+      def self.resource_delegate(spec)
+        spec.each do |resource_name, attributes|
+          resource_delegates[resource_name] = attributes
+        end
       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]
+      # 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]
+
+        return unless association_resource_class
 
-      if association_resource_class
+        memoized_variables << name
         module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{name}
+          return @__#{name} if instance_variable_defined?("@__#{name}")
+
           records = record.#{name}
-            return nil if records.nil?
+          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]
+      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)
+        if related_association
+          define_delegation_for_related_association(resource_name, resource_attribute, related_association)
+        else
+          define_delegation_for_related_attribute(resource_name, resource_attribute)
+        end
       end
-    end
-
 
-    def self.define_delegation_for_related_attribute(resource_name, resource_attribute)
-      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def self.define_delegation_for_related_attribute(resource_name, resource_attribute)
+        memoized_variables << 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
+        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
+      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
+        memoized_variables << resource_attribute
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
         def #{resource_attribute}
           @__#{resource_attribute} ||= if (rec = self.#{resource_name})
           if (related = rec.#{resource_attribute})
@@ -178,88 +180,101 @@ module Praxis::Mapper
           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}"
+        RUBY
       end
 
-      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def self.define_accessor(name)
+        ivar_name = if name.to_s =~ /\?/
+                      "is_#{name.to_s[0..-2]}"
+                    else
+                      name.to_s
+                    end
+        memoized_variables << ivar_name
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
       def #{name}
-        return @__#{ivar_name} if defined? @__#{ivar_name}
+        return @__#{ivar_name} if instance_variable_defined?("@__#{ivar_name}")
         @__#{ivar_name} = record.#{name}
       end
-      RUBY
-    end
+        RUBY
+      end
 
-    # TODO: this shouldn't be needed if we incorporate it with the properties of the mapper...
-    # ...maybe what this means is that we can change it for a better DSL in the resource?
-    def self.filters_mapping(definition={})
-      @_filters_map = \
-        case definition
-        when Hash
-          definition
-        when Array
-          definition.each_with_object({}) { |item, hash| hash[item.to_sym] = item }
-        else
-          raise "Resource.filters_mapping only allows a hash or an array"
+      # TODO: this shouldn't be needed if we incorporate it with the properties of the mapper...
+      # ...maybe what this means is that we can change it for a better DSL in the resource?
+      def self.filters_mapping(definition = {})
+        @_filters_map = \
+          case definition
+          when Hash
+            definition
+          when Array
+            definition.each_with_object({}) { |item, hash| hash[item.to_sym] = item }
+          else
+            raise 'Resource.filters_mapping only allows a hash or an array'
+          end
+      end
+
+      def self.craft_filter_query(base_query, filters:)
+        if filters
+          raise "To use API filtering, you must define the mapping of api-names to resource properties (using the `filters_mapping` method in #{self})" unless @_filters_map
+
+          debug = Praxis::Application.instance.config.mapper.debug_queries
+          base_query = model._filter_query_builder_class.new(query: base_query, model: model, filters_map: @_filters_map, debug: debug).generate(filters)
         end
-    end
 
-    def self.craft_filter_query(base_query, filters:) # rubocop:disable Metrics/AbcSize
-      if filters 
-        unless @_filters_map
-          raise "To use API filtering, you must define the mapping of api-names to resource properties (using the `filters_mapping` method in #{self})"
+        base_query
+      end
+
+      def self.craft_field_selection_query(base_query, selectors:)
+        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, debug: debug).generate
         end
-        debug = Praxis::Application.instance.config.mapper.debug_queries
-        base_query = model._filter_query_builder_class.new(query: base_query, model: model, filters_map: @_filters_map, debug: debug).generate(filters)
+
+        base_query
       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, debug: debug).generate
+      def self.craft_pagination_query(base_query, pagination:)
+        handler_klass = model._pagination_query_builder_class
+        return base_query unless handler_klass && (pagination.paginator || pagination.order)
+
+        # Gather and save the count if required
+        pagination.total_count = handler_klass.count(base_query.dup) if pagination.paginator&.total_count
+
+        base_query = handler_klass.order(base_query, pagination.order)
+        handler_klass.paginate(base_query, pagination)
       end
-      
-      base_query
-    end
 
-    def self.craft_pagination_query(base_query, pagination: ) # rubocop:disable Metrics/AbcSize
-      handler_klass = model._pagination_query_builder_class
-      return base_query unless (handler_klass && (pagination.paginator || pagination.order))
+      def initialize(record)
+        @record = record
+      end
 
-      # Gather and save the count if required
-      if pagination.paginator&.total_count
-        pagination.total_count = handler_klass.count(base_query.dup)
+      def reload
+        clear_memoization
+        reload_record
       end
-      
-      base_query = handler_klass.order(base_query, pagination.order)
-      handler_klass.paginate(base_query, pagination)
-    end
 
-    def initialize(record)
-      @record = record
-    end
+      def clear_memoization
+        self.class.memoized_variables.each do |name|
+          ivar = "@__#{name}"
+          remove_instance_variable(ivar) if instance_variable_defined?(ivar)
+        end
+      end
 
-    def respond_to_missing?(name,*)
-      @record.respond_to?(name) || super
-    end
+      def reload_record
+        record.reload
+      end
 
-    def method_missing(name,*args)
-      if @record.respond_to?(name)
-        self.class.define_accessor(name)
-        self.send(name)
-      else
-        super
+      def respond_to_missing?(name, *)
+        @record.respond_to?(name) || super
       end
-    end
 
+      def method_missing(name, *args)
+        if @record.respond_to?(name)
+          self.class.define_accessor(name)
+          send(name)
+        else
+          super
+        end
+      end
+    end
   end
 end