pakyow-core 0.8rc1 → 0.8.rc4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6603c6f6c576749182546ee51b5f99a237ba2ab2
+  data.tar.gz: a986e3adf2e4c33a16e8565b48984947bc1e00e5
+SHA512:
+  metadata.gz: 13942daed315f9bf380e9ff718d07458c89d630918d781377117e11aec1dfcab916c5692c769e6148ea37ec74e931c402ae303be62db75f2a77005b293b95d5c
+  data.tar.gz: 81cddf4aadc79a683129e3420cdf95e42f1e863cbfc123dbe93b92685ac830e533f3f76ca0cae149cc02b4300c5c9a5cb08419023763c7192f5b234ed07da3cf

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

@@ -0,0 +1,448 @@
+module Pakyow
+  class App
+    class << self
+      def reset
+        @@routes = {}
+        @@config = {}
+
+        @@stacks = {:before => {}, :after => {}}
+        %w(init load process route match error).each {|name|
+          @@stacks[:before][name.to_sym] = []
+          @@stacks[:after][name.to_sym] = []
+        }
+      end
+
+      # Defines an app
+      #
+      def define(&block)
+        # sets the path to the app file so it can be reloaded later
+        config.app.path = StringUtils.parse_path_from_caller(caller[0])
+
+        self.instance_eval(&block)
+      end
+
+      # Defines a route set.
+      #
+      #TODO default route set should be config option (also for bindings)
+      def routes(set_name = :main, &block)
+        if set_name && block
+          @@routes[set_name] = block
+        else
+          @@routes
+        end
+      end
+
+      # Defines middleware to be loaded.
+      #
+      def middleware(&block)
+        # prevents middleware from being loaded on each
+        # request when auto_reload is enabled
+        return if prepared?
+
+        # tell builder about the middleware
+        builder.instance_eval(&block)
+      end
+
+      # Creates an environment.
+      #
+      def configure(env, &block)
+        @@config[env] = block
+      end
+
+      # Fetches a stack (before | after) by name.
+      #
+      def stack(which, name)
+        @@stacks[which][name]
+      end
+
+      # Adds a block to the before stack for `stack_name`.
+      #
+      def before(stack_name, &block)
+        @@stacks[:before][stack_name.to_sym] << block
+      end
+
+      # Adds a block to the after stack for `stack_name`.
+      #
+      def after(stack_name, &block)
+        @@stacks[:after][stack_name.to_sym] << block
+      end
+
+      # Runs the application. Accepts the environment(s) to run, for example:
+      # run(:development)
+      # run([:development, :staging])
+      #
+      def run(*args)
+        return if running?
+
+        @running = true
+        builder.run(prepare(args))
+        detect_handler.run(builder, :Host => config.server.host, :Port => config.server.port) do |server|
+          trap(:INT)  { stop(server) }
+          trap(:TERM) { stop(server) }
+        end
+      end
+
+      # Stages the application. Everything is loaded but the application is
+      # not started. Accepts the same arguments as #run.
+      #
+      def stage(*args)
+        return if staged?
+        @staged = true
+        prepare(args)
+      end
+
+      def builder
+        @builder ||= Rack::Builder.new
+      end
+
+      def prepared?
+        @prepared
+      end
+
+      # Returns true if the application is running.
+      #
+      def running?
+        @running
+      end
+
+      # Returns true if the application is staged.
+      #
+      def staged?
+        @staged
+      end
+
+      # Convenience method for base configuration class.
+      #
+      def config
+        Pakyow::Config::Base
+      end
+
+      def load_config(envs)
+        # run global config first
+        if global_proc = @@config[:global]
+          config.instance_eval(&global_proc)
+        end
+
+        # then run other envs
+
+        envs.each do |env|
+          next unless config_proc = @@config[env.to_sym]
+          config.instance_eval(&config_proc)
+        end
+
+        config.app.loaded_envs = envs
+      end
+
+      protected
+
+      # Prepares the application for running or staging and returns an instance
+      # of the application.
+      def prepare(envs)
+        return if prepared?
+
+        # configure
+        envs = envs.empty? || envs.first.nil? ? [config.app.default_environment] : envs
+        load_config(envs)
+
+        # load middleware
+        builder.use(Rack::MethodOverride)
+        builder.use(Middleware::Static)   if config.app.static
+        builder.use(Middleware::Logger)   if config.app.log
+        builder.use(Middleware::Reloader) if config.app.auto_reload
+
+        @prepared = true
+
+        $:.unshift(Dir.pwd) unless $:.include? Dir.pwd
+
+        return self.new
+      end
+
+      def detect_handler
+        handlers = ['puma', 'thin', 'mongrel', 'webrick']
+        handlers.unshift(config.server.handler) if config.server.handler
+
+        handlers.each do |handler|
+          begin
+            return Rack::Handler.get(handler)
+          rescue LoadError
+          rescue NameError
+          end
+        end
+      end
+
+      def stop(server)
+        if server.respond_to?('stop!')
+          server.stop!
+        elsif server.respond_to?('stop')
+          server.stop
+        else
+          # exit ungracefully if necessary...
+          Process.exit!
+        end
+      end
+    end
+
+    include Helpers
+    include AppHelpers
+
+    attr_accessor :request, :response
+
+    def initialize
+      Pakyow.app = self
+      Pakyow.configure_logger
+
+      call_stack(:before, :init)
+
+      load_app
+
+      call_stack(:after, :init)
+    end
+
+    # Returns the primary (first) loaded env.
+    #
+    def env
+      config.app.loaded_envs[0]
+    end
+
+    def app
+      self
+    end
+
+    def call(env)
+      dup.process(env)
+    end
+
+    # Called on every request.
+    #
+    def process(env)
+      call_stack(:before, :process)
+
+      @response = Response.new
+      @request  = Request.new(env)
+      @request.app = self
+      @request.setup
+
+      set_initial_cookies
+
+      @found = false
+      catch(:halt) {
+        unless config.app.ignore_routes
+          call_stack(:before, :route)
+
+          @found = @router.perform(@request, self) {
+            call_stack(:after, :match)
+          }
+
+          call_stack(:after, :route)
+        end
+
+        unless found?
+          handle(404, false) 
+
+          if config.app.errors_in_browser
+            @response["Content-Type"] = 'text/html'
+
+            view_file = File.join(File.expand_path('../../', __FILE__), 'views', 'errors', '404.html')
+            content = File.open(view_file).read
+
+            path = StringUtils.normalize_path(request.path)
+            path = '/' if path.empty?
+
+            content.gsub!('{view_path}', path == '/' ? 'index.html' : "#{path}.html")
+            content.gsub!('{route_path}', path)
+
+            @response.body = []
+            @response.body << content
+          end
+        end
+      }
+
+      set_cookies
+
+      call_stack(:after, :process)
+
+      @response.finish
+    rescue StandardError => error
+      call_stack(:before, :error)
+
+      @request.error = error
+
+      handle(500, false) unless found?
+
+      if config.app.errors_in_browser
+        @response["Content-Type"] = 'text/html'
+        
+        view_file = File.join(File.expand_path('../../', __FILE__), 'views', 'errors', '500.html')
+        content = File.open(view_file).read
+
+        path = StringUtils.normalize_path(request.path)
+        path = '/' if path.empty?
+
+        nice_source = error.backtrace[0].match(/^(.+?):(\d+)(|:in `(.+)')$/)
+
+        content.gsub!('{file}', nice_source[1].gsub(File.expand_path(Config::App.root) + '/', ''))
+        content.gsub!('{line}', nice_source[2])
+        
+        content.gsub!('{msg}', error.to_s)
+        content.gsub!('{trace}', error.backtrace.join('<br>'))
+
+        @response.body = []
+        @response.body << content
+      end
+
+      call_stack(:after, :error)
+
+      @response.finish
+    end
+
+    def found?
+      @found
+    end
+
+    # This is NOT a useless method, it's a part of the external api
+    def reload
+      # reload the app file
+      load(config.app.path)
+
+      # reset config
+      envs = config.app.loaded_envs
+      config.reset!
+
+      # reload config
+      self.class.load_config(envs)
+
+      load_app
+    end
+
+    # APP ACTIONS
+
+    # Interrupts the application and returns response immediately.
+    #
+    def halt
+      throw :halt, @response
+    end
+
+    # Routes the request to different logic.
+    #
+    def reroute(path, method = nil)
+      @request.setup(path, method)
+
+      call_stack(:before, :route)
+      call_stack(:after, :match)
+      @router.reroute(@request)
+      call_stack(: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.class == File
+        data = file_or_data.read
+
+        # auto set type based on file type
+        type = Rack::Mime.mime_type("." + StringUtils.split_at_last_dot(file_or_data.path)[1])
+      else
+        data = file_or_data
+      end
+
+      headers = {}
+      headers["Content-Type"]         = type if type
+      headers["Content-disposition"]  = "attachment; filename=#{send_as}" if send_as
+
+      @response = Response.new(data, @response.status, @response.header.merge(headers))
+      halt
+    end
+
+    # Redirects to location (immediately).
+    #
+    def redirect(location, status_code = 302)
+      location = router.path(location) if location.is_a?(Symbol)
+      
+      headers = response ? response.header : {}
+      headers = headers.merge({'Location' => location})
+
+      app.response = Response.new('', status_code, headers)
+      halt
+    end
+
+    def handle(name_or_code, from_logic = true)
+      call_stack(:before, :route)
+      @router.handle(name_or_code, self, from_logic)
+      call_stack(:after, :route)
+    end
+
+    # Convenience method for defining routes on an app instance.
+    #
+    def routes(set_name = :main, &block)
+      self.class.routes(set_name, &block)
+      load_routes
+    end
+
+    protected
+
+    def call_stack(which, stack)
+      self.class.stack(which, stack).each {|block|
+        self.instance_exec(&block)
+      }
+    end
+
+    # Reloads all application files in path and presenter (if specified).
+    #
+    def load_app
+      call_stack(:before, :load)
+
+      # load src files
+      @loader = Loader.new
+      @loader.load_from_path(config.app.src_dir)
+
+      # load the routes
+      load_routes
+
+      call_stack(:after, :load)
+    end
+
+    def load_routes
+      @router = Router.instance.reset
+      self.class.routes.each_pair {|set_name, block|
+        @router.set(set_name, &block)
+      }
+    end
+
+    def set_cookies
+      @request.cookies.each_pair {|k, v|
+        @response.unset_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
+
+  App.reset
+end

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

@@ -1,27 +1,25 @@
-require 'core/configuration/base'
+require 'core/config/base'
+require 'core/config/app'
+require 'core/config/server'
+require 'core/config/cookies'
+require 'core/config/logger'
 require 'core/helpers'
-require 'core/log'
+require 'core/multilog'
 require 'core/request'
 require 'core/response'
 require 'core/loader'
 require 'core/router'
 require 'core/route_set'
-require 'core/route_template'
+require 'core/route_eval'
 require 'core/route_template_defaults'
 require 'core/route_lookup'
-require 'core/application'
-require 'core/cache'
-require 'core/presenter_base'
-require 'core/fn_context'
+require 'core/app'
+require 'core/exceptions'
 
 # middlewares
 require 'core/middleware/logger'
 require 'core/middleware/static'
 require 'core/middleware/reloader'
-require 'core/middleware/presenter'
-require 'core/middleware/not_found'
-require 'core/middleware/router'
-require 'core/middleware/setup'
 
 # utils
 require 'utils/string'
@@ -29,5 +27,30 @@ require 'utils/hash'
 require 'utils/dir'
 
 module Pakyow
-  attr_accessor :app
+  attr_accessor :app, :logger
+
+  def configure_logger
+    conf = Config::Base
+
+    logs = []
+
+    if File.directory?(conf.logger.path)
+      log_path = File.join(conf.logger.path, conf.logger.name)
+
+      begin
+        log = File.open(log_path, 'a')
+        log.sync if conf.logger.sync
+
+        logs << log
+      rescue StandardError => e
+        warn "Error opening '#{log_path}' for writing"
+      end
+    end
+
+    logs << $stdout if conf.app.log_output
+
+    io = logs.count > 1 ? MultiLog.new(*logs) : logs[0]
+
+    Pakyow.logger = Logger.new(io, conf.logger.level, conf.logger.colorize, conf.logger.auto_flush)
+  end
 end

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

@@ -1,59 +1,58 @@
 module Pakyow
-  module Configuration
+  module Config
     class App
+      Config::Base.register_config(:app, self)
+
       class << self
-        attr_accessor :dev_mode, :log, :public_dir, :root, :log_dir, 
-        :presenter, :default_action, :ignore_routes, :error_level, 
-        :default_environment, :application_path, :log_name, :src_dir,
-        :auto_reload, :errors_in_browser, :static, :all_views_visible
-        
-        # Displays development-specific warnings.
-        #
-        def dev_mode
-          @dev_mode.nil? ? true : @dev_mode
+        attr_accessor :log, :resources, :root, :default_action, :ignore_routes,
+        :default_environment, :path, :src_dir, :auto_reload, :errors_in_browser,
+        :static, :all_views_visible, :loaded_envs, :log_output
+
+        def method_missing(name, *args)
+          if name[-1,1] == '='
+            name = name[0..-2]
+            instance_variable_set("@#{name}", *args)
+          else
+            instance_variable_get("@#{name}")
+          end
         end
-        
+
         def auto_reload
           @auto_reload.nil? ? true : @auto_reload
         end
-        
+
         def errors_in_browser
           @errors_in_browser.nil? ? true : @errors_in_browser
         end
-        
+
         # Log requests?
         def log
           @log.nil? ? true : @log
         end
-        
+
+        def log_output
+          @log_output || true
+        end
+
         # Root directory
         def root
           @root || File.dirname('')
         end
-        
-        # Public directory
-        def public_dir
-          @public_dir || "#{root}/public"
-        end
-        
-        # Log directory
-        def log_dir
-          @log_dir || "#{root}/logs"
-        end
 
-        def log_name
-          @log_name || "requests.log"
+        # Resources directory
+        def resources
+          @resources ||= { :default => "#{root}/public" }
         end
 
         def src_dir
-          @src_dir || "#{root}/lib"
+          @src_dir || "#{root}/app/lib"
         end
-        
+
         # Default action
         def default_action
           @default_action || :index
         end
-        
+
         # Mockup mode
         def ignore_routes
           @ignore_routes.nil? ? false : @ignore_routes
@@ -62,24 +61,28 @@ module Pakyow
         def all_views_visible
           @all_views_visible.nil? ? true : @all_views_visible
         end
-        
+
         def default_environment
           @default_environment || :development
         end
-        
+
         # The path to the application class
-        def application_path
-          @application_path
+        def path
+          @path
         end
-        
+
         # Handle static files?
         #
-        # For best performance, should be set to false if static files are 
+        # For best performance, should be set to false if static files are
         # handled by a web server (e.g. Nginx)
         #
         def static
           @static || true
         end
+
+        def loaded_envs
+          @loaded_envs
+        end
       end
     end
   end

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

@@ -0,0 +1,30 @@
+module Pakyow
+  module Config
+    class Base
+      @@configs = {}
+      def self.register_config(name, klass)
+        @@configs[name] = klass
+
+        define_singleton_method name do
+          @@configs[name]
+        end
+      end
+
+      # Resets all config
+      def self.reset!
+        @@configs.keys.each do |type|
+          klass = self.send(type.to_sym)
+          klass.instance_variables.each do |var|
+            # Assumes path shouldn't be reset, since it's only set
+            # once when Pakyow::Application is inherited.
+            next if var.to_sym == :'@path'
+            begin
+              klass.send("#{var.to_s.gsub('@', '')}=", nil)
+            rescue
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Pakyow
+  module Config
+    class Cookies
+      Config::Base.register_config(:cookies, self)
+
+      class << self
+        attr_accessor :path, :expiration
+        
+        # What path should the cookie be created for?
+        def path
+          @path || '/'
+        end
+        
+        # When does the cookie expire?
+        def expiration
+          @expiration || Time.now + 60 * 60 * 24 * 7 # one week
+        end
+      end
+    end
+  end
+end