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

data/lib/praxis/mapper/sequel_compat.rb

@@ -0,0 +1,76 @@
+require 'active_support/concern'
+
+
+module Praxis::Mapper
+  module SequelCompat
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :_resource
+    end
+
+    module ClassMethods
+      def _filter_query_builder_class
+        Praxis::Extensions::SequelFilterQueryBuilder
+      end
+
+      def _field_selector_query_builder_class
+        Praxis::Extensions::FieldSelection::SequelQuerySelector
+      end
+
+      def _praxis_associations
+        orig = self.association_reflections.clone
+        orig.each do |k,v|
+          v[:model] = v.associated_class
+          v[:local_key_columns] = local_columns_used_for_the_association(v[:type], v)
+          v[:remote_key_columns] = remote_columns_used_for_the_association(v[:type], v)
+          if v.respond_to?(:primary_key)
+            v[:primary_key] = v.primary_key
+          else
+            # FIXME: figure out exactly what to do here. 
+            # not super critical, as we can't track these associations
+            # directly, but it would be nice to traverse these
+            # properly.
+            v[:primary_key] = :unsupported
+          end
+        end
+        orig
+      end
+
+      private
+      def local_columns_used_for_the_association(type, assoc_reflection)
+        case type
+        when :one_to_many
+          # The associated table (or middle table if many to many) will point to us by PK
+          assoc_reflection[:primary_key_columns]
+        when :many_to_one
+          # We have the FKs to the associated model
+          assoc_reflection[:keys]
+        when :many_to_many
+          # The middle table if many to many) will point to us by key (usually the PK, but not always)
+          assoc_reflection[:left_primary_keys]
+        else 
+          raise "association type #{type} not supported"
+        end
+      end
+
+      def remote_columns_used_for_the_association(type, assoc_reflection)
+        case type
+        when :one_to_many
+          # The columns in the associated table that will point back to the original association
+          assoc_reflection[:keys]
+        when :many_to_one
+          # The columns in the associated table that the children will point to (usually the PK, but not always) ??
+          [assoc_reflection.associated_class.primary_key]
+        when :many_to_many
+          # The middle table if many to many will point to us by key (usually the PK, but not always) ??
+          [assoc_reflection.associated_class.primary_key]
+        else 
+          raise "association type #{type} not supported"
+        end
+      end
+
+    end
+
+  end
+end

data/lib/praxis/media_type_identifier.rb

@@ -146,7 +146,8 @@ module Praxis
       if self.parameters.empty?
         self
       else
-        MediaTypeIdentifier.load(type: self.type, subtype: self.subtype, suffix: self.suffix)
+        val = {type: self.type, subtype: self.subtype, suffix: self.suffix}
+        MediaTypeIdentifier.load(val)
       end
     end
 

data/lib/praxis/middleware_app.rb

@@ -2,39 +2,37 @@ module Praxis
   class MiddlewareApp
 
     attr_reader :target
+
     # Initialize the application instance with the desired args, and return the wrapping class.
     def self.for( **args )
       Class.new(self) do
-        class << self
-          attr_accessor :app_instance
-          attr_reader :app_name, :skip_registration
-        end
-        @app_name = args.delete(:name)
-        @skip_registration = args.delete(:skip_registration) || false
         @args = args
-        @app_instance = nil
-        
+        @setup_done = false
         def self.name
           'MiddlewareApp'
         end
         def self.args
           @args
         end
+        def self.setup_done
+          @setup_done
+        end
         def self.setup
-          app_instance.setup(**args)
+          @setup_done = true
+          Praxis::Application.instance.setup(**@args)
         end
       end
-    end
+     end
 
     def initialize( inner )
       @target = inner
-      self.class.app_instance = Praxis::Application.new(name: self.class.app_name, skip_registration: self.class.skip_registration)      
+      @setup_done = false
     end
-    
+
     def call(env)
-      # NOTE: Need to make sure somebody has properly called the setup above before this is called
-      #@app_instance ||= Praxis::Application.new.setup(**self.class.args) #I Think that's not right at all...
-      result = self.class.app_instance.call(env)
+      self.class.setup unless self.class.setup_done
+      
+      result = Praxis::Application.instance.call(env)
 
       unless ( [404,405].include?(result[0].to_i) && result[1]['X-Cascade'] == 'pass' )
         # Respect X-Cascade header if it doesn't specify 'pass'

data/lib/praxis/multipart/part.rb

@@ -10,7 +10,6 @@ module Praxis
     attr_accessor :headers_attribute
     attr_accessor :filename_attribute
     attr_accessor :default_handler
-    attr_accessor :application
 
     def self.check_option!(name, definition)
       case name
@@ -78,8 +77,7 @@ module Praxis
       @name = name
       @body = body
       @headers = headers
-      @application = Praxis::Application.current_instance
-      @default_handler = application.handlers['json']
+      @default_handler = Praxis::Application.instance.handlers['json']
 
       if content_type.nil?
         self.content_type = 'text/plain'
