pakyow-core 0.10.2 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 50ae18ead2f40115c95fd5d0cd06c1d33168aef5
-  data.tar.gz: ba3af0e47bd3f344b0a3d6f0c694dda4ac7d2cfb
+  metadata.gz: 7d5b282f6dbfaf9f1aa89fb990e07d0eaf725bd5
+  data.tar.gz: 7b8acceb89ef30e66f1af2905f817b68ec4485ce
 SHA512:
-  metadata.gz: 99379ff43be348f4ebae46c630c8592f718b4b4659f3fd0bbc486f23182b968b3de9af1e17b81d899ccfb0e006c48e4efe01c82291a786e4443c9d2a626b8210
-  data.tar.gz: 72be27310400fb3da72d759efd71fc3ff5f926b01475df112e8d6b2af19ddf767d9940658fe9c277dce24ed935f7e9a410838ecbaf586cdcf4f92400b36e2564
+  metadata.gz: bfe95bcda07690cfa0aec13df8a9be8806564c5e6464a4786418147fda398aad722ab644a4c585b6dc68c41ff9ff8ee40b141065b5fe1b69fd58933c8ed80d9f
+  data.tar.gz: 16ec3ccb608ffddde3f6681d7a2461eb47a7a119078ea931e886e12889088869d0612a4a4d368dbcf27aa7c307b73c561497396fe1e62f297c807a69f61e7ed7

data/pakyow-core/CHANGELOG.md

@@ -1,3 +1,26 @@
+# 0.11.0
+
+  * Adds a `configure` hook for evaluating code before/after configuring app
+  * The `Pakyow::App.define` method now returns the defined app
+  * Explicitly requires `pakyow-support` so core works on its own
+  * Adds a convenience method for defining a restful resource
+  * Adds a `reload` hook for evaluating code before/after reloading app
+  * Better support for sending any IO object or String data
+  * Defaults to `global` when defining app configuration
+  * Adds a new `reloader` config namespace
+  * Redirects requests with `//` to single-slash path
+  * Adds the ability to easily disable middleware
+  * Bundles and configures middleware for session handling
+  * Automatically removes the trailing `/` in request path
+  * Now loads the global config options before env-specific options
+  * Adds the source directory to the load path
+  * Sets default Content-Type to utf-8
+  * Moves everything into the Pakyow namespace
+  * Changes to allow error hooks to halt execution
+  * Adds a convenience method for checking the existence of a route
+  * Protects against internal failures when calling a route with an unknown method
+  * Fixes route hook execution order, prioritizing hooks defined in outer scopes
+
 # 0.10.2 / 2015-11-15
 
   * Fixes issues presenting error views from gem

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

