pakyow-core 0.8rc1 → 0.8.rc4

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

@@ -1,330 +0,0 @@
-module Pakyow
-  class Application
-    class << self
-      attr_accessor :core_proc, :middleware_proc, :middlewares, :configurations
-
-      # Sets the path to the application file so it can be reloaded later.
-      #
-      def inherited(subclass)
-        Pakyow::Configuration::App.application_path = StringUtils.parse_path_from_caller(caller[0])
-      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
-        self.builder.run(self.prepare(args))
-        detect_handler.run(builder, :Host => Pakyow::Configuration::Base.server.host, :Port => Pakyow::Configuration::Base.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::Configuration::Base
-      end
-
-      # Creates configuration for a particular environment. Example:
-      # configure(:development) { app.auto_reload = true }
-      #
-      def configure(environment, &block)
-        self.configurations ||= {}
-        self.configurations[environment] = block
-      end
-
-      # The block that stores routes, handlers, and hooks.
-      #
-      def core(&block)
-        self.core_proc = block
-      end
-
-      # The block that stores presenter related things.
-      #
-      def presenter(&block)
-        Configuration::Base.app.presenter.proc = block
-      end
-
-      def middleware(&block)
-        self.middleware_proc = block
-      end
-      
-      def before(step, middlewares)
-        middlewares = [middlewares] unless middlewares.is_a?(Array)
-        step = step.to_sym
-
-        self.middlewares ||= {}
-        self.middlewares[step] ||= {}
-        (self.middlewares[step][:before] ||= []).concat(middlewares)
-      end
-      
-      def after(step, middlewares)
-        middlewares = [middlewares] unless middlewares.is_a?(Array)
-        step = step.to_sym
-
-        self.middlewares ||= {}
-        self.middlewares[step] ||= {}
-        (self.middlewares[step][:after] ||= []).concat(middlewares)
-      end
-
-      def use(step, type, builder)
-        return unless self.middlewares
-        return unless self.middlewares[step]
-        return unless self.middlewares[step][type]
-
-        self.middlewares[step][type].each { |m|
-          builder.use(m)
-        }
-      end
-      
-
-      protected
-
-      # Prepares the application for running or staging and returns an instance
-      # of the application.
-      def prepare(args)
-        self.load_config args.empty? || args.first.nil? ? [Configuration::Base.app.default_environment] : args
-        return if prepared?
-
-        self.builder.use(Rack::MethodOverride)
-
-        self.builder.use(Pakyow::Middleware::Setup)
-
-        #TODO possibly deprecate
-        self.builder.instance_eval(&self.middleware_proc) if self.middleware_proc
-        
-        self.builder.use(Pakyow::Middleware::Static)      if Configuration::Base.app.static
-        self.builder.use(Pakyow::Middleware::Logger)      if Configuration::Base.app.log
-        self.builder.use(Pakyow::Middleware::Reloader)    if Configuration::Base.app.auto_reload
-        
-        if Configuration::Base.app.presenter
-          self.use(:presentation, :before, self.builder)
-          self.builder.use(Pakyow::Middleware::Presenter)   
-          self.use(:presentation, :after, self.builder)
-        end
-        
-        unless Configuration::Base.app.ignore_routes
-          self.use(:routing, :before, self.builder)
-          self.builder.use(Pakyow::Middleware::Router)
-          self.use(:routing, :after, self.builder)
-        end
-
-        self.builder.use(Pakyow::Middleware::NotFound)    # always
-        
-        @prepared = true
-
-        $:.unshift(Dir.pwd) unless $:.include? Dir.pwd
-        return self.new
-      end
-
-      def load_config(args)
-        if self.configurations
-          args << Configuration::Base.app.default_environment if args.empty?
-          args.each do |env|
-            next unless config = self.configurations[env.to_sym]
-            Configuration::Base.instance_eval(&config)
-          end
-        end
-      end
-
-      def detect_handler
-        handlers = ['thin', 'mongrel', 'webrick']
-        handlers.unshift(Configuration::Base.server.handler) if Configuration::Base.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
-
-    attr_accessor :request, :response, :presenter, :router
-
-    def initialize
-      Pakyow.app = self
-
-      Pakyow.app.presenter = Configuration::Base.app.presenter.instance if Configuration::Base.app.presenter
-            
-      # Load application files
-      load_app(false)
-
-      # Prepare for logging
-      Log.reopen
-    end
-
-    def setup_rr(env)
-      self.request = Request.new(env)
-      self.response = Response.new
-    end
-
-    # Called on every request.
-    #
-    def call(env)
-      finish
-    end
-
-    # This is NOT a useless method, it's a part of the external api
-    def reload
-      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)
-      self.request.setup(path, method)
-
-      begin
-        # caught by other middleware (e.g. presenter) that does something with the
-        # new request then hands it back down to the router
-        throw :rerouted, request
-      rescue ArgumentError
-        # nobody caught it, so tell the router to reroute
-        app.router.reroute!(request)
-      end
-    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)
-      case file_or_data.class
-      when File
-        data = File.open(path, "r").each_line { |line| data << line }
-
-        # auto set type based on file type
-        type = Rack::Mime.mime_type("." + StringUtils.split_at_last_dot(File.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
-
-      app.response = Rack::Response.new(data, response.status, response.header.merge(headers))
-      halt
-    end
-
-    # Redirects to location (immediately).
-    #
-    def redirect(location, status_code = 302)
-      headers = response ? response.header : {}
-      headers = headers.merge({'Location' => location})
-
-      app.response = Rack::Response.new('', status_code, headers)
-      halt
-    end
-
-    def handle(name_or_code)
-      app.router.handle!(name_or_code, true)
-    end
-
-    protected
-
-    #TODO need configuration options for cookies (plus ability to override for each?)
-    def set_cookies
-      if self.request.cookies && self.request.cookies != {}
-        self.request.cookies.each do |key, value|
-          if value.nil?
-            self.response.set_cookie(key, {:path => '/', :expires => Time.now + 604800 * -1 }.merge({:value => value}))
-          elsif value.is_a?(Hash)
-            self.response.set_cookie(key, {:path => '/', :expires => Time.now + 604800}.merge(value))
-          else
-            self.response.set_cookie(key, {:path => '/', :expires => Time.now + 604800}.merge({:value => value}))
-          end
-        end
-      end
-    end
-
-    # Reloads all application files in application_path and presenter (if specified).
-    #
-    def load_app(reload_app = true)
-      load(Configuration::App.application_path) if reload_app
-
-      @loader = Loader.new unless @loader
-      @loader.load_from_path(Configuration::Base.app.src_dir)
-
-      self.load_core
-      self.presenter.load if self.presenter
-    end
-
-    # Evaluates core_proc
-    #
-    def load_core
-      @router = Router.instance.reset
-
-      @router.set(:default, &self.class.core_proc) if self.class.core_proc
-    end
-    
-    # Send the response and cleanup.
-    #
-    #TODO remove exclamation
-    def finish
-      set_cookies
-      self.response.finish
-    end
-
-  end
-end

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

@@ -1,25 +0,0 @@
-module Pakyow
-  class Cache
-    def initialize
-      @store = {}
-    end
-
-    def put(key, v)
-      @store[key] = v
-    end
-
-    def get(key, &block)
-      v = @store[key]
-      if v == nil && block_given?
-        v = block.call(key)
-        @store[key] = v
-      end
-      v
-    end
-
-    def invalidate(key)
-      put(key, nil)
-    end
-
-  end
-end

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

@@ -1,31 +0,0 @@
-module Pakyow
-  module Configuration
-    autoload :App, 'core/configuration/app'
-    autoload :Server, 'core/configuration/server'    
-    
-    class Base
-      # Fetches the server configuration    
-      def self.server
-        Configuration::Server
-      end
-      
-      # Fetches to application configuration
-      def self.app
-        Configuration::App
-      end
-      
-      # Resets all configuration
-      def self.reset!
-        %w[app server].each do |type|
-          klass = self.send(type.to_sym)
-          klass.instance_variables.each do |var|
-            # Assumes application_path shouldn't be reset, since it's only set
-            # once when Pakyow::Application is inherited.
-            next if var.to_sym == :'@application_path'
-            klass.send("#{var.to_s.gsub('@', '')}=", nil)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,5 +0,0 @@
-module Pakyow
-  class FnContext
-    include Helpers
-  end
-end

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

@@ -1,39 +0,0 @@
-module Pakyow
-  
-  # Provides an easy way to log text, warnings, etc.
-  class Log
-    # Opens stdout and the log file for writing.
-    def self.reopen
-      @@console = $stdout
-
-      d = Configuration::Base.app.log_dir
-      @@file = File.exists?(d) ? File.open("#{d}/#{Configuration::Base.app.log_name}", 'a') : nil
-    end
-
-    def self.close
-      @@file.close if @@file
-    end
-
-    # Adds text to the log. 
-    def self.puts(text = "")
-      return if !Configuration::Base.app.log
-      
-      @@console << "#{text}\r\n"
-      @@file.write "#{text}\r\n" if @@file
-    end
-
-    class << self
-      alias :enter :puts
-    end
-    
-    # Adds warning text to the log.
-    def self.warn(text)
-      Log.enter("WARNING: #{text}")
-    end
-
-    # Adds error text to the log.
-    def self.error(text)
-      Log.enter("ERROR: #{text}")
-    end
-  end
-end

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

@@ -1,40 +0,0 @@
-module Pakyow
-  module Middleware
-    class NotFound
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        @app.call(env)
-        
-        # 404 if no route matched and no views were found
-        unless found?
-          Log.enter "[404] Not Found"
-
-          Pakyow.app.response.body = [] 
-          Pakyow.app.presenter.reset if Pakyow.app.presenter
-
-          Pakyow.app.response.status = 404
-          Pakyow.app.router.handle!(404)
-
-          if Pakyow.app.presenter
-            # consider moving to presenter middleware
-            # Pakyow.app.presenter.prepare_for_request(Pakyow.app.request)
-            Pakyow.app.response.body = [Pakyow.app.presenter.content] if Pakyow.app.presenter.presented?
-          end
-        end
-      end
-
-      private
-
-      def found?
-        return true if Pakyow.app.router.routed?
-        return true if Pakyow.app.presenter && Pakyow.app.presenter.presented? && Configuration::App.all_views_visible
-
-        false
-      end
-    end
-  end
-end
-

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

@@ -1,25 +0,0 @@
-module Pakyow
-  module Middleware
-    class Presenter
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        r = Pakyow.app.request
-
-        while(r) do
-          Pakyow.app.presenter.prepare_for_request(Pakyow.app.request)
-
-          r = catch(:rerouted) {
-                   @app.call(@env)
-                   nil
-                 }
-        end
-                                                                  #TODO the right thing to do?
-        Pakyow.app.response.body = [Pakyow.app.presenter.content] if Pakyow.app.presenter.presented?
-        Pakyow.app.response.finish
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-module Pakyow
-  module Middleware
-    class Router
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        catch(:halt) {
-          Pakyow.app.router.route!(Pakyow.app.request)
-          @app.call(env)
-        }
-      rescue StandardError => error
-        Pakyow.app.request.error = error
-
-        Pakyow.app.response.status = 500
-        Pakyow.app.router.handle!(500)
-
-        if Configuration::Base.app.errors_in_browser
-          Pakyow.app.response.body = []
-          Pakyow.app.response.body << "<h4>#{CGI.escapeHTML(error.to_s)}</h4>"
-          Pakyow.app.response.body << error.backtrace.join("<br />")
-        end
-
-        begin
-          # caught by other middleware (e.g. logger)
-          throw :error, error
-        rescue ArgumentError
-        end
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module Pakyow
-  module Middleware
-    class Setup
-      def initialize(app)
-        @app = app
-      end
-
-      def call(env)
-        #TODO don't track r/r on app; pass through middleware instead (or call in a context that has access to current r/r)
-        Pakyow.app.setup_rr(env)
-        @app.call(env)
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-module Pakyow
-  class PresenterBase
-    def self.inherited(subclass)
-      Configuration::Base.app.presenter = subclass
-    end
-
-    def self.instance
-      @@instance ||= self.new
-    end
-  end
-end

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

@@ -1,77 +0,0 @@
-#TODO rename router to set and .func to .fn
-
-module Pakyow
-  class RouteTemplate
-    attr_accessor :path
-
-    def initialize(block, g_name, path, router)
-      @fns    = {}
-      @g_name = g_name
-      @path   = path
-      @router = router
-
-      self.instance_exec(&block)
-    end
-
-    def action(method, *args, &block)
-      fns = block_given? ? [block] : args[0]
-      @fns[method] = fns
-    end
-
-    def expand(template, data)
-      @expanding = true
-
-      t = self
-      if @path
-        @router.namespace(@path, @g_name) {
-          t.instance_exec(data, &template)
-        }
-      else
-        @router.group(@g_name) {
-          t.instance_exec(data, &template)
-        }
-      end
-    end
-
-    def fn(name)
-      @expanding ? @fns[name] : @router.func(name)
-    end
-
-    def call(controller, action)
-      @router.call(controller, action)
-    end
-
-    def get(*args, &block)
-      @router.get(*args, &block)
-    end
-
-    def put(*args, &block)
-      @router.put(*args, &block)
-    end
-
-    def post(*args, &block)
-      @router.post(*args, &block)
-    end
-
-    def delete(*args, &block)
-      @router.delete(*args, &block)
-    end
-
-    #TODO best name?
-    def map_actions(controller, actions)
-      actions.each { |a|
-        self.action(a, self.call(controller, a))
-      }
-    end
-
-    #TODO best name?
-    def map_restful_actions(controller)
-      self.map_actions(controller, self.restful_actions)
-    end
-
-    def restful_actions
-      [:index, :show, :new, :create, :edit, :update, :delete]
-    end
-  end
-end
-

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

@@ -1,36 +0,0 @@
-require 'fileutils'
-
-module Pakyow
-  module Generators
-    class AppGenerator
-      class << self
-        def start
-          case ARGV.first
-          when '--help', '-h', nil
-            puts File.open(File.join(CORE_PATH, 'commands/USAGE-NEW')).read
-          else
-            generator = self.new
-            generator.build(ARGV.first)
-          end
-        end
-      end
-      
-      def initialize
-        @src = "#{File.expand_path('../', __FILE__)}/templates/."
-      end
-      
-      def build(dest)
-        if !File.directory?(dest) || (Dir.entries(dest) - ['.', '..']).empty?
-          FileUtils.cp_r(@src, dest)
-        else
-          ARGV.clear
-          print "The folder '#{dest}' is in use. Would you like to populate it anyway? [Yn] "
-
-          if gets.chomp! == 'Y'
-            FileUtils.cp_r(@src, dest)
-          end
-        end
-      end
-    end
-  end
-end