praxis 0.21 → 2.0.pre.3

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

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+# rubocop:disable all
+module Praxis
+  module Extensions
+    class SequelFilterQueryBuilder
+      attr_reader :query, :root
+
+      # Abstract class, which needs to be used by subclassing it through the .for method, to set the mapping of attributes
+      class << self
+        def for(definition)
+          Class.new(self) do
+            @attr_to_column = case definition
+                              when Hash
+                                definition
+                              when Array
+                                definition.each_with_object({}) { |item, hash| hash[item.to_sym] = item }
+                              else
+                                raise "Cannot use FilterQueryBuilder.of without passing an array or a hash (Got: #{definition.class.name})"
+                              end
+            class << self
+              attr_reader :attr_to_column
+            end
+          end
+        end
+      end
+
+      # Base query to build upon
+      # table is necessary when use the strin queries, when the query has multiple tables involved
+      # (to disambiguate)
+      def initialize(query:, model: )
+        @query = query
+        @root = model.table_name
+      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
+      def build_clause(filters)
+        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
+          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
+            bindings.each{|col,val| expand_binding(column_name: col, op: spec[:op], value: val )}
+          else
+            expand_binding(column_name: column_name, **spec)
+          end
+        end
+        query
+      end
+
+      def expand_binding(column_name:,op:,value:)
+        assoc_or_field, *rest = column_name.to_s.split('.')
+        if rest.empty?
+          column_name = Sequel.qualify(root,column_name)
+        else
+          puts "Adding eager graph for #{assoc_or_field} due to being used in filter"
+          # Ensure the joined table is aliased properly (to the association name) so we can add the condition appropriately
+          @query = query.eager_graph(Sequel.as(assoc_or_field.to_sym, assoc_or_field.to_sym) )
+          column_name = Sequel.qualify(assoc_or_field, rest.first)
+        end
+        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
+      end
+
+      # Private to try to funnel all column names through `build_clause` that restricts
+      # the attribute names better (to allow more difficult SQL injections )
+      private def add_clause(attr:, op:, value:)
+        # TODO: partial matching
+        #components = attr.to_s.split('.')
+        #attr_selector = Sequel.qualify(*components)
+        attr_selector = attr
+  #      HERE!! if we have "association.name" we should properly join it ...!
+
+  #> ds.eager_graph(:device).where{{device[:name] => 'A%'}}.select(:accountID)
+  #=> #<Sequel::Mysql2::Dataset: "SELECT `accountID` FROM `EventData`
+  #     LEFT OUTER JOIN `Device` AS `device` ON
+  #           ((`device`.`accountID` = `EventData`.`accountID`) AND (`device`.`deviceID` = `EventData`.`deviceID`))
+  #      WHERE (`device`.`name` = 'A%')">
+        likeval = get_like_value(value)
+        @query =  case op
+                  when '='
+                    if likeval
+                      query.where(Sequel.like(attr_selector, likeval))
+                    else
+                      query.where(attr_selector => value)
+                    end
+                  when '!='
+                    if likeval
+                      query.exclude(Sequel.like(attr_selector, likeval))
+                    else
+                      query.exclude(attr_selector => value)
+                    end
+                  when '>'
+                    #query.where(Sequel.lit("#{attr_selector} > ?", value))
+                    query.where{attr_selector > value}
+                  when '<'
+                    query.where{attr_selector < value}
+                  when '>='
+                    query.where{attr_selector >= value}
+                  when '<='
+                    query.where{attr_selector <= value}
+                  else
+                    raise "Unsupported Operator!!! #{op}"
+                  end
+      end
+
+      # Returns nil if the value was not a fuzzzy pattern
+      def get_like_value(value)
+        if value.is_a?(String) && (value[-1] == '*' || value[0] == '*')
+          likeval = value.dup
+          likeval[-1] = '%' if value[-1] == '*'
+          likeval[0] = '%' if value[0] == '*'
+          likeval
+        end
+      end
+    end
+  end
+end
+# rubocop:enable all

data/lib/praxis/extensions/field_selection.rb

@@ -1,10 +1,2 @@
 require 'attributor/extras/field_selector'
-
-require 'praxis/extensions/field_selection/field_selector'
-
-module Praxis
-  module Extensions
-    module FieldSelection
-    end
-  end
-end
+require 'praxis/extensions/field_selection/field_selector'

