pakyow-core 0.10.2 → 0.11.0

data/pakyow-core/lib/pakyow/core/helpers/hooks.rb

@@ -0,0 +1,106 @@
+module Pakyow
+  module Helpers
+    # Methods to register and call hooks before and after particular triggers.
+    #
+    # @api public
+    module Hooks
+      TYPES = %i(before after)
+      TRIGGERS = %i(init load process route match error configure reload)
+
+      module InstanceMethods
+        protected
+
+        def hook_around(trigger)
+          call_hooks :before, trigger
+          yield
+          call_hooks :after, trigger
+        end
+
+        def call_hooks(type, trigger)
+          self.class.hook(type, trigger).each do |block|
+            instance_exec(&block)
+          end
+        end
+      end
+
+      def self.extended(object)
+        object.send(:include, InstanceMethods)
+      end
+
+      # Registers a before hook for a particular trigger.
+      #
+      # @api public
+      def before(trigger, &block)
+        register_hook(:before, trigger, block)
+      end
+
+      # Registers an after hook for a particular trigger.
+      #
+      # @api public
+      def after(trigger, &block)
+        register_hook(:after, trigger, block)
+      end
+
+      # Fetches a hook by type (before | after) and trigger.
+      #
+      # @api private
+      def hook(type, trigger)
+        check_hook_type(type)
+        check_trigger(trigger)
+
+        hooks[type.to_sym][trigger.to_sym]
+      end
+
+      protected
+
+      def hooks
+        return @hooks unless @hooks.nil?
+
+        @hooks = {
+          before: {},
+          after: {}
+        }
+
+        TRIGGERS.each do |name|
+          @hooks[:before][name.to_sym] = []
+          @hooks[:after][name.to_sym] = []
+        end
+
+        @hooks
+      end
+
+      def register_hook(type, trigger, block)
+        raise ArgumentError, 'Expected a block' if block.nil?
+
+        trigger = trigger.to_sym
+
+        check_trigger(trigger)
+        check_hook_type(type)
+
+        hooks[type][trigger] << block
+      end
+
+      def hook_around(trigger)
+        call_hooks :before, trigger
+        yield
+        call_hooks :after, trigger
+      end
+
+      def call_hooks(type, trigger)
+        hook(type, trigger).each do |block|
+          instance_exec(&block)
+        end
+      end
+
+      def check_trigger(trigger)
+        return true if TRIGGERS.include?(trigger)
+        raise ArgumentError, "Hook trigger #{trigger} doesn't exist"
+      end
+
+      def check_hook_type(type)
+        return true if TYPES.include?(type)
+        raise ArgumentError, "Hook type #{type} doesn't exist"
+      end
+    end
+  end
+end

data/pakyow-core/lib/pakyow/core/helpers/running.rb

