praxis 0.10.1 → 0.11pre

data/lib/praxis/bootloader_stages/plugin_config_load.rb

@@ -0,0 +1,20 @@
+module Praxis
+  module BootloaderStages
+    class PluginConfigLoad < Stage
+
+      def execute
+        application.plugins.each do |config_key, plugin|
+          value = plugin.load_config!
+          object = plugin.config_attribute.load(value)
+
+          if object
+            application.config.send("#{config_key}=", object)
+          end
+
+          plugin.config = application.config.send("#{config_key}")
+        end
+      end
+
+    end
+  end
+end

data/lib/praxis/bootloader_stages/plugin_config_prepare.rb

@@ -0,0 +1,18 @@
+module Praxis
+  module BootloaderStages
+    class PluginConfigPrepare < Stage
+
+      def execute
+        application.plugins.each do |config_key, plugin|
+          attribute = Attributor::Attribute.new(Attributor::Struct) {}
+
+          plugin.config_attribute = attribute
+          plugin.prepare_config!(attribute.type)
+
+          application.config.class.attributes[config_key] = plugin.config_attribute
+        end
+      end
+
+    end
+  end
+end

data/lib/praxis/bootloader_stages/plugin_loader.rb

@@ -0,0 +1,19 @@
+module Praxis
+
+
+  module BootloaderStages
+
+    class PluginLoader < Stage
+
+      def initialize(name, context,**opts)
+        super
+
+        stages << PluginConfigPrepare.new(:prepare, context, parent: self)
+        stages << PluginConfigLoad.new(:load, context, parent: self)
+        stages << PluginSetup.new(:setup, context, parent: self)
+      end
+
+    end
+
+  end
+end

data/lib/praxis/bootloader_stages/plugin_setup.rb

@@ -0,0 +1,13 @@
+module Praxis
+  module BootloaderStages
+    class PluginSetup < Stage
+
+      def execute
+        application.plugins.each do |config_key, plugin|
+          plugin.setup!
+        end
+      end
+
+    end
+  end
+end

data/lib/praxis/bootloader_stages/routing.rb

@@ -4,7 +4,22 @@ module Praxis
   module BootloaderStages
 
     class Routing < Stage
+      class Target
+        attr_reader :action
+        def initialize(application, controller, action)
+          @application = application
+          @controller = controller
+          @action = action
+        end
+        
+        def call(request)
+          request.action = @action
+          dispatcher = Dispatcher.current( application: @application)
 
+          dispatcher.dispatch(@controller, @action, request)
+        end
+      end
+      
       def execute
         application.controllers.each do |controller|
           controller.definition.actions.each do |action_name, action|
@@ -20,12 +35,7 @@ module Praxis
       def target_factory(controller, action_name)
         action = controller.definition.actions.fetch(action_name)
 
-        Proc.new do |request|
-          request.action = action
-          dispatcher = Dispatcher.current( application: application)
-
-          dispatcher.dispatch(controller, action, request)
-        end
+        Target.new(application, controller, action)
       end
 
     end

data/lib/praxis/callbacks.rb

@@ -1,5 +1,3 @@
-require 'active_support/concern'
-
 module Praxis
   module Callbacks
     extend ::ActiveSupport::Concern

data/lib/praxis/config.rb

@@ -28,6 +28,7 @@ module Praxis
     #     attribute :two String
     #   end
     # end
+    
     # ...or using this way too (equivalent)
     # define(:app) do
     #   attribute :two, String
@@ -69,7 +70,7 @@ module Praxis
       context = ['Application', 'config']
 
       begin
-        @value = @attribute.load(config, context)
+        @value = @attribute.load(config, context, recurse: true)
       rescue Attributor::AttributorException => e
         raise Exceptions::ConfigLoad.new(exception: e)
       end
@@ -84,7 +85,7 @@ module Praxis
     def get
       @value ||= begin
         context = ['Application','config'].freeze
-        @attribute.load({},context)
+        @attribute.load({},context, recurse: true)
       end
     end
 

