praxis 0.21 → 2.0.pre.3

data/lib/praxis/mapper/selector_generator.rb

@@ -0,0 +1,149 @@
+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)
+      if resource.properties.key?(name)
+        add_property(name, fields)
+      elsif 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...
+      add_association(name, fields) if resource.model._praxis_associations.key?(name)
+      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 
+            add_select(name) unless resource.model._praxis_associations.key?(name)
+          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(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

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

@@ -5,15 +5,33 @@ module Praxis
 
     # Initialize the application instance with the desired args, and return the wrapping class.
     def self.for( **args )
-      Praxis::Application.instance.setup(**args)
-      self
+      Class.new(self) do
+        @args = args
+        @setup_done = false
+        def self.name
+          'MiddlewareApp'
+        end
+        def self.args
+          @args
+        end
+        def self.setup_done
+          @setup_done
+        end
+        def self.setup
+          @setup_done = true
+          Praxis::Application.instance.setup(**@args)
+        end
+      end
      end
 
     def initialize( inner )
       @target = inner
+      @setup_done = false
     end
 
     def 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' )

data/lib/praxis/multipart/parser.rb

@@ -22,6 +22,7 @@ module Praxis
     TERMINAL_CRLF = /\r\n$/.freeze
 
 
+    PARAMS_BUF_SIZE = 65536 # Same as implicitly in rack 1.x
     BUFSIZE = 16384
 
     def self.parse(headers,body)
@@ -87,9 +88,9 @@ module Praxis
 
       @buf = ""
 
-      @params = Rack::Utils::KeySpaceConstrainedParams.new
+      @params = new_params
 
-      @boundary_size = Rack::Utils.bytesize(@boundary) + EOL.size
+      @boundary_size = @boundary.bytesize + EOL.size
 
       if @content_length = @headers['Content-Length']
         @content_length = @content_length.to_i
@@ -98,6 +99,17 @@ module Praxis
       true
     end
 
+    if Rack.const_defined?(:RELEASE) && Rack::RELEASE[0] == '2'
+      # Rack 2 requires the buffer size
+      def new_params
+        Rack::Utils::KeySpaceConstrainedParams.new(PARAMS_BUF_SIZE)
+      end
+    else
+      def new_params
+        Rack::Utils::KeySpaceConstrainedParams.new
+      end
+    end
+
     def full_boundary
       @boundary + EOL
     end

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/plugins/rails_plugin.rb

@@ -0,0 +1,104 @@
+require 'praxis/plugin'
+require 'praxis/plugin_concern'
+
+module Praxis
+  module Plugins
+    module RailsPlugin
+      include Praxis::PluginConcern
+
+      class Plugin < Praxis::Plugin
+
+        def setup!
+          require 'praxis/dispatcher'
+          enable_action_controller_instrumentation
+        end
+
+        private
+        def enable_action_controller_instrumentation
+          Praxis::Dispatcher.class_eval do
+            # Wrap the original action dispatch with a method that instruments rails-expected bits...
+            alias_method :orig_instrumented_dispatch, :instrumented_dispatch
+
+            def instrumented_dispatch( praxis_payload )
+              rails_payload = {
+                :controller => controller.class.name,
+                :action     => action.name,
+                :params     => ( (request.params) ? request.params.dump : {} ),
+                :method     => request.verb,
+                :path       => (request.fullpath rescue "unknown")
+              }
+              Praxis::Notifications.instrument("start_processing.action_controller", rails_payload.dup)
+
+              Praxis::Notifications.instrument 'process_action.action_controller' do |data|
+                begin
+                  res = orig_instrumented_dispatch(praxis_payload)
+                  # TODO: also add the db_runtime and view_runtime values...
+                  data[:status] = res[0]
+                  res
+                ensure
+                  # Append DB runtime to payload
+                  #data[:db_runtime] = 999
+                  # Append rendering time to payload
+                  #data[:view_runtime] = 123
+                end
+              end
+            end
+          end
+        end
+      end
+
+      module Request
+      end
+
+      module Controller
+        extend ActiveSupport::Concern
+
+        # Throw in some basic and expected controller methods
+
+        # Expose a rails-version of params from the controller
+        # Avoid using them explicitly in your controllers though. Use request.params object instead, as they are
+        # the Praxis ones that have been validated and coerced into the types you've defined.
+        def params
+          self.request.parameters
+        end
+
+        # Allow accessing the response headers from the controller
+        def headers
+          self.response.headers
+        end
+
+        def session
+          self.request.session
+        end
+
+        # Allow setting the status and body of the response from the controller itself.
+        def status=(code)
+          self.response.status = code
+        end
+
+        def response_body=(body)
+          #TODO: @_rendered = true # Necessary to know if to stop filter chain or not...
+          self.response.body = body
+        end
+
+        def head(status, options = {})
+          options, status = status, nil if status.is_a?(Hash)
+          status ||= options.delete(:status) || :ok
+          location = options.delete(:location)
+          content_type = options.delete(:content_type)
+
+          code = Rack::Utils::SYMBOL_TO_STATUS_CODE[status]
+          response = Praxis::Response.new(status: code, body: status.to_s, location: location)
+
+          options.each do |key, value|
+            response.headers[key.to_s.dasherize.split('-').each { |v| v[0] = v[0].chr.upcase }.join('-')] = value.to_s
+          end
+          response.content_type = content_type if content_type
+          response
+        end
+
+      end
+
+    end
+  end
+end