@@ -0,0 +1,124 @@
+require 'rack/builder'
+require 'rack/handler'
+
+module Pakyow
+  module Helpers
+    # Methods run running an app.
+    #
+    # @api public
+    module Running
+      STOP_METHODS = ['stop!', 'stop']
+      HANDLERS = ['puma', 'thin', 'mongrel', 'webrick']
+      SIGNALS = [:INT, :TERM]
+
+      # Prepares the app for being staged in one or more environments by
+      # loading config(s), middleware, and setting the load path.
+      #
+      # @api public
+      def prepare(*env_or_envs)
+        return true if prepared?
+
+        # load config for one or more environments
+        load_env_config(*env_or_envs)
+
+        # load each block from middleware stack
+        load_middleware
+
+        # add app/lib to load path
+        $LOAD_PATH.unshift config.app.src_dir
+
+        @prepared = true
+      end
+
+      # Stages the app by preparing and returning an instance. This is
+      # essentially everything short of running it.
+      #
+      # @api public
+      def stage(*env_or_envs)
+        prepare(*env_or_envs)
+        self.new
+      end
+
+      # Runs the staged app.
+      #
+      # @api public
+      def run(*env_or_envs)
+        return true if running?
+        @running = true
+        builder.run(stage(*env_or_envs))
+        detect_handler.run(builder, Host: config.server.host, Port: config.server.port) do |server|
+          SIGNALS.each do |signal|
+            trap(signal) { stop(server) }
+          end
+        end
+      end
+
+      # Returns true if the application is prepared.
+      #
+      # @api public
+      def prepared?
+        @prepared == true
+      end
+
+      # Returns true if the application is running.
+      #
+      # @api public
+      def running?
+        @running == true
+      end
+
+      # Returns true if the application is staged.
+      #
+      # @api public
+      def staged?
+        !Pakyow.app.nil?
+      end
+
+      # Returns a rack builder instance.
+      #
+      # @api public
+      def builder
+        @builder ||= Rack::Builder.new
+      end
+
+      # Returns an instance of the rack handler.
+      #
+      # @api private
+      def detect_handler
+        if config.server.handler
+          HANDLERS.unshift(config.server.handler).uniq!
+        end
+
+        HANDLERS.each do |handler_name|
+          begin
+            handler = Rack::Handler.get(handler_name)
+            return handler unless handler.nil?
+          rescue LoadError
+          rescue NameError
+          end
+        end
+
+        raise 'No handler found'
+      end
+
+      protected
+
+      def stop(server)
+        STOP_METHODS.each do |method|
+          if server.respond_to?(method)
+            return server.send(method)
+          end
+        end
+
+        # exit ungracefully
+        Process.exit!
+      end
+
+      def load_middleware
+        middleware.each do |block|
+          instance_exec(builder, &block)
+        end
+      end
+    end
+  end
+end

data/pakyow-core/lib/{core → pakyow/core}/helpers.rb

@@ -1,12 +1,14 @@
 module Pakyow
-  # For methods that should be accessible anywhere
+  # Helpers available anywhere
+  #
+  # @api public
   module Helpers
     def context
       @context or raise NoContextError
     end
 
     def logger
-      request.logger
+      request.logger || Pakyow.logger
     end
 
     def router
@@ -38,8 +40,22 @@ module Pakyow
     def config
       Pakyow::Config
     end
-  end
 
-  # For methods that should only be accessible through App
-  module AppHelpers; end
+    # Returns the primary app environment.
+    #
+    # @api public
+    def env
+      config.env
+    end
+
+    # Helpers for Pakyow::App
+    #
+    # @api public
+    module App; end
+
+    # Helpers for Pakyow::CallContext
+    #
+    # @api public
+    module Context; end
+  end
 end

data/pakyow-core/lib/{core → pakyow/core}/loader.rb

@@ -17,7 +17,7 @@ module Pakyow
           next if FileTest.directory?(path)
           next if path.split('.')[-1] != 'rb'
 
-          if Config.app.auto_reload
+          if Config.reloader.enabled
             if !@times[path] || (@times[path] && File.mtime(path) - @times[path] > 0)
               load(path)
               @times[path] = File.mtime(path)

data/pakyow-core/lib/{core → pakyow/core}/middleware/logger.rb

@@ -41,7 +41,7 @@ module Pakyow
 
     def <<(msg = nil, severity = :unknown)
       return if @log.nil?
-      msg << "\n"
+      (msg || "") << "\n"
 
       msg = format(msg, severity) if @format
       @mutex.synchronize do
@@ -83,7 +83,7 @@ module Pakyow
 
     def format(msg, level)
       return msg unless color = level_color(level)
-      return COLOR_SEQ % (30 + COLOR_TABLE.index(color)) + msg + RESET_SEQ
+      return COLOR_SEQ % (30 + COLOR_TABLE.index(color)) + (msg || "") + RESET_SEQ
     end
 
     def level_color(level)
@@ -99,6 +99,12 @@ end
 
 module Pakyow
   module Middleware