data/lib/praxis/extensions/field_selection/active_record_query_selector.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+module Praxis
+  module Extensions
+    module FieldSelection
+      class ActiveRecordQuerySelector
+        attr_reader :selector, :query
+        # Gets a dataset, a selector...and should return a dataset with the selector definition applied.
+        def initialize(query:, selectors:)
+          @selector = selectors
+          @query = query
+        end
+
+        def generate(debug: false)
+          # TODO: unfortunately, I think we can only control the select clauses for the top model 
+          # (as I'm not sure ActiveRecord supports expressing it in the join...)
+          @query = add_select(query: query, selector_node: selector)
+          eager_hash = _eager(selector)
+
+          @query = @query.includes(eager_hash)          
+          explain_query(query, eager_hash) if debug
+
+          @query
+        end
+
+        def add_select(query:, selector_node:)
+          # We're gonna always require the PK of the model, as it is a special case for AR, and the app itself 
+          # might assume it is always there and not be surprised by the fact that if it isn't, it won't blow up
+          # in the same way as any other attribute not being loaded...i.e., ActiveModel::MissingAttributeError: missing attribute: xyz
+          select_fields = selector_node.select + [selector_node.resource.model.primary_key.to_sym]
+          select_fields.empty? ? query : query.select(*select_fields)
+        end
+
+        def _eager(selector_node)
+          selector_node.tracks.each_with_object({}) do |(track_name, track_node), h|
+            h[track_name] = _eager(track_node)
+          end
+        end
+
+        def explain_query(query, eager_hash)
+          prev = ActiveRecord::Base.logger
+          ActiveRecord::Base.logger = Logger.new(STDOUT)
+          ActiveRecord::Base.logger.debug("Query plan for ...#{selector.resource.model} with selectors: #{JSON.generate(selector.dump)}")
+          ActiveRecord::Base.logger.debug(" ActiveRecord query: #{selector.resource.model}.includes(#{eager_hash})")
+          query.explain
+          ActiveRecord::Base.logger.debug("Query plan end")
+          ActiveRecord::Base.logger = prev
+        end
+      end
+    end
+  end
+end

data/lib/praxis/extensions/field_selection/sequel_query_selector.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'sequel'
+
+module Praxis
+  module Extensions
+    module FieldSelection
+      class SequelQuerySelector
+        attr_reader :selector, :query
+        # Gets a dataset, a selector...and should return a dataset with the selector definition applied.
+        def initialize(query:, selectors:)
+          @selector = selectors
+          @query = query
+        end
+
+        def generate(debug: false)
+          @query = add_select(query: query, selector_node: @selector)
+          
+          @query = @selector.tracks.inject(@query) do |ds, (track_name, track_node)|
+            ds.eager(track_name => _eager(track_node) )
+          end
+
+          explain_query(query) if debug
+          @query
+        end
+
+        def _eager(selector_node)
+          lambda do |dset|
+            dset = add_select(query: dset, selector_node: selector_node)
+
+            dset = selector_node.tracks.inject(dset) do |ds, (track_name, track_node)|
+              ds.eager(track_name => _eager(track_node) )
+            end
+
+          end
+        end
+
+        def add_select(query:, selector_node:)
+          # We're gonna always require the PK of the model, as it is a special case for Sequel, and the app itself 
+          # might assume it is always there and not be surprised by the fact that if it isn't, it won't blow up
+          # in the same way as any other attribute not being loaded...i.e., NoMethodError: undefined method `foobar' for #<...>
+          select_fields = selector_node.select + [selector_node.resource.model.primary_key.to_sym]
+    
+          table_name = selector_node.resource.model.table_name
+          qualified = select_fields.map { |f| Sequel.qualify(table_name, f) }
+          query.select(*qualified)
+        end
+
+        def explain_query(ds)
+          prev_loggers = Sequel::Model.db.loggers
+          stdout_logger = Logger.new($stdout)
+          Sequel::Model.db.loggers = [stdout_logger]
+          stdout_logger.debug("Query plan for ...#{selector.resource.model} with selectors: #{JSON.generate(selector.dump)}")
+          ds.all
+          stdout_logger.debug("Query plan end")
+          Sequel::Model.db.loggers = prev_loggers
+        end
+      end
+    end
+  end
+end

data/lib/praxis/extensions/rails_compat.rb

@@ -0,0 +1,2 @@
+require 'praxis/extensions/rails_compat/request_methods'
+require 'praxis/plugins/rails_plugin'

data/lib/praxis/extensions/rails_compat/request_methods.rb

@@ -0,0 +1,19 @@
+# Make Praxis' request derive from ActionDispatch
+if defined? Praxis::Request
+  puts "IT seems that we're trying to redefine Praxis' request parent too late."
+  puts "-> try to include the Rails compat pieces earlier in the bootstrap process (before Praxis::Request is requried)"
+  exit(-1)
+end
+
+begin
+  require 'praxis/request_superclassing'
+
+  module Praxis
+    require 'action_dispatch'
+    Praxis.request_superclass = ::ActionDispatch::Request
+  end
+  require 'praxis/request'
+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