@@ -0,0 +1,81 @@
+require_relative 'helpers/configuring'
+require_relative 'helpers/running'
+require_relative 'helpers/hooks'
+
+require_relative 'call_context'
+require_relative 'helpers'
+require_relative 'config'
+require_relative 'loader'
+require_relative 'router'
+
+module Pakyow
+  # The main app object.
+  #
+  # @api public
+  class App
+    extend Helpers::Hooks
+    extend Helpers::Configuring
+    extend Helpers::Running
+
+    class << self
+      # Convenience method for accessing app configuration object.
+      #
+      # @api public
+      def config
+        Pakyow::Config
+      end
+
+      # Resets app state.
+      #
+      # @api private
+      def reset
+        instance_variables.each do |ivar|
+          remove_instance_variable(ivar)
+        end
+      end
+    end
+
+    include Helpers::App
+
+    def initialize
+      Pakyow.app = self
+
+      @loader = Loader.new
+
+      hook_around :init do
+        load_app
+      end
+    end
+
+    # @api private
+    def call(env)
+      CallContext.new(env).process.finish
+    end
+
+    # Reloads the app.
+    #
+    # @api private
+    def reload
+      hook_around :reload do
+        load_app
+      end
+    end
+
+    protected
+
+    def load_app
+      hook_around :load do
+        @loader.load_from_path(Pakyow::Config.app.src_dir)
+        load_routes unless Pakyow::Config.app.ignore_routes
+      end
+    end
+
+    def load_routes
+      Router.instance.reset
+
+      self.class.routes.each_pair do |set_name, block|
+        Router.instance.set(set_name, &block)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require 'pakyow/core/helpers'
+require 'pakyow/core/multilog'
+require 'pakyow/core/app_context'
+require 'pakyow/core/request'
+require 'pakyow/core/response'
+require 'pakyow/core/loader'
+require 'pakyow/core/router'
+require 'pakyow/core/route_merger'
+require 'pakyow/core/route_module'
+require 'pakyow/core/route_set'
+require 'pakyow/core/route_eval'
+require 'pakyow/core/route_expansion_eval'
+require 'pakyow/core/route_template_eval'
+require 'pakyow/core/route_template_defaults'
+require 'pakyow/core/route_lookup'
+require 'pakyow/core/app'
+require 'pakyow/core/errors'
+
+require 'pakyow/core/config'
+require 'pakyow/core/config/reloader'
+require 'pakyow/core/config/app'
+require 'pakyow/core/config/server'
+require 'pakyow/core/config/cookies'
+require 'pakyow/core/config/logger'
+require 'pakyow/core/config/session'
+
+require 'pakyow/core/middleware/override'
+require 'pakyow/core/middleware/reloader'
+require 'pakyow/core/middleware/req_path_normalizer'
+require 'pakyow/core/middleware/session'
+require 'pakyow/core/middleware/static'
+require 'pakyow/core/middleware/logger'
+
+module Pakyow
+  class << self
+    attr_accessor :app, :logger
+  end
+
+  def self.configure_logger
+    logs = []
+
+    if File.directory?(Config.logger.path)
+      log_path = File.join(Config.logger.path, Config.logger.filename)
+
+      begin
+        log = File.open(log_path, 'a')
+        log.sync if Config.logger.sync
+
+        logs << log
+      rescue StandardError => e
+        warn "Error opening '#{log_path}' for writing"
+      end
+    end
+
+    logs << $stdout if Config.logger.stdout
+
+    io = logs.count > 1 ? MultiLog.new(*logs) : logs[0]
+
+    Pakyow.logger = Logger.new(io, Config.logger.level, Config.logger.colorize, Config.logger.auto_flush)
+  end
+end

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