+    Pakyow::App.middleware do |builder|
+      if Pakyow::Config.logger.enabled
+        builder.use Pakyow::Middleware::Logger
+      end
+    end
+
     class Logger
       # handles logging after an error occurs
       Pakyow::App.after(:error) {

data/pakyow-core/lib/pakyow/core/middleware/override.rb

@@ -0,0 +1,3 @@
+Pakyow::App.middleware do |builder|
+  builder.use Rack::MethodOverride
+end

data/pakyow-core/lib/pakyow/core/middleware/reloader.rb

@@ -0,0 +1,23 @@
+module Pakyow
+  module Middleware
+    Pakyow::App.middleware do |builder|
+      if Pakyow::Config.reloader.enabled
+        builder.use Pakyow::Middleware::Reloader
+      end
+    end
+
+    # Rack compatible middleware that tells app to reload on each request.
+    #
+    # @api public
+    class Reloader
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        Pakyow.app.reload
+        @app.call(env)
+      end
+    end
+  end
+end

data/pakyow-core/lib/pakyow/core/middleware/req_path_normalizer.rb

@@ -0,0 +1,49 @@
+require 'pakyow/core/call_context'
+
+module Pakyow
+  module Middleware
+    Pakyow::App.middleware do |builder|
+      builder.use Pakyow::Middleware::ReqPathNormalizer
+    end
+
+    # Rack compatible middleware that normalize the path if contains '//'
+    # or has a trailing '/', it replace '//' with '/', remove trailing `/`
+    # and issue a 301 redirect to the normalized path.
+    #
+    # @api public
+    class ReqPathNormalizer
+      TAIL_SLASH_REPLACE_REGEX = /(\/)+$/
+      TAIL_SLASH_REGEX = /(.)+(\/)+$/
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        path = env['PATH_INFO']
+
+        if double_slash?(path) || tail_slash?(path)
+          catch :halt do
+            CallContext.new(env).redirect(normalize_path(path), 301)
+          end
+        else
+          @app.call(env)
+        end
+      end
+
+      def normalize_path(path)
+        normalized = path
+          .gsub('//', '/')
+          .gsub(TAIL_SLASH_REPLACE_REGEX, '')
+      end
+
+      def double_slash?(path)
+        path.include?('//')
+      end
+
+      def tail_slash?(path)
+        (TAIL_SLASH_REGEX =~ path).nil? ? false : true
+      end
+    end
+  end
+end

data/pakyow-core/lib/pakyow/core/middleware/session.rb

@@ -0,0 +1,5 @@
+Pakyow::App.middleware do |builder|
+  if Pakyow::Config.session.enabled
+    builder.use Pakyow::Config.session.object, Pakyow::Config.session.options
+  end
+end

data/pakyow-core/lib/pakyow/core/middleware/static.rb

@@ -0,0 +1,76 @@
+require 'pakyow/core/config'
+require 'pakyow/core/call_context'
+
+module Pakyow
+  module Middleware
+    # Rack compatible middleware that serves static files from one or more configured resource stores.
+    #
+    # @example
+    #   Pakyow::Config.app.resources = {
+    #     default: './public'
+    #   }
+    #
+    #   Pakyow::App.builder.use Pakyow::Middleware::Static
+    #
+    #   # Assuming './public/foo.png' exists, a GET request to '/foo.png' will
+    #   # result in this middleware responding with the static file.
+    #
+    # @api public
+    class Static
+      Pakyow::App.middleware do |builder|
+        if Pakyow::Config.app.static
+          builder.use Pakyow::Middleware::Static
+        end
+      end
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        static, resource_path = self.class.static?(env)
+        return @app.call(env) unless static
+
+        catch :halt do
+          CallContext.new(env).send(File.open(resource_path))
+        end
+      end
+
+      class << self
+        STATIC_REGEX = /\.(.*)$/
+        STATIC_HTTP_METHODS = %w(GET)
+
+        # Checks if `path` can be found in any configured resource store.
+        #
+        # @api public
+        def static?(env)
+          path, method = env.values_at('PATH_INFO', 'REQUEST_METHOD')
+
+          return false unless STATIC_HTTP_METHODS.include?(method)
+          return false unless static_path?(path)
+
+          resources_contain?(path)
+        end
+
+        protected
+
+        def static_path?(path)
+           path =~ STATIC_REGEX
+        end
+
+        def resources_contain?(path)
+          resources.each_pair do |_, resource_path|
+            full_path = File.join(resource_path, path)
+            return true, full_path if File.exists?(full_path)
+          end
+
+          false
+        end
+
+        def resources
+          Config.app.resources
+        end
+      end
+    end
+  end
+end

data/pakyow-core/lib/{core → pakyow/core}/request.rb

@@ -1,4 +1,5 @@
 require 'json'
+require 'rack'
 
 module Pakyow
 
@@ -58,9 +59,12 @@ module Pakyow
 
     # Returns indifferent params (see {HashUtils.strhash} for more info on indifferent hashes).
     def params
-      @params ||= Hash.strhash(super.merge!(env['pakyow.data'] || {}).merge!(JSON.parse(body.read.to_s)))
-    rescue JSON::JSONError
-      @params = Hash.strhash(super)
+      return @params unless @params.nil?
+
+      @params = super
+      @params.merge!(env['pakyow.data']) if env['pakyow.data'].is_a?(Hash)
+      @params.merge!(JSON.parse(body.read.to_s)) if format == :json
+      @params = Hash.strhash(@params)
     end
 
     # Returns array of url components.

data/pakyow-core/lib/{core → pakyow/core}/response.rb

@@ -4,6 +4,8 @@ module Pakyow
   class Response < Rack::Response
     attr_reader :format
 
+    DEFAULT_CONTENT_TYPE = 'text/html;charset=utf-8'.freeze
+
     STATUS_CODE_NAMES = {
       100 => 'Continue',
       101 => 'Switching Protocols',
@@ -117,13 +119,13 @@ module Pakyow
     def initialize(*args)
       super
 
-      self["Content-Type"] ||= 'text/html'
+      self["Content-Type"] ||= DEFAULT_CONTENT_TYPE
       @format = Rack::Mime::MIME_TYPES.key(type)
     end
 
     def format=(format)
       @format = format
-      self["Content-Type"] = Rack::Mime.mime_type(".#{format}")
+      self["Content-Type"] = format == :html ? DEFAULT_CONTENT_TYPE : Rack::Mime.mime_type(".#{format}")
     end
 
     def type

data/pakyow-core/lib/{core → pakyow/core}/route_expansion_eval.rb

@@ -31,7 +31,7 @@ module Pakyow
   		all_fns = route[3]
   		all_fns[:fns].unshift(fn) if fn
 
-  		hooks = merge_hooks(hooks, all_fns[:hooks])
+  		hooks = merge_hooks(all_fns[:hooks], hooks)
   		route[3] = build_fns(all_fns[:fns], hooks)
 
   		register_route(route)

data/pakyow-core/lib/{core → pakyow/core}/route_set.rb

@@ -28,7 +28,7 @@ module Pakyow
       method = method.to_sym
       method = :get if method == :head
 
-      @routes[method].each{|r|
+      (@routes[method] || []).each do |r|
         #TODO can we do this without conditionals? fall-through?
         case r[0]
         when Regexp
@@ -40,7 +40,7 @@ module Pakyow
             return r, nil
           end
         end
-      }
+      end
 
       nil
     end

data/pakyow-core/lib/{core → pakyow/core}/router.rb

@@ -37,6 +37,10 @@ module Pakyow
       raise MissingRoute, "Could not find route '#{name}'"
     end
 
+    def exists?(context)
+      !match(context.request).empty?
+    end
+
     # Performs the initial routing for a request.
     #
     def perform(context, app = Pakyow.app, &after_match)

data/pakyow-core/lib/pakyow/core.rb

@@ -0,0 +1,8 @@
+require 'find'
+require 'rack'
+require 'rack/file'
+require 'logger'
+require 'cgi'
+
+require 'pakyow/support'
+require 'pakyow/core/base'

data/pakyow-core/lib/pakyow-core.rb

@@ -1,11 +1 @@
-libdir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
-
-# Gems
-require 'find'
-require 'rack'
-require 'rack/file'
-require 'logger'
-require 'cgi'
-
-require 'core/base'
+require 'pakyow/core'