praxis 0.0.1 → 0.9

data/lib/praxis/application.rb

@@ -0,0 +1,65 @@
+require 'singleton'
+require 'mustermann'
+require 'logger'
+
+module Praxis
+  class Application
+    include Singleton
+
+    attr_reader :router
+    attr_reader :controllers
+    attr_reader :resource_definitions
+
+    attr_accessor :bootloader
+    attr_accessor :file_layout
+    attr_accessor :loaded_files
+    attr_accessor :logger
+    attr_accessor :plugins
+    attr_accessor :root
+
+    def self.configure
+      yield(self.instance)
+    end
+
+    def initialize
+      @controllers = Set.new
+      @resource_definitions = Set.new
+
+      @router = Router.new(self)
+
+      @bootloader = Bootloader.new(self)
+      @file_layout = nil
+      @plugins = Array.new
+      @loaded_files = Set.new
+      @config = Config.new
+      @root = nil
+      @logger = Logger.new(STDOUT)
+    end
+    
+    def setup(root: '.')
+      @root = Pathname.new(root).expand_path
+
+      @bootloader.setup!
+    end
+
+    def call(env)
+      self.router.call(env)
+    end
+
+    def layout(&block)
+      self.file_layout = FileGroup.new(self.root, &block)
+    end
+
+    def config(key=nil, type=Attributor::Struct, **opts, &block)
+      if block_given? || (type==Attributor::Struct && !opts.empty? )
+        @config.define(key, type, opts, &block)
+      else
+        @config.get
+      end
+    end
+
+    def config=(config)
+      @config.set(config)
+    end
+  end
+end

data/lib/praxis/bootloader.rb

@@ -0,0 +1,91 @@
+module Praxis
+
+
+  class Bootloader
+
+    attr_reader :application, :stages
+
+    def initialize(application)
+      @application = application
+      @stages = Array.new
+
+      setup_stages!
+    end
+
+    def config
+      @application.config
+    end
+
+    def root
+      @application.root
+    end
+
+    def setup_stages!
+      # Require environment first. they define constants and environment specific settings
+      stages << BootloaderStages::Environment.new(:environment, application)
+
+      # then the initializers. as it is their job to ensure monkey patches and other
+      # config is in place first.
+      stages << BootloaderStages::FileLoader.new(:initializers, application)
+
+      # then require lib/ code.
+      stages << BootloaderStages::FileLoader.new(:lib, application)
+
+      # design-specific code.
+      stages << BootloaderStages::SubgroupLoader.new(:design, application)
+
+      # app-specific code.
+      stages << BootloaderStages::SubgroupLoader.new(:app, application)
+
+      # setup routing
+      stages << BootloaderStages::Routing.new(:routing, application)
+
+      # naggy warning about unloaded files
+      stages << BootloaderStages::WarnUnloadedFiles.new(:warn_unloaded_files, application)
+
+      after(:app) do
+        Praxis::Mapper.finalize!
+        Praxis::Blueprint.finalize!
+      end
+
+    end
+
+    def delete_stage(stage_name)
+      if (stage = stages.find { |stage| stage.name == stage_name })
+        stages.delete(stage)
+      else
+        raise Exceptions::StageNotFound.new(
+          "Cannot remove stage with name #{stage_name}, stage does not exist."
+        )
+      end
+    end
+
+
+    def before(*stage_path, &block)
+      stage_name = stage_path.shift
+      stages.find { |stage| stage.name == stage_name }.before(*stage_path, &block)
+    end
+
+    def after(*stage_path, &block)
+      stage_name = stage_path.shift
+      stages.find { |stage| stage.name == stage_name }.after(*stage_path, &block)
+    end
+
+    def use(plugin,&block)
+      application.plugins << plugin.new(application, &block)
+    end
+
+    def setup!
+      run
+    end
+
+    def run
+      stages.each do |stage|
+        stage.run
+      end
+    end
+
+  end
+
+
+end

data/lib/praxis/bootloader_stages/environment.rb

