praxis 0.21 → 0.22.pre.1

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+require_relative 'active_record_filter_query_builder'
+
+module Praxis
+  module Extensions
+    module QueryBuilder
+    # To include in a resource object...
+      extend ActiveSupport::Concern
+
+      included do
+        # TODO: this shouldn't be needed if we incorporate it with the properties of the mapper...
+        def self.filters_mapping(hash)
+          @query_builder_class = ActiveRecordFilterQueryBuilder.for(**hash)
+        end
+        
+        def self.query_builder_class
+          @query_builder_class
+        end
+
+        def self.craft_query(base_query, filters) # rubocop:disable Metrics/AbcSize
+          # Assume QueryBuilder
+          if query_builder_class
+            unless query_builder_class.ancestors.include?(ActiveRecordFilterQueryBuilder)
+              raise ArgumentError, ':query_builder_class must a class extending FilterQueryBuilder'
+            end
+
+            if filters && query_builder_class
+              base_query = query_builder_class.new(query: base_query, model: model ).build_clause(filters)
+            end
+            # puts "FILTERS_QUERY: #{filters_query.sql}"
+          end
+          
+          base_query
+        end
+      end
+
+    end
+  end
+end

data/lib/praxis/extensions/field_selection.rb

@@ -1,6 +1,9 @@
 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

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+module Praxis
+  module Extensions
+    module FieldSelection
+      class ActiveRecordQuerySelector
+        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:)
+          @selector = selectors
+          @ds = ds
+          @top_model = model
+          @resolved = resolved
+          @seen = Set.new
+          @root = model.table_name
+        end
+
+        def add_select(ds:, 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)
+          else
+            ds
+          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)
+
+          @ds.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
+        end
+
+        def only_assoc_for(model, hash)
+          hash.keys.reject { |assoc| model.associations[assoc].nil? }
+        end
+
+        def fields_for(model)
+          selector[model][:select].to_a
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+module Praxis
+  module Extensions
+    module FieldSelection
+      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:)
+          @selector = selectors
+          @ds = ds
+          @top_model = model
+          @resolved = resolved
+          @seen = Set.new
+          @root = model.table_name
+        end
+
+        def add_select(ds:, 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 | [:id]
+            qualified = fields.map { |f| Sequel.qualify(table_name, f) }
+            ds.select(*qualified)
+          else
+            ds
+          end
+        end
+
+        def generate
+          @ds = add_select(ds: ds, model: top_model, table_name: root)
+
+          tracks = only_assoc_for(top_model, resolved)
+          @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]
+            #      hash[track] = _eager(assoc_model, resolved[track])
+            dataset.eager(track => _eager(assoc_model, resolved[track]))
+          end
+        end
+
+        def _eager(model, resolved)
+          lambda do |dset|
+            d = add_select(ds: dset, model: model, table_name: model.table_name)
+
+            tracks = only_assoc_for(model, resolved)
+            tracks.inject(d) do |dataset, track|
+              next dataset if @seen.include?([model, track])
+              @seen << [model, track]
+              assoc_model = model.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? }
+        end
+
+        def fields_for(model)
+          selector[model][:select].to_a
+        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/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.instance.validation_handler.handle!(
+          Praxis::Application.current_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." \
-          "Are you missing a call Praxis::Application.instance.setup?"
+          "Have you forgot to call 'setup' on the Praxis application instance?"
       end
 
 

data/lib/praxis/middleware_app.rb

@@ -2,19 +2,39 @@ module Praxis
   class MiddlewareApp
 
     attr_reader :target
-
     # Initialize the application instance with the desired args, and return the wrapping class.
     def self.for( **args )
-      Praxis::Application.instance.setup(**args)
-      self
-     end
+      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
+        
+        def self.name
+          'MiddlewareApp'
+        end
+        def self.args
+          @args
+        end
+        def self.setup
+          app_instance.setup(**args)
+        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)      
     end
-
+    
     def call(env)
-      result = Praxis::Application.instance.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)
 
       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/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/multipart/part.rb

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

data/lib/praxis/plugins/praxis_mapper_plugin.rb

@@ -33,7 +33,7 @@ require 'terminal-table'
 #             }
 #           }
 #   2. log_stats: A String indicating what kind of DB stats you would like
-#      output into the Praxis::Application.instance.logger app log. Possible
+#      output into the Praxis::Application.current_instance.logger app log. Possible
 #      values are: "detailed", "short", and "skip" (i.e. do not print the stats
 #      at all).
 #   3. stats_log_level: the logging level with which the statistics should be logged.
@@ -238,7 +238,7 @@ module Praxis
         end
 
         def self.to_logger(message)
-            Praxis::Application.instance.logger.__send__(Plugin.instance.config.stats_log_level, "Praxis::Mapper Statistics: #{message}")
+            Praxis::Application.current_instance.logger.__send__(Plugin.instance.config.stats_log_level, "Praxis::Mapper Statistics: #{message}")
         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