halcyon 0.5.0 → 0.5.1

data/Rakefile

@@ -92,6 +92,11 @@ namespace 'spec' do
   task :verb do
     sh "bacon -r~/lib/bacon/output -rlib/halcyon -rspec/spec_helper spec/**/* -o CSpecDox"
   end
+  
+  desc "run single rspec verbosely (specify SPEC)"
+  task :select do
+    sh "bacon -r~/lib/bacon/output -rlib/halcyon -rspec/spec_helper spec/**/#{ENV['SPEC']}_spec.rb -o CSpecDox"
+  end
 end
 
 desc "Do predistribution stuff"

data/lib/halcyon.rb

@@ -11,57 +11,75 @@ $:.unshift File.dirname(__FILE__)
 #   Halcyon.config #=> {:allow_from => :all, :logging => {...}, ...}
 #   Halcyon.paths #=> {:config => Halcyon.root/'config', ...}
 #   Halcyon.logger #=> #<Logger>
-#   Halcyon.version #=> "0.5.0"
+#   Halcyon.version #=> "0.5.1"
+# 
 module Halcyon
   
-  VERSION = [0,5,0] unless defined?(Halcyon::VERSION)
+  VERSION = [0,5,1] unless defined?(Halcyon::VERSION)
   
   autoload :Application, 'halcyon/application'
   autoload :Client, 'halcyon/client'
+  autoload :Config, 'halcyon/config'
   autoload :Controller, 'halcyon/controller'
   autoload :Exceptions, 'halcyon/exceptions'
   autoload :Logging, 'halcyon/logging'
   autoload :Runner, 'halcyon/runner'
   
+  include Config::Helpers
+  
   class << self
     
-    attr_accessor :app
     attr_accessor :logger
-    attr_accessor :config
-    attr_accessor :paths
+    attr_writer :config
     
     def version
       VERSION.join('.')
     end
     
-    # The root directory of the current application.
+    # The default <tt>root</tt> setting, overwritten by a configuration helper.
+    # This is so that the paths can be loaded when first booting the app.
+    # This won't be necessary for certain cases where the paths the root is
+    # manually configured, but for all other cases it can cause problems.
     # 
-    # Returns String:root_directory
     def root
-      self.config[:root] || Dir.pwd rescue Dir.pwd
+      Dir.pwd
     end
     