@@ -0,0 +1,57 @@
+module Praxis
+
+
+  module BootloaderStages
+
+    class Environment < Stage
+
+      # require environment files. we will require 2 files:
+      # 1) the environment.rb file    - generic stuff for all environments
+      # 2) "Deployer.environment".rb  - environment specific stuff
+      def execute
+        env_file = application.root + "config/environment.rb"
+        require env_file if File.exists? env_file
+
+        application.plugins.each do |plugin|
+          plugin.setup!
+        end
+
+        unless application.file_layout
+          setup_default_layout!
+        end
+
+        setup_initial_config!
+      end
+
+      def setup_default_layout!
+        application.layout do
+          layout do
+            map :initializers, 'config/initializers/**/*'
+            map :lib, 'lib/**/*'
+            map :design, 'design/' do
+              map :api, 'api.rb'
+              map :media_types, '**/media_types/**/*'
+              map :resources, '**/resources/**/*'
+            end
+            map :app, 'app/' do
+              map :models, 'models/**/*'
+              map :controllers, '**/controllers/**/*'
+              map :responses, '**/responses/**/*'
+            end
+          end
+        end
+      end
+
+      # TODO: not really sure I like this here... but where else is better?
+      def setup_initial_config!
+        application.config do
+          attribute :praxis do
+            attribute :validate_responses, Attributor::Boolean, default: false
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/praxis/bootloader_stages/file_loader.rb

@@ -0,0 +1,31 @@
+module Praxis
+
+
+  module BootloaderStages
+
+    class FileLoader < Stage
+
+      attr_reader :path
+
+      def initialize(name, application, path: nil)
+        super
+        @path = path || Array(name)
+      end
+
+      def execute
+        application.file_layout[*path].each do |file|
+          next if application.loaded_files.include?(file)
+          next unless file.extname == '.rb'
+          require file
+          application.loaded_files << file
+        end
+      end
+
+      def callback_args
+        application.file_layout[*path]
+      end
+
+    end
+  end
+
+end

data/lib/praxis/bootloader_stages/routing.rb

@@ -0,0 +1,34 @@
+module Praxis
+
+
+  module BootloaderStages
+
+    class Routing < Stage
+
+      def execute
+        application.controllers.each do |controller|
+          controller.actions.each do |action_name, action|
+            action.routes.each do |route|
+              target = target_factory(controller, action_name)
+              application.router.add_route target, route
+            end
+          end
+        end
+      end
+
+
+      def target_factory(controller, action_name)
+        action = controller.action(action_name)
+
+        Proc.new do |request|
+          request.action = action
+          dispatcher = Dispatcher.current(thread: Thread.current, application: application)
+
+          dispatcher.dispatch(controller, action, request)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/praxis/bootloader_stages/subgroup_loader.rb

@@ -0,0 +1,27 @@
+module Praxis
+
+  module BootloaderStages
+
+    class SubgroupLoader < Stage
+
+      attr_writer :order
+
+      def initialize(name, application)
+        super
+        # always finalize Taylor after loading app code.
+      
+      end
+
+      def order
+        @order ||= application.file_layout[name].groups.keys
+      end
+
+      def setup!
+        order.each do |group|
+          @stages << FileLoader.new(group, application, path: [name, group])
+        end
+      end
+    end
+
+  end
+end

data/lib/praxis/bootloader_stages/warn_unloaded_files.rb

@@ -0,0 +1,40 @@
+module Praxis
+
+
+  module BootloaderStages
+
+    class WarnUnloadedFiles < Stage
+      @enabled = true
+
+      def self.enabled=(enabled)
+        @enabled = enabled
+      end
+
+      def self.enabled
+        @enabled
+      end
+
+      def execute
+        return unless self.class.enabled
+        base = application.file_layout[:app].base
+        file_enum = base.find.to_a
+        files = file_enum.select do |file|
+          path = file.relative_path_from(base)
+          path.extname == '.rb'
+        end
+
+        missing = Set.new(files) - application.loaded_files
+        if missing.any?
+          msg = "The following files application files under #{base} were not loaded:\n"
+          missing.each do |file|
+            path = file.relative_path_from(base)
+            msg << " * #{path}\n"
+          end
+          puts msg
+        end
+      end
+
+
+    end
+  end
+end

data/lib/praxis/config.rb