@@ -214,7 +212,7 @@ module Praxis
     end
 
     def handler
-      handlers = application.handlers
+      handlers = Praxis::Application.instance.handlers
       (content_type && handlers[content_type.handler_name]) || @default_handler
     end
 
@@ -251,7 +249,7 @@ module Praxis
 
       # and return that one if it already corresponds to a registered handler
       # otherwise, add the encoding
-      if application.handlers.include?(pick.handler_name)
+      if Praxis::Application.instance.handlers.include?(pick.handler_name)
         return pick
       else
         return pick + handler_name

data/lib/praxis/notifications.rb

@@ -21,7 +21,7 @@ module Praxis
     end
 
     def self.instrument(name, payload = {}, &block)
-      ActiveSupport::Notifications.instrument(name, payload, &block)
+      ActiveSupport::Notifications.instrument(name, **payload, &block)
     end
 
     def self.subscribe(*args, &block)

data/lib/praxis/plugins/mapper_plugin.rb

@@ -0,0 +1,64 @@
+require 'singleton'
+require 'praxis/extensions/attribute_filtering/filtering_params'
+
+module Praxis
+  module Plugins
+    module MapperPlugin
+      include Praxis::PluginConcern
+
+      class Plugin < Praxis::Plugin
+        include Singleton
+
+        def config_key
+          :mapper
+        end
+
+        def load_config!
+          {} # override the default one, since we don't necessarily want to configure it via a yaml file.
+        end
+
+        def prepare_config!(node)
+          node.attributes do
+            attribute :debug_queries, Attributor::Boolean, default: false,
+              description: 'Weather or not to log debug information about queries executed in the build_query automation module'
+          end
+        end
+      end
+
+      module Controller
+        extend ActiveSupport::Concern
+
+        included do
+          include Praxis::Extensions::FieldExpansion
+        end
+
+        def set_selectors
+          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)
+        end
+
+        def build_query(base_query) # 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)
+          base_query = domain_model.craft_filter_query( base_query , filters: filters )
+
+          base_query = domain_model.craft_field_selection_query(base_query, selectors: selector_generator.selectors)
+
+          # TODO: handle pagination and ordering
+          base_query
+        end
+
+        def selector_generator
+          @selector_generator ||= Praxis::Mapper::SelectorGenerator.new
+        end
+
+      end
+
+    end
+  end
+end

data/lib/praxis/request.rb

@@ -1,7 +1,7 @@
 module Praxis
 
   class Request < Praxis.request_superclass
-    attr_reader :env, :query, :praxis_instance
+    attr_reader :env, :query
     attr_accessor :route_params, :action
 
     PATH_VERSION_PREFIX = "/v".freeze
@@ -14,11 +14,10 @@ module Praxis
     API_NO_VERSION_NAME = 'n/a'.freeze
     VERSION_USING_DEFAULTS = [:header, :params].freeze
 
-    def initialize(env, args={})
+    def initialize(env)
       @env = env
       @query = Rack::Utils.parse_nested_query(env[QUERY_STRING_NAME])
       @route_params = {}
-      @praxis_instance = args[:application]
     end
 
     # Determine the content type of this request as indicated by the Content-Type header.