@@ -0,0 +1,171 @@
+require 'pakyow/core/helpers'
+require 'pakyow/core/helpers/hooks'
+require 'pakyow/core/router'
+require 'pakyow/core/request'
+require 'pakyow/core/response'
+require 'pakyow/core/app_context'
+
+module Pakyow
+  class CallContext
+    include Helpers
+    include Helpers::Context
+    include Helpers::Hooks::InstanceMethods
+
+    attr_writer :context
+
+    def initialize(env)
+      @router = Pakyow::Router.instance
+
+      req = Request.new(env)
+      res = Response.new
+
+      # set response format based on request
+      res.format = req.format
+
+      @context = AppContext.new(req, res)
+    end
+
+    def process
+      hook_around :process do
+        set_initial_cookies
+
+        @found = false
+        catch :halt do
+          hook_around :route do
+            @found = @router.perform(context, self) {
+              call_hooks :after, :match
+            }
+          end
+
+          handle(404, false) unless found?
+        end
+
+        set_cookies
+      end
+
+      self
+    rescue StandardError => error
+      request.error = error
+
+      catch :halt do
+        hook_around :error do
+          handle(500, false) unless found?
+        end
+      end
+
+      self
+    end
+
+    # Interrupts the application and returns response immediately.
+    #
+    def halt
+      throw :halt, response
+    end
+
+    # Routes the request to different logic.
+    #
+    def reroute(location, method = nil)
+      location = @router.path(location)
+      request.setup(location, method)
+
+      call_hooks :before, :route
+      call_hooks :after, :match
+      @router.reroute(request)
+      call_hooks :after, :route
+    end
+
+    # Sends data in the response (immediately). Accepts a string of data or a File,
+    # mime-type (auto-detected; defaults to octet-stream), and optional file name.
+    #
+    # If a File, mime type will be guessed. Otherwise mime type and file name will
+    # default to whatever is set in the response.
+    #
+    def send(file_or_data, type = nil, send_as = nil)
+      if file_or_data.is_a?(IO)
+        data = file_or_data
+
+        if file_or_data.is_a?(File)
+          # auto set type based on file type
+          type ||= Rack::Mime.mime_type("." + String.split_at_last_dot(file_or_data.path)[1])
+        end
+      elsif file_or_data.is_a?(String)
+        data = StringIO.new(file_or_data)
+      else
+        raise ArgumentError, 'Expected an IO or String object'
+      end
+
+      headers = {}
+      headers["Content-Type"]         = type if type
+      headers["Content-disposition"]  = "attachment; filename=#{send_as}" if send_as
+
+      res.body = data
+      res.header.merge!(headers)
+
+      halt
+    end
+
+    # Redirects to location (immediately).
+    #
+    def redirect(location, status_code = 302)
+      location = @router.path(location)
+
+      headers = response ? response.header : {}
+      headers = headers.merge({'Location' => location})
+
+      self.context.response = Response.new('', status_code, headers)
+      halt
+    end
+
+    def handle(name_or_code, from_logic = true)
+      hook_around :route do
+        @router.handle(name_or_code, self, from_logic)
+      end
+    end
+
+    def finish
+      res.finish
+    end
+
+    protected
+
+    def found?
+      @found
+    end
+
+    def call_hooks(type, trigger)
+      Pakyow::App.hook(type, trigger).each do |block|
+        instance_exec(&block)
+      end
+    end
+
+    def set_cookies
+      request.cookies.each_pair {|k, v|
+        response.delete_cookie(k) if v.nil?
+
+        # cookie is already set with value, ignore
+        next if @initial_cookies.include?(k.to_s) && @initial_cookies[k.to_s] == v
+
+        # set cookie with defaults
+        response.set_cookie(k, {
+          :path => config.cookies.path,
+          :expires => config.cookies.expiration,
+          :value => v
+        })
+      }
+
+      # delete cookies that are no longer present
+      @initial_cookies.each {|k|
+        response.delete_cookie(k) unless request.cookies.key?(k.to_s)
+      }
+    end
+
+    # Stores set cookies at beginning of request cycle
+    # for comparison at the end of the cycle
+    def set_initial_cookies
+      @initial_cookies = {}
+      request.cookies.each {|k,v|
+        @initial_cookies[k] = v
+      }
+    end
+  end
+end

data/pakyow-core/lib/{core → pakyow/core}/config/app.rb