-    def configurable(attribute)
-      eval <<-"end;"
-        def #{attribute.to_s}
-          Halcyon.config[:#{attribute.to_s}]
-        end
-        def #{attribute.to_s}=(value)
-          value = value.to_mash if value.is_a?(Hash)
-          Halcyon.config[:#{attribute.to_s}] = value
-        end
-      end;
+    # Configuration accessor which creates a configuration object when
+    # necessary.
+    # 
+    def config
+      @config ||= Halcyon::Config.new
+    end
+    
+    # Tests for Windows platform (to compensate for numerous Windows-specific
+    # bugs and oddities.)
+    # 
+    # Returns Boolean:is_windows
+    # 
+    def windows?
+      RUBY_PLATFORM =~ /mswin/
+    end
+    
+    # Tests for Linux platform.
+    # 
+    # Returns Boolean:is_linux
+    # 
+    def linux?
+      RUBY_PLATFORM =~ /linux/
     end
-    alias_method :configurable_attr, :configurable
     
   end
   
-  # Creates <tt>Halcyon.db</tt> to alias <tt>Halcyon.config[:db]</tt>.
-  # Also creates the complementary assignment method, <tt>Halcyon.db=</tt>
-  # that aliases <tt>Halcyon.config[:db]=</tt>.
-  configurable_attr :db
-  
 end
 
 # Include the klass#logger and klass.logger accessor methods into Object.
 Object.send(:include, Halcyon::Logging::Helpers)
+
+# The server-interface framework.
+# 
+module Rack
+  
+  autoload :JSONP, 'rack/jsonp'
+  
+end

data/lib/halcyon/application.rb

@@ -7,21 +7,13 @@ module Halcyon
   # Manages shutting down and starting up hooks, routing, dispatching, etc.
   # Also restricts the requests to acceptable clients, defaulting to all.
   # 
-  class Application 
-    include Exceptions
+  class Application
     
+    autoload :Hooks, 'halcyon/application/hooks'
     autoload :Router, 'halcyon/application/router'
     
-    attr_accessor :session
-    
-    DEFAULT_OPTIONS = {
-      :root => Dir.pwd,
-      :logging => {
-        :type => 'Logger',
-        :level => 'info'
-      },
-      :allow_from => :all
-    }.to_mash
+    include Exceptions
+    include Hooks
     
     # Initializes the app:
     # * runs startup hooks
@@ -30,7 +22,7 @@ module Halcyon
     def initialize
       self.logger.info "Starting up..."
       
-      self.hooks[:startup].call(Halcyon.config) if self.hooks[:startup]
+      Halcyon.hooks[:startup].each {|hook| hook.call(Halcyon.config) }
       
       # clean after ourselves and get prepared to start serving things
       self.logger.debug "Starting GC."
@@ -40,7 +32,7 @@ module Halcyon
       
       at_exit do
         self.logger.info "Shutting down #{$$}."
-        self.hooks[:shutdown].call(Halcyon.config) if self.hooks[:shutdown]
+        Halcyon.hooks[:shutdown].each {|hook| hook.call(Halcyon.config) }
         self.logger.info "Done."
       end
     end
@@ -92,11 +84,51 @@ module Halcyon
         self.logger.error "#{e.message}\n\t" << e.backtrace.join("\n\t")
       end
       
+      # This handles various sorts of response formats.
+      # 
+      # The primary format is <tt>{:status => 200, :body => ...}</tt> which
+      # also supports a <tt>:headers</tt> entity (also a Hash).
+      # 
+      # If this format is not followed, we assume they've just returned data so
+      # we package it up like normal and respond (for the user).
+      # 
+      # The one exception to the previous rule is if the data is in the
+      # standard response structure [200, {}, 'OK'] or some such, we construct
+      # the reply accordingly.
+      # 
+      response.status = 200 # we assume 200, but when specified get updated appropriately
+      result = case result
+      when Hash
+        if result[:status] and result[:body]
+          # {:status => 200, :body => 'OK'}
+          # no coercion necessary
+          result
+        else
+          # {*}
+          {:status => 200, :body => result}
+        end
+      when Array
+        if result[0].is_a?(Integer) and result[1].is_a?(Hash) and result[2]
+          # [200, {}, 'OK'] format followed
+          {:status => result[0], :headers => result[1], :body => result[2]}
+        else
+          # [*]
+          {:status => 200, :body => result}
+        end
+      else
+        # *
+        {:status => 200, :body => result}
+      end
+      # set response data
+      headers = result.delete(:headers) || {}
       response.status = result[:status]
+      headers.each {|(header,val)| response[header] = val }
       response.write result.to_json
       
       timing[:finished] = Time.now
-      timing[:total] = (((timing[:finished] - timing[:started])*1e4).round.to_f/1e4)
+      # the rescue is necessary if for some reason the timing is faster than
+      # system timing usec. this actually happens on Windows
+      timing[:total] = ((((timing[:finished] - timing[:started])*1e4).round.to_f/1e4) rescue 0.01)
       timing[:per_sec] = (((1.0/(timing[:total]))*1e2).round.to_f/1e2)
       
       self.logger.info "[#{response.status}] #{URI.parse(env['REQUEST_URI'] || env['PATH_INFO']).path} (#{timing[:total]}s;#{timing[:per_sec]}req/s)"
@@ -151,9 +183,34 @@ module Halcyon
       # if no errors have occured up to this point, the route should be fully
       # valid and all exceptions raised should be treated as
       # <tt>500 Internal Server Error</tt>s, which is handled by <tt>call</tt>.
-      controller.send(action)
+      controller._dispatch(action)
     end
     
+    # def apply_filters(where, controller, action)
+    #   self.logger.debug "Applying #{where.to_s} filters to #{controller.class.to_s}##{action.to_s}"
+    #   if controller.filters[:all].include?(action)
+    #     controller.filters[:all][action].select {|filter| filter[:apply] == where}.each do |filter|
+    #       if filter[:filter_or_block].is_a?(Proc)
+    #         filter[:filter_or_block].call
+    #       else
+    #         controller.send(filter[:filter_or_block])
+    #       end
+    #     end
+    #   end
+    #   if controller.filters[:only].include?(action)
+    #     controller.filters[:only][action].select {|filter| filter[:apply] == where && filter}.each do |filter|
+    #       controller.send(filter[:filter_or_block])
+    #     end
+    #   end
+    #   controller.filters[:except].each do |(filters_not_for_action, filters)|
+    #     unless filters_not_for_action == action
+    #       filters.each do |filter|
+    #         controller.send(filter[:filter_or_block])
+    #       end
+    #     end
+    #   end
+    # end
+    
     # Filters unacceptable requests depending on the configuration of the
     # <tt>:allow_from</tt> option.
     # 
@@ -193,22 +250,8 @@ module Halcyon
       request.params.merge(env['halcyon.route'])
     end
     
-    # See the documentation for generated apps in <tt>config/initialze/hooks.rb</tt>
-    # 
-    def hooks
-      self.class.hooks
-    end
-    
     class << self
       
-      attr_accessor :hooks
-      
-      # See the documentation for generated apps in <tt>config/initialze/hooks.rb</tt>
-      # 
-      def hooks
-        @hooks ||= {}
-      end
-      
       # Defines routes for the application.
       # 
       # Refer to Halcyon::Application::Router for documentation and resources.
@@ -221,23 +264,69 @@ module Halcyon
         end
       end
       
-      # Sets the startup hook to the proc.
-      # 
-      # Use this to initialize application-wide resources, such as database
-      # connections.
-      # 
-      # Use initializers where possible.
-      # 
-      def startup &hook
-        self.hooks[:startup] = hook
-      end
+      #--
+      # Boot Process
+      #++
       
-      # Sets the shutdown hook to the proc.
-      # 
-      # Close any resources opened in the +startup+ hook.
+      # Used to keep track of whether the boot process has been run yet.
+      attr_accessor :booted
+      
+      # Runs through the bootup process. This involves:
+      # * establishing configuration directives
+      # * loading required libraries
       # 
-      def shutdown &hook
-        self.hooks[:shutdown] = hook
+      def boot(&block)
+        Halcyon.config ||= Halcyon::Config.new
+        
+        # Set application name
+        Halcyon.app = Halcyon.config[:app] || Halcyon.root.split('/').last.camel_case
+        
+        # Load configuration files (when available)
+        Dir.glob(%w(config app).map{|conf|Halcyon.paths[:config]/conf+'.{yml,yaml}'}).each do |config_file|
+          Halcyon.config.load_from(config_file) if File.exist?(config_file)
+        end
+        
+        # Run configuration files (when available)
+        # These are unique in that they are Ruby files that we require so we
+        # can get rid of YAML config files and use Ruby configuration files.
+        Dir.glob(Halcyon.paths[:config]/'*.rb').each do |config_file|
+          require config_file
+        end
+        
+        # Yield to the block to handle boot configuration (and other tasks).
+        Halcyon.config.use(&block) if block_given?
+        
+        # Setup logger
+        if Halcyon.config[:logger]
+          Halcyon.config[:logging] = (Halcyon.config[:logging] || Halcyon::Config.defaults[:logging]).merge({
+            :type => Halcyon.config[:logger].class.to_s,
+            :logger => Halcyon.config[:logger]
+          })
+        end
+        Halcyon::Logging.set(Halcyon.config[:logging][:type])
+        Halcyon.logger = Halcyon::Logger.setup(Halcyon.config[:logging])
+        
+        # Run initializers
+        Dir.glob(%w(requires hooks routes *).map{|init|Halcyon.paths[:init]/init+'.rb'}).each do |initializer|
+          self.logger.debug "Init: #{File.basename(initializer).chomp('.rb').camel_case}" if
+          require initializer.chomp('.rb')
+        end
+        
+        # Setup autoloads for Controllers found in Halcyon.root/'app' (by default)
+        Dir.glob([Halcyon.paths[:controller]/'application.rb', Halcyon.paths[:controller]/'*.rb']).each do |controller|
+          self.logger.debug "Load: #{File.basename(controller).chomp('.rb').camel_case} Controller" if
+          require controller.chomp('.rb')
+        end
+        
+        # Setup autoloads for Models found in Halcyon.root/'app'/'models' (by default)
+        Dir.glob(Halcyon.paths[:model]/'*.rb').each do |model|
+          self.logger.debug "Load: #{File.basename(model).chomp('.rb').camel_case} Model" if
+          require model.chomp('.rb')
+        end
+        
+        # Set to loaded so additional calls to boot are ignored (unless
+        # forcefully loaded by ignoring this value).
+        self.booted = true
       end
       
     end

data/lib/halcyon/application/hooks.rb

@@ -0,0 +1,38 @@
+module Halcyon
+  class Application
+    
+    # Helper that provides access to setting and running hooks.
+    # 
+    module Hooks
+      
+      # Extends the target with the class methods necessary.
+      def self.included(target)
+        target.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        
+        # Sets the startup hook to the proc.
+        # 
+        # Use this to initialize application-wide resources, such as database
+        # connections.
+        # 
+        # Use initializers where possible.
+        # 
+        def startup &hook
+          Halcyon.hooks[:startup] << hook
+        end
+      
+        # Sets the shutdown hook to the proc.
+        # 
+        # Close any resources opened in the +startup+ hook.
+        # 
+        def shutdown &hook
+          Halcyon.hooks[:shutdown] << hook
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/halcyon/config.rb

@@ -0,0 +1,252 @@
+module Halcyon
+  
+  # Application configuration map.
+  # 
+  class Config
+    
+    attr_accessor :config
+    
+    autoload :Helpers, 'halcyon/config/helpers'
+    autoload :Paths, 'halcyon/config/paths'
+    autoload :File, 'halcyon/config/file'
+    
+    # Creates an empty configuration hash (Mash) and sets up the configuration
+    # to whatever the settings are provided, merging over the defaults.
+    # 
+    # Examples:
+    # 
+    #   Halcyon::Config.new(:environment => :development)
+    # 
+    # OR
+    # 
+    #   Halcyon::Config.new(:allow_from => :all)
+    # 
+    # OR
+    # 
+    #   Halcyon::Config.new
+    # 
+    # OR
+    # 
+    #   Halcyon::Config.new do |c|
+    #     c[:foo] = true
+    #   end
+    # 
+    def initialize(config={}, &block)
+      env = config.delete(:environment)
+      self.config = Mash.new
+      self.setup(self.defaults(env).merge(config))
+      self.use(&block) if block_given?
+    end
+    
+    # Sets the configuration up with the values given.
+    # 
+    def configure(config={})
+      config.each do |(key, val)|
+        self.config[key] = val
+      end
+    end
+    
+    # Sets up the configuration by storing the settings provided (via param or
+    # via block).
+    # 
+    # Usage:
+    # 
+    #   Halcyon.config.setup do |c|
+    #     c[:foo] = true
+    #   end
+    # 
+    # or
+    # 
+    #   Halcyon.config.setup(:foo => true)
+    # 
+    def setup(config={})
+      if block_given?
+        yield(self.config.dup)
+      end
+      # merge new settings
+      self.configure(config)
+    end
+    
+    # Yields and returns the configuration.
+    # 
+    # Examples:
+    # 
+    #   Halcyon.config.use do |c|
+    #     c[:foo] = true
+    #   end
+    # 
+    def use
+      if block_given?
+        yield self.config
+      end
+      self.config
+    end
+    
+    # Allows retrieval of single key config values and setting single config
+    # values.
+    # 
+    # Examples:
+    # 
+    #   Halcyon.config.app #=> 'AppName'
+    #   Halcyon.config[:app] #=> 'AppName'
+    # 
+    def method_missing(method, *args)
+      if method.to_s[-1,1] == '='
+        self.put(method.to_s.tr('=',''), *args)
+      else
+        self.get(method)
+      end
+    end
+    
+    # Get the configuration value associated with the key.
+    # 
+    # Examples:
+    # 
+    #   Halcyon.config.get(:app) #=> 'AppName'
+    # 
+    def get(key)
+      self.config[key]
+    end
+    
+    # Put the configuration value associated with the key or setup with a hash.
+    # 
+    # Examples:
+    # 
+    #   Halcyon.config.put(:app, 'AppName')
+    # 
+    # OR
+    # 
+    #   Halcyon.config.put(:app => 'AppName')
+    # 
+    def put(key_or_config_hash, value = nil)
+      if value.nil? and key_or_config_hash.is_a?(Hash)
+        self.configure(key_or_config_hash)
+      else
+        self.config[key_or_config_hash] = value
+      end
+    end
+    
+    # Removes the configuration value from the hash.
+    # 
+    # Examples:
+    # 
+    #   Halcyon.config.delete(:app) #=> 'AppName'
+    # 
+    def delete(key)
+      self.config.delete(key)
+    end
+    
+    # Alias for the <tt>get</tt> method.
+    # 
+    # Examples:
+    # 
+    #   Halcyon.config[:foo] #=> true
+    # 
+    def [](key)
+      self.get(key)
+    end
+    
+    # Alias for the <tt>put</tt> method. (Restricted to the key/value pair.)
+    # 
+    # Examples:
+    # 
+    #   Halcyon.config[:foo] = true
+    # 
+    def []=(key, value)
+      self.put(key, value)
+    end
+    
+    # Returns the configuration rendered as YAML.
+    # 
+    def to_yaml
+      require 'yaml'
+      self.config.to_hash.to_yaml
+    end
+    
+    # Returns the configuration as a hash.
+    # 
+    def to_hash
+      self.config.to_hash
+    end
+    
+    # Shortcut for Halcyon::Config.defaults.
+    # 
+    def defaults(env = nil)
+      Halcyon::Config.defaults(env)
+    end
+    
+    # Loads the contents of a configuration file found at <tt>path</tt> and
+    # merges it with the current configuration.
+    # 
+    def load_from(path)
+      self.configure(Halcyon::Config::File.load(path))
+      self
+    end
+    
+    def inspect
+      attrs = ""
+      self.config.keys.each {|key| attrs << " #{key}=#{self.config[key].inspect}"}
+      "#<Halcyon::Config#{attrs}>"
+    end
+    
+    class << self
+      
+      # Default configuration values.
+      # 
+      # Defaults to the configuration for <tt>:development</tt>.
+      # 
+      def defaults(env = nil)
+        base = {
+          :app => nil,
+          :root => Dir.pwd,
+          :environment => :development,
+          :allow_from => 'all',
+          :logging => {
+            :type => 'Logger',
+            :level => 'debug'
+          },
+          :paths => Paths.new,
+          :hooks => Hash.new([])
+        }
+        case (env || :development)
+        when :development
+          base.merge({
+            :environment => :development
+          })
+        when :test
+          base.merge({
+            :app => 'Specs',
+            :environment => :test,
+            :logging => {
+              :type => 'Logger',
+              :level => 'warn',
+              :file => 'log/test.log'
+            }
+          })
+        when :console
+          base.merge({
+            :environment => :console
+          })
+        when :production
+          base.merge({
+            :environment => :production,
+            :logging => {
+              :type => 'Logger',
+              :level => 'warn',
+              :file => 'log/production.log'
+            }
+          })
+        end
+      end
+      
+      # Loads the contents of a configuration file found at <tt>path</tt>.
+      # 
+      def load_from(path)
+        Halcyon::Config::File.load(path)
+      end
+      
+    end
+    
+  end
+  
+end