pakyow-core 0.11.3 → 1.0.0.rc1

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

@@ -1,61 +0,0 @@
-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

@@ -1,171 +0,0 @@
-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) || file_or_data.is_a?(StringIO)
-        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/pakyow/core/config/app.rb

@@ -1,49 +0,0 @@
-Pakyow::Config.register :app do |config|
-
-  config.opt :name, 'pakyow'
-
-  # if true, errors are displayed in the browser
-  config.opt :errors_in_browser
-
-  # the location of the app's root directory
-  config.opt :root, File.dirname('')
-
-  # the location of the app's resources
-  config.opt :resources, -> {
-    @resources ||= {
-      default: File.join(root, 'public')
-    }
-  }
-
-  # the location of the app's source code
-  config.opt :src_dir, -> { File.join(root, 'app', 'lib') }
-
-  # the environment to run in, if one isn't provided
-  config.opt :default_environment, :development
-
-  # the default action to use for routing
-  config.opt :default_action, :index
-
-  # if true, all routes are ignored
-  config.opt :ignore_routes, false
-
-  # if true, views are visible without a route defined
-  config.opt :all_views_visible, true
-
-  # whether or not pakyow should serve static files
-  config.opt :static, true
-
-  # stores the path to the app definition
-  config.opt :path, -> { Pakyow::App.path }
-
-  # stores the envs an app is run in
-  config.opt :loaded_envs
-end.env :development do |opts|
-  opts.errors_in_browser = true
-  opts.static = true
-end.env :production do |opts|
-  opts.errors_in_browser = false
-  opts.static = true
-end.env :prototype do |opts|
-  opts.ignore_routes = false
-end

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

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

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

@@ -1,34 +0,0 @@
-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, -> { File.join(Pakyow::Config.app.root, 'log') }
-
-  # the name of the log file
-  config.opt :filename, 'pakyow.log'
-
-  # whether or not the log file should be synced
-  config.opt :sync
-
-  # whether or not the log file should be flushed automatically
-  config.opt :auto_flush
-
-  # whether or not the log file should be colorized
-  config.opt :colorize
-end.env :development do |opts|
-  opts.sync = true
-  opts.auto_flush = true
-  opts.colorize = true
-end.env :production do |opts|
-  opts.sync = false
-  opts.auto_flush = false
-  opts.stdout = false
-  opts.colorize = false
-end

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

@@ -1,10 +0,0 @@
-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/pakyow/core/config/server.rb

@@ -1,10 +0,0 @@
-Pakyow::Config.register :server do |config|
-  # the port to start `pakyow server`
-  config.opt :port, 3000
-
-  # the host to start `pakyow server`
-  config.opt :host, '0.0.0.0'
-
-  # explicitly set a handler to try (e.g. puma)
-  config.opt :handler
-end

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

@@ -1,41 +0,0 @@
-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/pakyow/core/config.rb

@@ -1,95 +0,0 @@
-require_relative 'errors'
-
-module Pakyow
-  class Config
-    class << self
-      attr_accessor :env
-    end
-
-    def self.register(name)
-      config = Pakyow::Config.new(name)
-      yield(config.defaults)
-
-      @config ||= {}
-      @config[name] = config
-
-      self.class.instance_eval do
-        define_method(name) { @config[name] }
-      end
-
-      config
-    end
-
-    def self.deregister(name)
-      @config.delete(name)
-    end
-
-    def self.reset
-      @config.values.each(&:reset)
-    end
-
-    def self.app_config(&block)
-      instance_eval(&block)
-    end
-
-    attr_reader :config_name
-
-    def initialize(name, default_config: false)
-      @config_name = name
-      @opts = {}
-      @envs = {}
-      @default_config = default_config
-    end
-
-    def defaults
-      return if @default_config # don't define defaults for defaults
-      @defaults ||= Pakyow::Config.new("#{@config_name}.defaults", default_config: true)
-    end
-
-    def env(name)
-      config = Pakyow::Config.new("#{@config_name}.#{name}")
-      yield(config)
-
-      @envs[name] = config
-      self
-    end
-
-    def clear_env(name)
-      @envs.delete(name)
-    end
-
-    def value(name, *args)
-      value = @opts.fetch(name) { raise(ConfigError.new("No config value available for `#{@config_name}.#{name}`")) }
-      value = instance_exec(*args, &value) if value.is_a?(Proc)
-      value
-    end
-
-    def opt(name, default = nil)
-      context = defaults ? defaults : self
-      context.instance_variable_get(:@opts)[name] = default
-    end
-
-    def reset
-      @opts = {}
-    end
-
-    def method_missing(method, *args)
-      if /^(\w+)=$/ =~ method
-        @opts[$1.to_sym] = args[0]
-      else
-        configs = [self]
-        configs << @envs[Config.env] if @envs.key?(Config.env)
-        configs << @defaults unless @defaults.nil?
-
-        configs.each do |config|
-          begin
-            return config.value(method, *args)
-          rescue ConfigError
-          end
-        end
-
-        raise(ConfigError.new("No config value available for `#{@config_name}.#{method}`"))
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module Pakyow
-  # Raised when no app context is available
-  class NoContextError < StandardError; end
-
-  # Raised when no config object is available
-  class ConfigError < StandardError; end
-
-  # Raised when route is looked up that doesn't exist
-  class MissingRoute < StandardError; end
-
-  # Raised when template part doesn't exist
-  class UnknownTemplatePart < StandardError; end
-
-  class Error < StandardError; end
-end
-

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

@@ -1,142 +0,0 @@
-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