praxis 0.22.pre.2 → 2.0.pre.1

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/active_record_query_selector.rb

@@ -3,49 +3,47 @@ module Praxis
   module Extensions
     module FieldSelection
       class ActiveRecordQuerySelector
-        attr_reader :selector, :ds, :top_model, :resolved, :root
+        attr_reader :selector, :query, :top_model, :resolved, :root
         # Gets a dataset, a selector...and should return a dataset with the selector definition applied.
-        def initialize(ds:, model:, selectors:, resolved:)
+        def initialize(query:, model:, selectors:, resolved:)
           @selector = selectors
-          @ds = ds
+          @query = query
           @top_model = model
           @resolved = resolved
           @seen = Set.new
           @root = model.table_name
         end
 
-        def add_select(ds:, model:, table_name:)
+        def add_select(query:, model:, table_name:)
           if (fields = fields_for(model))
             # Note, let's always add the pk fields so that associations can load properly
             fields = fields | [model.primary_key.to_sym]
-            ds.select(*fields)
+            query.select(*fields)
           else
-            ds
+            query
           end
         end
 
         def generate
           # 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...)
-          @ds = add_select(ds: ds, model: top_model, table_name: root)
+          @query = add_select(query: query, model: top_model, table_name: root)
 
-          @ds.includes(_eager(top_model, resolved) )
+          @query.includes(_eager(top_model, resolved) )
         end
 
         def _eager(model, resolved)
-            # Cannot select fields in included rels...boooo :()
-            # d = add_select(ds: dset, model: model, table_name: model.table_name)
-            tracks = only_assoc_for(model, resolved)
-            tracks.inject([]) do |dataset, track|
-              next dataset if @seen.include?([model, track])
-              @seen << [model, track]
-              assoc_model = model.associations[track][:model]
-              dataset << { track => _eager(assoc_model, resolved[track]) }
-            end
+          tracks = only_assoc_for(model, resolved)
+          tracks.inject([]) do |dataset, track|
+            next dataset if @seen.include?([model, track])
+            @seen << [model, track]
+            assoc_model = model._praxis_associations[track][:model]
+            dataset << { track => _eager(assoc_model, resolved[track]) }
+          end
         end
 
         def only_assoc_for(model, hash)
-          hash.keys.reject { |assoc| model.associations[assoc].nil? }
+          hash.keys.reject { |assoc| model._praxis_associations[assoc].nil? }
         end
 
         def fields_for(model)

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

@@ -5,9 +5,9 @@ module Praxis
       class SequelQuerySelector
         attr_reader :selector, :ds, :top_model, :resolved, :root
         # Gets a dataset, a selector...and should return a dataset with the selector definition applied.
-        def initialize(ds:, model:, selectors:, resolved:)
+        def initialize(query:, model:, selectors:, resolved:)
           @selector = selectors
-          @ds = ds
+          @ds = query
           @top_model = model
           @resolved = resolved
           @seen = Set.new
@@ -32,7 +32,7 @@ module Praxis
           @ds = tracks.inject(@ds) do |dataset, track|
             next dataset if @seen.include?([top_model, track])
             @seen << [top_model, track]
-            assoc_model = top_model.associations[track][:model]
+            assoc_model = top_model._praxis_associations[track][:model]
             #      hash[track] = _eager(assoc_model, resolved[track])
             dataset.eager(track => _eager(assoc_model, resolved[track]))
           end
@@ -46,14 +46,14 @@ module Praxis
             tracks.inject(d) do |dataset, track|
               next dataset if @seen.include?([model, track])
               @seen << [model, track]
-              assoc_model = model.associations[track][:model]
+              assoc_model = model._praxis_associations[track][:model]
               dataset.eager(track => _eager(assoc_model, resolved[track]))
             end
           end
         end
 
         def only_assoc_for(model, hash)
-          hash.keys.reject { |assoc| model.associations[assoc].nil? }
+          hash.keys.reject { |assoc| model._praxis_associations[assoc].nil? }
         end
 
         def fields_for(model)

data/lib/praxis/extensions/field_selection.rb

@@ -1,13 +1,2 @@
 require 'attributor/extras/field_selector'
-
-require 'praxis/extensions/field_selection/field_selector'
-# TODO: we should conditionally require it based on what ORM/s we want...
-require 'praxis/extensions/field_selection/active_record_query_selector'
-
-
-module Praxis
-  module Extensions
-    module FieldSelection
-    end
-  end
-end
+require 'praxis/extensions/field_selection/field_selector'

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,63 @@
+# 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
+
+            if v.is_a?(ActiveRecord::Reflection::ThroughReflection)
+              info[:through] = v.through_reflection.name # TODO: is this correct?
+            end
+
+            # TODO: add more keys for the association to make true praxis mapper functions happy
+            hash[k.to_sym] = info
+          end
+        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:, resolved:) # rubocop:disable Metrics/AbcSize
+      if selectors && model._field_selector_query_builder_class
+        base_query = model._field_selector_query_builder_class.new(query: base_query, model: self.model,
+                                          selectors: selectors, resolved: resolved).generate
+      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