pakyow-core 0.11.3 → 1.0.0.rc1

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

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

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

@@ -1,61 +0,0 @@
-module Pakyow
-  # Helpers available anywhere
-  #
-  # @api public
-  module Helpers
-    def context
-      @context or raise NoContextError
-    end
-
-    def logger
-      request.logger || Pakyow.logger
-    end
-
-    def router
-      RouteLookup.new
-    end
-
-    def request
-      context ? context.request : nil
-    end
-    alias_method :req, :request
-
-    def response
-      context ? context.response : nil
-    end
-    alias_method :res, :response
-
-    def params
-      request ? request.params : {}
-    end
-
-    def session
-      request ? request.session : {}
-    end
-
-    def cookies
-      request ? request.cookies : {}
-    end
-
-    def config
-      Pakyow::Config
-    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/pakyow/core/loader.rb

@@ -1,32 +0,0 @@
-module Pakyow
-  # Handles the loading and reloading of a Pakyow application. If in development
-  # mode, files are automatically reloaded if modified.
-  class Loader
-
-    # Loads files in the provided path, decending into child directories.
-    def load_from_path(path)
-      require_recursively(path)
-    end
-
-    protected
-
-    def require_recursively(dir)
-      @times ||= {}
-      if File.exists?(dir)
-        Dir.walk(dir) do |path|
-          next if FileTest.directory?(path)
-          next if path.split('.')[-1] != 'rb'
-
-          if Config.reloader.enabled
-            if !@times[path] || (@times[path] && File.mtime(path) - @times[path] > 0)
-              load(path)
-              @times[path] = File.mtime(path)
-            end
-          else
-            require path
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,146 +0,0 @@
-module Pakyow
-  class Logger
-    LEVELS = {
-      :debug   => 0,
-      :info    => 1,
-      :warn    => 2,
-      :error   => 3,
-      :fatal   => 4,
-      :unknown => 5,
-    }
-
-    LEVEL_COLORS = {
-      :debug   => :cyan,
-      :info    => :green,
-      :warn    => :yellow,
-      :error   => :red,
-      :fatal   => :red,
-      # :unknown => nil,
-    }
-
-    COLOR_TABLE = [
-      :black,
-      :red,
-      :green,
-      :yellow,
-      :blue,
-      :magenta,
-      :cyan,
-      :white,
-    ]
-
-    RESET_SEQ = "\033[0m"
-    COLOR_SEQ = "\033[%dm"
-    BOLD_SEQ  = "\033[1m"
-
-    def initialize(log = $stdout, level = 0, format = false, auto_flush = false)
-      level = LEVELS[level] if level.is_a?(Symbol)
-      @log, @level, @format, @auto_flush = log, level, format, auto_flush
-      @mutex = Mutex.new
-    end
-
-    def <<(msg = nil, severity = :unknown)
-      return if @log.nil?
-      (msg || "") << "\n"
-
-      msg = format(msg, severity) if @format
-      @mutex.synchronize do
-        @log.write msg
-        @log.flush if @auto_flush
-      end
-    end
-
-    alias :write :<<
-
-    def add(severity, msg = nil)
-      severity ||= LEVELS[:unknown]
-      return if severity < @level
-
-      write(msg, severity)
-    end
-
-    alias :log :add
-
-    def debug(msg = nil)
-      add(LEVELS[:debug], msg)
-    end
-
-    def info(msg = nil)
-      add(LEVELS[:info], msg)
-    end
-
-    def warn(msg = nil)
-      add(LEVELS[:warn], msg)
-    end
-
-    def error(msg = nil)
-      add(LEVELS[:error], msg)
-    end
-
-    def fatal(msg = nil)
-      add(LEVELS[:fatal], msg)
-    end
-
-    def format(msg, level)
-      return msg unless color = level_color(level)
-      return COLOR_SEQ % (30 + COLOR_TABLE.index(color)) + (msg || "") + RESET_SEQ
-    end
-
-    def level_color(level)
-      LEVEL_COLORS[LEVELS.key(level)]
-    end
-
-    def close
-      @log.close
-    end
-
-  end
-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) {
-        error = request.error
-        Pakyow.logger.error "[500] #{error.class}: #{error}\n" + error.backtrace.join("\n") + "\n\n"
-      }
-
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        env['rack.logger'] = Pakyow.logger
-
-        result = nil
-        difference = time { |began_at|
-          Pakyow.logger << "#{env['REQUEST_METHOD']} #{env['REQUEST_URI']} for #{env['REMOTE_ADDR']} at #{began_at}"
-          result = @app.call(env)
-        }
-
-        status = result[0]
-        Pakyow.logger << "#{status} (#{nice_status(status)}) in #{difference}ms\n"
-
-        result
-      end
-
-      def time
-        s = Time.now
-        yield(s)
-        time = ((Time.now.to_f - s.to_f) * 1000.0)
-        (time * 10**2).round / (10**2).to_f
-      end
-
-      def nice_status(status)
-        Pakyow::Response::STATUS_CODE_NAMES[status] || '?'
-      end
-    end
-  end
-end

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

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

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

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

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

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

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

@@ -1,19 +0,0 @@
-module Pakyow
-  class MultiLog
-    def initialize(*targets)
-      @targets = targets
-    end
-
-    def write(*args)
-      @targets.each { |t| t.write(*args) }
-    end
-
-    def close
-      @targets.each(&:close)
-    end
-
-    def flush
-      @targets.each(&:flush)
-    end
-  end
-end