data/lib/praxis/dispatcher.rb

@@ -7,7 +7,10 @@ module Praxis
   }.freeze
 
   class Dispatcher
-    attr_reader :controller, :action, :request, :application
+    attr_reader :controller
+    attr_reader :action
+    attr_reader :request
+    attr_reader :application
 
     @deferred_callbacks = Hash.new do |hash,stage|
       hash[stage] = {before: [], after:[]}
@@ -70,26 +73,35 @@ module Praxis
       @action = action
       @request = request
 
-      @stages.each do |stage|
-        result = stage.run
-        case result
-        when Response
-          return result.finish
+      payload = {request: request, response: nil}
+
+      Notifications.instrument 'praxis.request.all'.freeze, payload do
+        # the response stage must be the final stage in the list
+        *stages, response_stage = @stages
+        
+        stages.each do |stage|
+          result = stage.run
+          case result
+          when Response
+            controller.response = result
+            break
+          end
         end
-      end
 
-      controller.response.finish
+        response_stage.run
+
+        payload[:response] = controller.response
+        controller.response.finish
+      end
     rescue => e
-      response = Responses::InternalServerError.new(error: e)
-      response.request = controller.request
-      response.finish
+      @application.error_handler.handle!(request, e)
     ensure
       @controller = nil
       @action = nil
       @request = nil
     end
-   
-    
+
+
     def reset_cache!
       return unless Praxis::Blueprint.caching_enabled?
 

data/lib/praxis/error_handler.rb

@@ -0,0 +1,16 @@
+module Praxis
+  class ErrorHandler
+
+    def handle!(request, error)
+      Application.instance.logger.error error.inspect
+      error.backtrace.each do |line|
+        Application.instance.logger.error line
+      end
+
+      response = Responses::InternalServerError.new(error: error)
+      response.request = request
+      response.finish
+    end
+
+  end
+end

data/lib/praxis/links.rb

@@ -63,7 +63,7 @@ module Praxis
       end
 
       define_method(name) do
-        value = @object.send(using)
+        value = @object.__send__(using)
         return value if value.nil? || value.kind_of?(attribute.type)
         attribute.type.new(value)
       end
@@ -72,13 +72,13 @@ module Praxis
       unless name == using
         @attribute.type.instance_eval do
           define_method(using) do
-            self.send(name)
+            self.__send__(name)
           end
         end
 
         @reference.attribute.type.instance_eval do
           define_method(using) do
-            self.send(name)
+            self.__send__(name)
           end
         end
       end
@@ -103,12 +103,17 @@ module Praxis
         @reference.attribute.type.instance_eval do
           define_method(using) do
             return nil unless attributes[:links]
-            attributes[:links].send(name)
+            attributes[:links].__send__(name)
           end
         end
       end
     end
 
+    def self.validate(*args)
+      # FIXME: what to validate for links?
+      []
+    end
+
   end
 
 end

data/lib/praxis/media_type_collection.rb

@@ -83,7 +83,7 @@ module Praxis
       when Hash
         # Need to parse/deserialize first
         self.new(self.attribute.load(value,context, **options))
-      when Array
+      when Array, Praxis::Mapper::ResourceDecorator
         object = self.attribute.load({})
         object._members = value.collect { |subvalue| @member_attribute.load(subvalue) }
         self.new(object)
@@ -116,8 +116,7 @@ module Praxis
 
     def validate(context=Attributor::DEFAULT_ROOT_CONTEXT)
       errors = super
-
-      @object.each_with_object(errors) do |member, errors|
+      self.each_with_object(errors) do |member, errors|
         errors.push(*member.validate(context))
       end
     end

data/lib/praxis/notifications.rb