@@ -0,0 +1,92 @@
+module Praxis
+  class Config
+    include Attributor::Type
+
+    attr_reader :attribute
+
+    def initialize
+      @attribute = Attributor::Attribute.new(Attributor::Struct) {}
+      @value = nil
+    end
+
+    # You can define the configuration in different ways
+    # 
+    # Add a key to the top struct
+    # define do
+    #   attribute :added_to_top, String
+    # end
+    #
+    # Add a key to the top struct (that is a struct itself)
+    # define do
+    #   attribute :app do
+    #     attribute :one String
+    #   end
+    # end
+    # Which you could expand too in this way
+    # define do
+    #   attribute :app do
+    #     attribute :two String
+    #   end
+    # end
+    # ...or using this way too (equivalent)
+    # define(:app) do
+    #   attribute :two, String
+    # end
+    # You can also define a key to be a non-Struct type
+    # define :app, Attributor::Hash
+        
+    def define(key=nil, type=Attributor::Struct, **opts, &block)
+      if key.nil? && type != Attributor::Struct
+        raise Exceptions::InvalidConfiguration.new(
+          "You cannot define the top level configuration with a non-Struct type. Got: #{type.inspect}"
+        )
+      end
+      
+      case key
+      when String, Symbol, NilClass
+
+        top = key.nil? ? @attribute : @attribute.attributes[key]
+        if top #key defined...redefine
+          unless  type == Attributor::Struct && top.type < Attributor::Struct
+            raise Exceptions::InvalidConfiguration.new(
+              "Incompatible type received for extending configuration key [#{key}]. Got type #{type.name}"
+            )
+          end
+          top.options.merge!(opts)
+          top.type.attributes(opts, &block)
+        else
+          @attribute.attributes[key] = Attributor::Attribute.new(type, opts, &block)
+        end
+      else
+        raise Exceptions::InvalidConfiguration.new(
+          "Defining a configuration key requires a String or a Symbol key. Got: #{key.inspect}"
+        )
+      end
+            
+    end
+
+    def set(config)
+      context = ['Application', 'config']
+
+      begin
+        @value = @attribute.load(config, context)
+      rescue Attributor::AttributorException => e
+        raise Exceptions::ConfigLoad.new(exception: e)
+      end
+
+      errors = @attribute.validate(@value, context)
+
+      unless errors.empty?
+        raise Exceptions::ConfigValidation.new(errors: errors)
+      end
+    end
+
+    def get
+      @value ||= begin
+        context = ['Application','config'].freeze
+        @attribute.load({},context)
+      end
+    end
+
+  end
+end

data/lib/praxis/content_type_parser.rb

@@ -0,0 +1,62 @@
+module Praxis
+  module ContentTypeParser
+    REGEXP = /^
+      \s*
+      (?<type>[^+;\s]+)
+      (\+(?<sub_type>[^;\s]+))?
+      (\s*;\s*)?
+      (?<params>.*?)?
+      (\s*;\s*)?
+    $/x
+
+    # Parses Content type
+    #
+    # @param  [String]         Content type to parse
+    # @return [Hash]           A hash with keys: :type, :sub_type(optional) and :params(optional)
+    # @raise  [ArgumentError]  It fails when blank or weird content type is provided
+    #
+    # @example
+    #   parse(nil)      #=> Exception: Content type does not have any type defined (ArgumentError)
+    #   parse('+json')  #=> Exception: Content type does not have any type defined (ArgumentError)
+    #   parse(';p1=11') #=> Exception: Content type does not have any type defined (ArgumentError)
+    #
+    # @example
+    #   parse('text/xml') #=>
+    #     {:type     => "text/xml",
+    #      :sub_type => nil,
+    #      :params   => {}}
+    #
+    # @example
+    #   parse('application/vnd.something+json') #=>
+    #     {:type     => "application/vnd.something",
+    #      :sub_type => "json",
+    #      :params   => {}}
+    #
+    # @example
+    #   parse('application/vnd.something+json;p1=1.0;param_with_noval;p2=a13') #=>
+    #     {:type     => "application/vnd.something",
+    #      :sub_type => "json",
+    #      :params   => {"p1"=>"1.0", "param_with_noval"=>nil, "p2"=>"a13"}}
+    #
+    def self.parse(content_type)
+      parsed = REGEXP.match(content_type.to_s)
+      raise(ArgumentError, 'Content type does not have any type defined') unless parsed
+
+      result = {
+        type: parsed[:type]
+      }
+      result[:sub_type] = parsed[:sub_type] if parsed[:sub_type]
+      if parsed[:params]
+        params = {}
+        parsed[:params].split(';').each do |param|
+          key, value = param.split('=')
+          key        = key.to_s.strip
+          next if key.empty?
+          params[key.strip] = value && value.strip
+        end
+        result[:params] = params unless params.empty?
+      end
+      result
+    end
+  end
+end

data/lib/praxis/controller.rb