@@ -1,7 +1,6 @@
-Pakyow::Config.register(:app) { |config|
+Pakyow::Config.register :app do |config|
 
-  # if true, the app will be reloaded on every request
-  config.opt :auto_reload
+  config.opt :name, 'pakyow'
 
   # if true, errors are displayed in the browser
   config.opt :errors_in_browser
@@ -10,14 +9,14 @@ Pakyow::Config.register(:app) { |config|
   config.opt :root, File.dirname('')
 
   # the location of the app's resources
-  config.opt :resources, lambda {
+  config.opt :resources, -> {
     @resources ||= {
       default: File.join(root, 'public')
     }
   }
 
   # the location of the app's source code
-  config.opt :src_dir, lambda { File.join(root, 'app', 'lib') }
+  config.opt :src_dir, -> { File.join(root, 'app', 'lib') }
 
   # the environment to run in, if one isn't provided
   config.opt :default_environment, :development
@@ -31,39 +30,20 @@ Pakyow::Config.register(:app) { |config|
   # if true, views are visible without a route defined
   config.opt :all_views_visible, true
 
-  # whether or not pakyow should log to stdout
-  config.opt :log_output, true
-
-  # whether or not pakyow should write to a log
-  config.opt :log, true
-
   # whether or not pakyow should serve static files
   config.opt :static, true
 
   # stores the path to the app definition
-  config.opt :path, lambda { Pakyow::App.path }
+  config.opt :path, -> { Pakyow::App.path }
 
   # stores the envs an app is run in
   config.opt :loaded_envs
-
-}.env(:development) { |opts|
-
-  opts.auto_reload = true
+end.env :development do |opts|
   opts.errors_in_browser = true
   opts.static = true
-
-}.env(:staging) { |opts|
-
-  opts.auto_reload = false
-  opts.errors_in_browser = true
-  opts.log_output = false
-  opts.static = true
-
-}.env(:production) { |opts|
-
-  opts.auto_reload = false
+end.env :production do |opts|
   opts.errors_in_browser = false
-  opts.log_output = false
   opts.static = true
-
-}
+end.env :prototype do |opts|
+  opts.ignore_routes = false
+end

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

@@ -0,0 +1,4 @@
+Pakyow::Config.register :cookies do |config|
+  config.opt :path, '/'
+  config.opt :expiration, -> { Time.now + 60 * 60 * 24 * 7 }
+end

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

@@ -1,10 +1,15 @@
-Pakyow::Config.register(:logger) { |config|
+Pakyow::Config.register :logger do |config|
+  # whether or not pakyow should write to a log
+  config.opt :enabled, true
 
   # the default level to log at
   config.opt :level, :debug
 
+  # whether or not pakyow should log to stdout
+  config.opt :stdout, true
+
   # where the log file should be placed
-  config.opt :path, lambda { File.join(Pakyow::Config.app.root, 'log') }
+  config.opt :path, -> { File.join(Pakyow::Config.app.root, 'log') }
 
   # the name of the log file
   config.opt :filename, 'pakyow.log'
@@ -17,23 +22,13 @@ Pakyow::Config.register(:logger) { |config|
 
   # whether or not the log file should be colorized
   config.opt :colorize
-
-}.env(:development) { |opts|
-
+end.env :development do |opts|
   opts.sync = true
   opts.auto_flush = true
   opts.colorize = true
-
-}.env(:staging) { |opts|
-
+end.env :production do |opts|
   opts.sync = false
   opts.auto_flush = false
+  opts.stdout = false
   opts.colorize = false
-
-}.env(:production) { |opts|
-
-  opts.sync = false
-  opts.auto_flush = false
-  opts.colorize = false
-
-}
+end

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

@@ -0,0 +1,10 @@
+Pakyow::Config.register :reloader do |config|
+
+  # if true, the app will be reloaded on every request
+  config.opt :enabled
+
+end.env :development do |opts|
+  opts.enabled = true
+end.env :production do |opts|
+  opts.enabled = false
+end

data/pakyow-core/lib/{core → pakyow/core}/config/server.rb

@@ -1,5 +1,4 @@
-Pakyow::Config.register(:server) { |config|
-
+Pakyow::Config.register :server do |config|
   # the port to start `pakyow server`
   config.opt :port, 3000
 
@@ -8,5 +7,4 @@ Pakyow::Config.register(:server) { |config|
 
   # explicitly set a handler to try (e.g. puma)
   config.opt :handler
-
-}
+end

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

@@ -0,0 +1,41 @@
+Pakyow::Config.register :session do |config|
+  # whether or not to use sessions
+  config.opt :enabled, true
+
+  # the session object
+  config.opt :object, Rack::Session::Cookie
+
+  # session middleware config options
+  config.opt :options, -> {
+    opts = {
+      key: Pakyow::Config.session.key,
+      secret: Pakyow::Config.session.secret
+    }
+
+    # set optional options if available
+    %i(domain path expire_after old_secret).each do |opt|
+      value = Pakyow::Config.session.send(opt)
+      opts[opt] = value if value
+    end
+
+    opts
+  }
+
+  # the session key
+  config.opt :key, -> { "#{Pakyow::Config.app.name}.session" }
+
+  # the session secret
+  config.opt :secret, -> { ENV['SESSION_SECRET'] }
+
+  # the old session secret (used for rotation)
+  config.opt :old_secret
+
+  # session expiration, in seconds
+  config.opt :expire_after
+
+  # session cookie path
+  config.opt :path
+
+  # session cookie domain
+  config.opt :domain
+end

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

@@ -1,3 +1,5 @@
+require_relative 'errors'
+
 module Pakyow
   class Config
     class << self

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

@@ -0,0 +1,142 @@
+module Pakyow
+  module Helpers
+    # Methods for configuring an app.
+    #
+    # @api public
+    module Configuring
+      RESOURCE_ACTIONS = {
+        core: Proc.new { |app, set_name, path, block|
+          app.routes(set_name) { restful(set_name, path, &block) }
+        }
+      }
+
+      module InstanceMethods
+        # Convenience method for defining routes on an app instance.
+        #
+        # @api public
+        def routes(set_name = :main, &block)
+          self.class.routes(set_name, &block)
+          load_routes
+        end
+
+        # Convenience method for defining resources on an app instance.
+        #
+        # @api public
+        def resource(set_name, path, &block)
+          self.class.resource(set_name, path, &block)
+        end
+      end
+
+      def self.extended(object)
+        object.before :reload do
+          self.class.send(:load_config)
+        end
+
+        object.send(:include, InstanceMethods)
+      end
+
+      # Absolute path to the file containing the app definition.
+      #
+      # @api private
+      attr_reader :path
+
+      # Defines an app
+      #
+      # @api public
+      def define(&block)
+        raise ArgumentError, 'Expected a block' unless block_given?
+
+        # Sets the path to the file containiner the app definition for later reloading.
+        @path = String.parse_path_from_caller(caller[0])
+
+        instance_eval(&block)
+        self
+      end
+
+      # Defines a route set.
+      #
+      # @api public
+      def routes(set_name = :main, &block)
+        return @routes ||= {} unless block_given?
+        routes[set_name] = block
+        self
+      end
+
+      # Defines a resource.
+      #
+      # @api public
+      def resource(set_name, path, &block)
+        raise ArgumentError, 'Expected a block' unless block_given?
+
+        RESOURCE_ACTIONS.each do |plugin, action|
+          action.call(self, set_name, path, block)
+        end
+      end
+
+      # Accepts block to be added to middleware stack.
+      #
+      # @api public
+      def middleware(&block)
+        return @middleware ||= [] unless block_given?
+        middleware << block
+      end
+
+      # Creates an environment.
+      #
+      # @api public
+      def configure(env = :global, &block)
+        raise ArgumentError, 'Expected a block' unless block_given?
+        env_config[env] = block
+      end
+
+      protected
+
+      def load_config
+        # reload the app file
+        load(config.app.path)
+
+        # reset config
+        envs = config.app.loaded_envs
+        config.reset
+
+        # reload config
+        load_env_config(*envs)
+      end
+
+      def load_env_config(*env_or_envs)
+        hook_around :configure do
+          envs = build_envs(env_or_envs)
+
+          config.app.loaded_envs = envs
+          config.env = envs.first
+
+          load_env(:global)
+
+          envs.each do |env|
+            load_env(env)
+          end
+
+          Pakyow.configure_logger
+        end
+      end
+
+      def env_config
+        @config ||= {}
+      end
+
+      def build_envs(env_or_envs)
+        envs = Array.ensure(env_or_envs)
+        envs = (envs.empty? || envs.first.nil?) ? [config.app.default_environment] : envs
+        envs.map!(&:to_sym)
+      end
+
+      def load_env(env)
+        config.app_config(&config_for(env))
+      end
+
+      def config_for(env)
+        env_config.fetch(env) { proc{} }
+      end
+    end
+  end
+end