@@ -0,0 +1,41 @@
+require 'active_support/notifications'
+
+require 'singleton'
+
+module Praxis
+
+  module Notifications
+    include Praxis::PluginConcern
+
+    class Plugin < Praxis::Plugin
+      include Singleton
+
+      def config_key
+        :notifications # 'praxis.notifications'
+      end
+
+    end
+
+    def self.publish(name, *args)
+      ActiveSupport::Notifications.publish(name, *args)
+    end
+
+    def self.instrument(name, payload = {}, &block)
+      ActiveSupport::Notifications.instrument(name, payload, &block)
+    end
+
+    def self.subscribe(*args, &block)
+      ActiveSupport::Notifications.subscribe(*args, &block)
+    end
+
+    def self.subscribed(callback, *args, &block)
+      ActiveSupport::Notifications.subscribed(callback, *args, &block)
+    end
+
+    def self.unsubscribe(subscriber_or_name)
+      ActiveSupport::Notifications.unsubscribe(subscriber_or_name)
+    end
+
+
+  end
+end

data/lib/praxis/plugin.rb

@@ -3,15 +3,26 @@ module Praxis
   # one instance is created per use.
   class Plugin
 
-    attr_reader :application, :block
+    attr_accessor :application
+    attr_accessor :block
+    attr_accessor :config
+    attr_accessor :config_attribute
 
-    def initialize(application, &block)
-      @application = application
-      @block = block
+    def options
+      @options ||= {}
     end
 
-    def config
-      @application.config
+    def config_key
+    end
+
+    def prepare_config!(node)
+    end
+
+    def load_config!
+      return unless options.has_key?(:config_file)
+      return {} unless (application.root + options[:config_file]).exist?
+
+      YAML.load_file(application.root + options[:config_file])
     end
 
     def setup!
@@ -25,6 +36,5 @@ module Praxis
       application.bootloader.before(stage,&block)
     end
 
-
   end
-end
+end

data/lib/praxis/plugin_concern.rb

@@ -0,0 +1,40 @@
+module Praxis
+
+  module PluginConcern
+    extend ::ActiveSupport::Concern
+
+    included do
+      @setup = false
+    end
+
+    module ClassMethods
+      PLUGIN_CLASSES = [
+        :Request,
+        :Controller,
+        :ResourceDefinition,
+        :ActionDefinition
+      ]
+
+      def setup!
+        return if @setup
+
+        PLUGIN_CLASSES.each do |name|
+          if self.constants.include?(name)
+            inject!(name)
+          end
+        end
+
+        @setup = true
+      end
+
+      def inject!(name)
+        plugin = self.const_get(name)
+        praxis = Praxis.const_get(name)
+
+        praxis.include(plugin)
+      end
+
+    end
+  end
+
+end

data/lib/praxis/request.rb

@@ -1,15 +1,14 @@
 module Praxis
 
   class Request
-    attr_reader :env, :query, :version
+    attr_reader :env, :query
     attr_accessor :route_params, :action
 
-
     def initialize(env)
       @env = env
       @query = Rack::Utils.parse_nested_query(env['QUERY_STRING'.freeze])
       @route_params = {}
-      load_version
+      @path_version_matcher = path_version_matcher
     end
 
     def content_type
@@ -65,10 +64,31 @@ module Praxis
       self.raw_params
       self.raw_payload
     end
-
-    def load_version
-      @version = env.fetch("HTTP_X_API_VERSION".freeze,
-                           @query.fetch('api_version'.freeze, 'n/a'.freeze))
+    
+    def self.path_version_prefix
+      "/v".freeze
+    end
+    
+    def path_version_matcher
+      %r{^#{Request.path_version_prefix}(?<version>[^\/]+)\/}.freeze
+    end
+    
+    def version(using: [:header,:params].freeze)
+      result = nil
+      Array(using).find do |mode|
+        case mode
+        when :header ;
+          result = env["HTTP_X_API_VERSION".freeze]
+        when :params ;
+          result = @query['api_version'.freeze]
+        when :path ;
+          m = self.path.match(@path_version_matcher) 
+          result = m[:version] unless m.nil?
+        else
+          raise "Unknown method for retrieving the API version: #{mode}"
+        end
+      end
+      return result || 'n/a'.freeze
     end
 
     def load_headers(context)