@@ -87,8 +86,8 @@ module Praxis
     PATH_VERSION_MATCHER = %r{^#{self.path_version_prefix}(?<version>[^\/]+)\/}.freeze
 
     def path_version_matcher
-      if praxis_instance.versioning_scheme == :path
-        matcher = Mustermann.new(praxis_instance.api_definition.info.base_path + '*')
+      if Application.instance.versioning_scheme == :path
+        matcher = Mustermann.new(ApiDefinition.instance.info.base_path + '*')
         matcher.params(self.path)[API_VERSION_PARAM_NAME]
       else
         PATH_VERSION_MATCHER.match(self.path)[:version]
@@ -97,7 +96,8 @@ module Praxis
 
     def version
       result = nil
-      Array(praxis_instance.versioning_scheme).find do |mode|
+
+      Array(Application.instance.versioning_scheme).find do |mode|
         case mode
         when :header;
           result = env[API_VERSION_HEADER_NAME]
@@ -128,7 +128,8 @@ module Praxis
     def load_payload(context)
       return unless action.payload
       return if content_type.nil?
-      raw = if (handler = praxis_instance.handlers[content_type.handler_name])
+
+      raw = if (handler = Praxis::Application.instance.handlers[content_type.handler_name])
         handler.parse(self.raw_payload)
       else
         # TODO is this a good default?
@@ -161,6 +162,12 @@ module Praxis
       @unmatched_versions ||= Set.new
     end
 
+    # Override the inspect instance method of a request, as, by default, the kernel inspect will go nuts
+    # traversing the action and app_instance and therefore all associated instance variables reachable through that
+    def inspect
+      "'@env' => #{@env.inspect},\n'@headers' => #{@headers.inspect},\n'@params' => #{@params.inspect},\n'@query' => #{@query.inspect}"
+    end
+
   end
 
 end

data/lib/praxis/request_stages/response.rb

@@ -8,9 +8,8 @@ module Praxis
 
         response.handle
 
-        config = Application.current_instance.config
-        if config.praxis.validate_responses == true
-          validate_body = config.praxis.validate_response_bodies
+        if Application.instance.config.praxis.validate_responses == true
+          validate_body = Application.instance.config.praxis.validate_response_bodies
 
           response.validate(action, validate_body: validate_body)
         end

data/lib/praxis/resource_definition.rb

@@ -8,15 +8,11 @@ module Praxis
     DEFAULT_RESOURCE_HREF_ACTION = :show
 
     included do
-      # Store the attached (i.e., current) Praxis App instance into the resource definition for easy retrieval later
-      @application = Application.instance
-      @application.resource_definitions << self
-
       @version = 'n/a'.freeze
       @actions = Hash.new
       @responses = Hash.new
 
-      @action_defaults = Trait.new &ResourceDefinition.generate_defaults_block(application: @application)
+      @action_defaults = Trait.new &ResourceDefinition.generate_defaults_block
 
       @version_options = {}
       @metadata = {}
@@ -37,12 +33,13 @@ module Praxis
 
       @on_finalize = Array.new
 
- 
+      Application.instance.resource_definitions << self
     end
 
-    def self.generate_defaults_block( version: nil, application:)
+    def self.generate_defaults_block( version: nil )
+
       # Ensure we inherit any base params defined in the API definition for the passed in version
-      base_attributes = if (base_params = application.api_definition.info(version).base_params)
+      base_attributes = if (base_params = ApiDefinition.instance.info(version).base_params)
         base_params.attributes
       else
         {}
@@ -52,15 +49,15 @@ module Praxis
         unless base_attributes.empty?
           params do
             base_attributes.each do |base_name, base_attribute|
-              attribute base_name, base_attribute.type, base_attribute.options
+              attribute base_name, base_attribute.type, **base_attribute.options
             end
           end
         end
       end
     end
 
-    def self.finalize!(application: )
-      application.resource_definitions.each do |resource_definition|
+    def self.finalize!
+      Application.instance.resource_definitions.each do |resource_definition|
         while (block = resource_definition.on_finalize.shift)
           block.call
         end
@@ -76,7 +73,6 @@ module Praxis
       attr_reader :traits
       attr_reader :version_prefix
       attr_reader :parent_prefix
-      attr_reader :application
 
       # opaque hash of user-defined medata, used to decorate the definition,
       # and also available in the generated JSON documents
@@ -91,9 +87,9 @@ module Praxis
         @display_name = string
       end
 
-      def on_finalize
+      def on_finalize(&block)
         if block_given?
-          @on_finalize << Proc.new
+          @on_finalize << proc(&block)
         end
 
         @on_finalize
@@ -172,7 +168,7 @@ module Praxis
 
               parent_attribute = parent_action.params.attributes[parent_name]
 
-              attribute name, parent_attribute.type, parent_attribute.options
+              attribute name, parent_attribute.type, **parent_attribute.options
             end
           end
         end
@@ -203,7 +199,7 @@ module Praxis
           end
         end
 
-        @action_defaults.instance_eval &ResourceDefinition.generate_defaults_block( version: version, application: self.application)
+        @action_defaults.instance_eval &ResourceDefinition.generate_defaults_block( version: version )
       end
 
 
@@ -225,7 +221,7 @@ module Praxis
       end
 
       def to_href( params )
-        canonical_path.primary_route.path.expand(params)
+        canonical_path.primary_route.path.expand(params.transform_values(&:to_s))
       end
 
       def parse_href(path)
@@ -242,10 +238,10 @@ module Praxis
       end
 
       def trait(trait_name)
-        unless self.application.api_definition.traits.has_key? trait_name
+        unless ApiDefinition.instance.traits.has_key? trait_name
           raise Exceptions::InvalidTrait.new("Trait #{trait_name} not found in the system")
         end
-        trait = self.application.api_definition.traits.fetch(trait_name)
+        trait = ApiDefinition.instance.traits.fetch(trait_name)
         @traits << trait_name
       end
       alias_method :use, :trait

data/lib/praxis/response.rb

@@ -63,23 +63,24 @@ module Praxis
       self.class.response_name
     end
 
-    def format!(config:)
+    def format!
     end
 
-    def encode!(handlers:)
+    def encode!
       case @body
       when Hash, Array
         # response payload is structured data; transform it into an entity using the handler
         # implied by the response's media type. If no handler is registered for this
         # name, assume JSON as a default handler.
+        handlers = Praxis::Application.instance.handlers
         handler = (content_type && handlers[content_type.handler_name]) || handlers['json']
         @body = handler.generate(@body)
       end
     end
 
-    def finish(application:)
-      format!(config: application.config)
-      encode!(handlers: application.handlers)
+    def finish
+      format!
+      encode!
 
       @body = Array(@body)