@@ -0,0 +1,59 @@
+require 'active_support/concern'
+require 'active_support/inflector'
+
+module Praxis
+
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :request
+      attr_accessor :response
+      Application.instance.controllers << self
+      self.instance_eval do
+        @before_callbacks = Hash.new
+        @after_callbacks = Hash.new
+      end
+
+    end
+
+    module ClassMethods
+      attr_reader :before_callbacks, :after_callbacks
+
+      def implements(definition)
+        define_singleton_method(:definition) do
+          definition
+        end
+        definition.controller = self
+      end
+
+      def actions
+        definition.actions
+      end
+
+      def action(name)
+        actions.fetch(name)
+      end
+
+      def before(*stage_path, **conditions, &block)
+        stage_path = [:action] if stage_path.empty?
+        @before_callbacks[stage_path] ||= Array.new
+        @before_callbacks[stage_path] << [conditions, block]
+      end
+
+      def after(*stage_path, **conditions, &block)
+        stage_path = [:action] if stage_path.empty?
+        @after_callbacks[stage_path] ||= Array.new
+        @after_callbacks[stage_path] << [conditions, block]
+      end
+
+    end
+
+
+    def initialize(request, response=Responses::Ok.new)
+      @request = request
+      @response = response
+    end
+
+  end
+end

data/lib/praxis/dispatcher.rb

@@ -0,0 +1,102 @@
+module Praxis
+
+  CONTEXT_FOR = {
+    params: [Attributor::AttributeResolver::ROOT_PREFIX, "params".freeze],
+    headers: [Attributor::AttributeResolver::ROOT_PREFIX, "headers".freeze],
+    payload: [Attributor::AttributeResolver::ROOT_PREFIX, "payload".freeze]
+  }.freeze
+
+  class Dispatcher
+    attr_reader :controller, :action, :request, :application
+
+    @deferred_callbacks = Hash.new do |hash,stage|
+      hash[stage] = {before: [], after:[]}
+    end
+
+    class << self
+      attr_reader :deferred_callbacks
+    end
+
+    def self.before(*stage_path, **conditions, &block)
+      @deferred_callbacks[:before] << [conditions, block]
+    end
+
+    def self.after(*stage_path, **conditions, &block)
+      @deferred_callbacks[:after] << [conditions, block]
+    end
+
+    def self.current(thread: Thread.current, application: Application.instance)
+      thread[:praxis_dispatcher] ||= self.new(application: application)
+    end
+
+    def initialize(application: Application.instance)
+      @stages = []
+      @application = application
+      setup_stages!
+    end
+
+    def setup_stages!
+      @stages << RequestStages::LoadRequest.new(:load_request, self)
+      @stages << RequestStages::Validate.new(:validate, self)
+      @stages << RequestStages::Action.new(:action, self)
+      @stages << RequestStages::Response.new(:response, self)
+      setup_deferred_callbacks!
+    end
+
+    def setup_deferred_callbacks!
+      self.class.deferred_callbacks.each do |stage_name, callbacks|
+        callbacks[:before].each do |(*stage_path, block)|
+          self.before(stage_name, *stage_path, &block)
+        end
+
+        callbacks[:after].each do |(*stage_path, block)|
+          self.after(stage_name, *stage_path, &block)
+        end
+      end
+    end
+
+    def before(*stage_path, &block)
+      stage_name = stage_path.shift
+      stages.find { |stage| stage.name == stage_name }.before(*stage_path, &block)
+    end
+
+    def after(*stage_path, &block)
+      stage_name = stage_path.shift
+      stages.find { |stage| stage.name == stage_name }.after(*stage_path, &block)
+    end
+
+    def dispatch(controller_class, action, request)
+      @controller = controller_class.new(request)
+      @action = action
+      @request = request
+
+      @stages.each do |stage|
+        result = stage.run
+        case result
+        when Response
+          return result.finish
+        end
+      end
+
+      controller.response.finish
+    rescue => e
+      response = Responses::InternalServerError.new(error: e)
+      response.request = controller.request
+      response.finish
+    ensure
+      @controller = nil
+      @action = nil
+      @request = nil
+    end
+   
+    
+    def reset_cache!
+      return unless Praxis::Blueprint.caching_enabled?
+
+      Praxis::Blueprint.cache = Hash.new do |hash, key|
+        hash[key] = Hash.new
+      end
+    end
+
+  end
+end

data/lib/praxis/exception.rb

@@ -0,0 +1,4 @@
+module Praxis
+  class Exception < StandardError
+  end
+end

data/lib/praxis/exceptions/config.rb

@@ -0,0 +1,6 @@
+module Praxis
+  module Exceptions
+    class Config < Exception
+    end
+  end
+end

data/lib/praxis/exceptions/config_load.rb

@@ -0,0 +1,9 @@
+module Praxis
+  module Exceptions
+    class ConfigLoad < Config
+      def initialize(exception:)
+        super(exception.message)
+      end
+    end
+  end
+end

data/lib/praxis/exceptions/config_validation.rb

@@ -0,0 +1,9 @@
+module Praxis
+  module Exceptions
+    class ConfigValidation < Config
+      def initialize(errors:)
+        super('Validation error: ' << errors.join('; '))
+      end
+    end
+  end
+end