halcyon 0.5.0 → 0.5.1

data/lib/halcyon/exceptions.rb

@@ -95,8 +95,9 @@ module Halcyon
       status, body = http_status
       class_eval <<-"end;"
         class #{body.gsub(/( |\-)/,'')} < Halcyon::Exceptions::Base
-          def initialize(s=#{status}, b='#{body}')
-            super
+          def initialize(body=nil)
+            body = '#{body}' if body.nil?
+            super(#{status}, body)
           end
         end
       end;

data/lib/halcyon/runner.rb

@@ -4,6 +4,7 @@ module Halcyon
   # * setting up the logger
   # * loading initializers
   # * loading controllers
+  # All of which is done by the call to <tt>Halcyon::Application.boot</tt>.
   # 
   # The Runner is a full-fledged Rack application, and accepts calls to #call.
   # 
@@ -14,70 +15,14 @@ module Halcyon
   #   Halcyon::Runner.run!(['start', '-p', '4647'])
   #   
   #   # load the config file and initialize the app
-  #   Halcyon::Runner.load_config Halcyon.root/'config'/'config.yml'
   #   Halcyon::Runner.new
   class Runner
     
     autoload :Commands, 'halcyon/runner/commands'
     
-    class << self
-      
-      # Runs commands from the CLI.
-      #   +argv+ the arguments to pass to the commands
-      # 
-      # Returns nothing
-      def run!(argv=ARGV)
-        Commands.send(argv.shift, argv)
-      end
-      
-      # Returns the path to the configuration file specified, defaulting
-      # to the path for the <tt>config.yml</tt> file.
-      #   +file+ the name of the config file path (without the <tt>.yml</tt>
-      #   extension)
-      def config_path(file = "config")
-        Halcyon.paths[:config]/"#{file}.yml"
-      end
-      
-    end
-    
     # Initializes the application and application resources.
-    def initialize
-      Halcyon::Runner.load_paths if Halcyon.paths.nil?
-      
-      # Load the configuration if none is set already
-      if Halcyon.config.nil?
-        if File.exist?(Halcyon::Runner.config_path)
-          Halcyon.config = Halcyon::Runner.load_config
-        else
-          Halcon.config = Halcyon::Application::DEFAULT_OPTIONS
-        end
-      end
-      
-      # Set application name
-      Halcyon.app = Halcyon.config[:app] || Halcyon.root.split('/').last.camel_case
-      
-      # Setup logger
-      if Halcyon.config[:logger]
-        Halcyon.config[:logging] = (Halcyon.config[:logging] || Halcyon::Application::DEFAULT_OPTIONS[:logging]).merge({
-          :type => Halcyon.config[:logger].class.to_s,
-          :logger => Halcyon.config[:logger]
-        })
-      end
-      Halcyon::Logging.set((Halcyon.config[:logging][:type] rescue nil))
-      Halcyon.logger = Halcyon::Logger.setup(Halcyon.config[:logging])
-      
-      # Run initializers
-      Dir.glob(Halcyon.paths[:init]/'{requires,hooks,routes,environment,*}.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'
-      Dir.glob(Halcyon.paths[:controller]/'{application,*}.rb').each do |controller|
-        self.logger.debug "Load: #{File.basename(controller).chomp('.rb').camel_case} Controller" if
-        require controller.chomp('.rb')
-      end
-      
+    def initialize(&block)
+      Halcyon::Application.boot(&block) unless Halcyon::Application.booted
       @app = Halcyon::Application.new
     end
     
@@ -91,48 +36,12 @@ module Halcyon
     
     class << self
       
-      # Loads the configuration file specified into <tt>Halcyon.config</tt>.
-      #   +file+ the configuration file to load
-      # 
-      # Examples
-      #   Halcyon::Runner.load_config Halcyon.root/'config'/'config.yml'
-      #   Halcyon.config #=> {:allow_from => :all, :logging => {...}, ...}.to_mash
-      # 
-      # Returns {Symbol:key => String:value}.to_mash
-      def load_config(file=Halcyon::Runner.config_path)
-        if File.exist?(file)
-          require 'yaml'
-          
-          # load the config file
-          begin
-            config = YAML.load_file(file).to_mash
-          rescue Errno::EACCES
-            raise LoadError.new("Can't access #{file}, try 'sudo #{$0}'")
-          end
-        else
-          warn "#{file} not found, ensure the path to this file is correct. Ignoring."
-          nil
-        end
-      end
-      
-      # Set the paths for resources to be located.
-      # 
-      # Used internally for setting the load paths if not manually overridden
-      # and needed to be set before normal application initialization.
-      # 
-      # TODO: Move this to the planned <tt>Halcyon::Config</tt> object.
+      # Runs commands from the CLI.
+      #   +argv+ the arguments to pass to the commands
       # 
-      # Returns nothing.
-      def load_paths
-        # Set the default application paths, not overwriting manually set paths
-        Halcyon.paths = {
-          :controller => Halcyon.root/'app',
-          :model => Halcyon.root/'app'/'models',
-          :lib => Halcyon.root/'lib',
-          :config => Halcyon.root/'config',
-          :init => Halcyon.root/'config'/'{init,initialize}',
-          :log => Halcyon.root/'log'
-        }.to_mash.merge(Halcyon.paths || {})
+      # Returns nothing
+      def run!(argv=ARGV)
+        Commands.send(argv.shift, argv)
       end
       
     end

data/lib/halcyon/runner/commands.rb

@@ -63,10 +63,9 @@ module Halcyon
           # Set up the application
           Object.instance_eval do
             $log = ''
-            Halcyon::Runner.load_paths if Halcyon.paths.nil?
-            (Halcyon.config = Halcyon::Runner.load_config) || require(Halcyon.root/'app')
-            Halcyon.config[:logger] = Logger.new(StringIO.new($log))
-            $app = Halcyon::Runner.new
+            $app = Halcyon::Runner.new do |c|
+              c[:logger] = Logger.new(StringIO.new($log))
+            end
             $response = nil
           end
           

data/lib/rack/jsonp.rb

@@ -0,0 +1,38 @@
+module Rack
+  
+  # A Rack middleware for providing JSON-P support.
+  # 
+  # Full credit to Flinn Mueller (http://actsasflinn.com/) for this contribution.
+  # 
+  class JSONP
+    
+    def initialize(app)
+      @app = app
+    end
+    
+    # Proxies the request to the application, stripping out the JSON-P callback
+    # method and padding the response with the appropriate callback format.
+    # 
+    # Changes nothing if no <tt>callback</tt> param is specified.
+    # 
+    def call(env)
+      status, headers, response = @app.call(env)
+      request = Rack::Request.new(env)
+      response = pad(request.params.delete('callback'), response) if request.params.include?('callback')
+      [status, headers, response]
+    end
+    
+    # Pads the response with the appropriate callback format according to the
+    # JSON-P spec/requirements.
+    # 
+    # The Rack response spec indicates that it should be enumerable. The method
+    # of combining all of the data into a sinle string makes sense since JSON
+    # is returned as a full string.
+    # 
+    def pad(callback, response, body = "")
+      response.each{ |s| body << s }
+      "#{callback}(#{body})" 
+    end
+    
+  end
+end

data/spec/halcyon/application_spec.rb

@@ -3,10 +3,9 @@ describe "Halcyon::Application" do
   before do
     @log = ''
     @logger = Logger.new(StringIO.new(@log))
-    @config = $config.dup
-    @config[:logger] = @logger
-    @config[:app] = 'Specs'
-    Halcyon.config = @config
+    Halcyon.config.use do |c|
+      c[:logger] = @logger
+    end
     @app = Halcyon::Runner.new
   end
   
@@ -17,7 +16,7 @@ describe "Halcyon::Application" do
   
   it "should dispatch methods according to their respective routes" do
     Rack::MockRequest.new(@app).get("/hello/Matt")
-    @log.should =~ / INFO \[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] \(\d+\) Specs :: \[200\] \/hello\/Matt \(.+\)\n/
+    $hello.should == "Matt"
   end
   
   it "should handle requests and respond with JSON" do
@@ -26,13 +25,6 @@ describe "Halcyon::Application" do
     body['body'].should == "Found"
   end
   
-  it "should handle requests with param values in the URL" do
-    body = JSON.parse(Rack::MockRequest.new(@app).get("/hello/Matt?test=value").body)
-    body['status'].should == 200
-    body['body'].should == "Hello Matt"
-    @log.split("\n").last.should =~ /"test"=>"value"/
-  end
-  
   it "should not dispatch private methods" do
     body = JSON.parse(Rack::MockRequest.new(@app).get("/specs/undispatchable_private_method").body)
     body['status'].should == 404
@@ -47,12 +39,14 @@ describe "Halcyon::Application" do
   
   it "should log activity" do
     Halcyon.logger.is_a?(Logger).should.be.true?
-    Rack::MockRequest.new(@app).get("/lolcats/r/cute")
-    @log.should =~ / INFO \[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] \(\d+\) Specs :: \[404\] \/lolcats\/r\/cute \(.+\)\n/
+    # Rack::MockRequest.new(@app).get("/lolcats/r/cute")
+    # @log.should =~ / INFO \[\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}\] \(\d+\) Specs :: \[404\] \/lolcats\/r\/cute \(.+\)\n/
+    # Halcyon.logger.debug "Testing"
+    # @log.should =~ /Testing/
   end
   
   it "should allow all requests by default" do
-    Halcyon.config[:allow_from].should == :all
+    Halcyon.config[:allow_from].to_sym.should == :all
   end
   
   it "should handle exceptions gracefully" do

data/spec/halcyon/config_spec.rb

@@ -0,0 +1,157 @@
+describe "Halcyon::Config" do
+  
+  before do
+    Halcyon.config = Halcyon::Config.new(:environment => :test)
+    # @log = ''
+    # @logger = Logger.new(StringIO.new(@log))
+    # @config = $config.dup
+    # @config[:logger] = @logger
+    # @config[:app] = 'Specs'
+    # Halcyon.config = @config
+    # @app = Halcyon::Runner.new
+  end
+  
+  it "should provide the path of the application root directory" do
+    Halcyon.root.should == Dir.pwd
+    Halcyon.config[:root] = Dir.pwd
+    Halcyon.root.should == Halcyon.config[:root]
+  end
+  
+  it "should provide numerous ways to retrieve configuration values" do
+    Halcyon.config[:foo] = :bar
+    
+    Halcyon.config[:foo].should == :bar
+    Halcyon.config.foo.should == :bar
+    Halcyon.config.get(:foo).should == :bar
+    Halcyon.config.use {|c| c[:foo].should == :bar }
+  end
+  
+  it "should provide numerous ways to set configuration values" do
+    Halcyon.config[:foo] = :a; Halcyon.config[:foo].should == :a
+    Halcyon.config.foo = :b; Halcyon.config[:foo].should == :b
+    Halcyon.config.put(:foo, :c); Halcyon.config[:foo].should == :c
+    Halcyon.config.put(:foo => :d); Halcyon.config[:foo].should == :d
+    Halcyon.config.use {|c| c[:foo] = :e }; Halcyon.config[:foo].should == :e
+  end
+  
+  it "should access to major config values through Halcyon.<attr> accessors" do
+    Halcyon.config.use do |c|
+      c[:app] = "Specr"
+      c[:root] = Dir.pwd
+      c[:paths] = Halcyon::Config::Paths.new
+      c[:db] = Mash.new(:test => Mash.new)
+      c[:environment] = :test
+    end
+    
+    Halcyon.app.should == Halcyon.config[:app]
+    Halcyon.root.should == (Halcyon.config[:root] || Dir.pwd)
+    Halcyon.paths.should == Halcyon.config[:paths]
+    Halcyon.db.should == Halcyon.config[:db]
+    Halcyon.environment.should == Halcyon.config[:environment]
+  end
+  
+  it "should provide custom Halcyon.<attr> accessors interfacing config values" do
+    Halcyon.configurable_attr(:foo)
+    Halcyon.foo = true
+    Halcyon.foo.should == Halcyon.config[:foo]
+    
+    Halcyon.configurable_reader(:bar) do
+      Halcyon.config[:bar].to_sym
+    end
+    Halcyon.config[:bar] = "foo"
+    Halcyon.bar.should == :foo
+    
+    Halcyon.configurable_reader(:baz, "Halcyon.config[%s].to_sym")
+    Halcyon.config[:baz] = "bar"
+    Halcyon.baz.should == :bar
+    
+    Halcyon.configurable_writer(:bing) do |value|
+      Halcyon.config[:bing] = value.to_sym
+    end
+    Halcyon.bing = "foo"
+    Halcyon.config[:bing].should == :foo
+    
+    Halcyon.configurable_writer(:bong, "Halcyon.config[%s] = value.to_sym")
+    Halcyon.bong = "bar"
+    Halcyon.config[:bong].should == :bar
+  end
+  
+  # it "should ..." do
+  #   #
+  # end
+  
+end
+
+describe "Halcyon::Config::Paths" do
+  
+  before do
+    @paths = Halcyon::Config::Paths.new
+  end
+  
+  it "should be able to look up paths by name" do
+    @paths.for(:config).should == Halcyon.root/'config'
+  end
+  
+  it "should be able to define new paths" do
+    @paths.define(:foo => Halcyon.root/'bar', :bar => Halcyon.root/'foo')
+    @paths.for(:foo).should == Halcyon.root/'bar'
+    @paths.for(:bar).should == Halcyon.root/'foo'
+  end
+  
+  it "should be able to define new paths by name" do
+    @paths.define(:foo, Halcyon.root/'baz')
+    @paths.for(:foo).should == Halcyon.root/'baz'
+  end
+  
+  it "should provide a shortcut to look up paths by name" do
+    @paths[:config].should == @paths.for(:config)
+  end
+  
+  it "should provide a shortcut to define new paths by name" do
+    @paths[:config] = Halcyon.root/'gifnoc'
+    @paths.for(:config).should == Halcyon.root/'gifnoc'
+  end
+  
+  it "should raise an ArgumentError if a nonexistent path is queried for" do
+    should.raise(ArgumentError) { @paths.for(:nonexistent_path) }
+  end
+  
+end
+
+require 'tmpdir'
+require 'yaml'
+describe "Halcyon::Config::File" do
+  
+  before do
+    @config = {
+      :allow_from => "all",
+      :logging => {
+        :type => "Logger",
+        :level => "debug"
+      },
+      :root => Dir.pwd,
+      :app => "Specr",
+      :environment => "development"
+    }.to_mash
+    File.open(Dir.tmpdir/'config.yaml', 'w+'){|f| f << @config.to_yaml }
+    File.open(Dir.tmpdir/'config.json', 'w+'){|f| f << @config.to_json }
+  end
+  
+  it "should load the configuration from the YAML config file" do
+    Halcyon::Config::File.new(Dir.tmpdir/'config.yaml').to_hash.should == @config
+  end
+  
+  it "should load the configuration from the JSON config file" do
+    Halcyon::Config::File.new(Dir.tmpdir/'config.json').to_hash(:from_json).should == @config
+  end
+  
+  it "should provide shortcuts for loading configuration files" do
+    Halcyon::Config::File.load(Dir.tmpdir/'config.yaml').should == @config
+    Halcyon::Config::File.load_from_json(Dir.tmpdir/'config.json')
+  end
+  
+  it "should throw an ArgumentError when the config file doesn't exist" do
+    should.raise(ArgumentError) { Halcyon::Config::File.load('/path/to/nonexistent/file.yalm') }
+  end
+  
+end

data/spec/halcyon/controller_spec.rb

@@ -3,22 +3,39 @@ describe "Halcyon::Controller" do
   before do
     @log = ''
     @logger = Logger.new(StringIO.new(@log))
-    @config = $config.dup
-    @config[:logger] = @logger
-    @config[:app] = 'Specs'
-    Halcyon.config = @config
+    Halcyon.config.use do |c|
+      c[:logger] = @logger
+    end
     @app = Halcyon::Runner.new
   end
   
   it "should provide various shorthand methods for simple responses but take custom response values" do
     controller = Specs.new(Rack::MockRequest.env_for('/'))
     
-    response = {:status => 200, :body => 'OK'}
+    response = {:status => 200, :body => 'OK', :headers => {}}
     controller.ok.should == response
     controller.success.should == response
     
-    controller.ok('').should == {:status => 200, :body => ''}
-    controller.ok(['OK', 'Sure Thang', 'Correcto']).should == {:status => 200, :body => ['OK', 'Sure Thang', 'Correcto']}
+    controller.ok('').should == {:status => 200, :body => '', :headers => {}}
+    controller.ok(['OK', 'Sure Thang', 'Correcto']).should == {:status => 200, :body => ['OK', 'Sure Thang', 'Correcto'], :headers => {}}
+    
+    headers = {'Date' => Time.now.strftime("%a, %d %h %Y %H:%I:%S %Z"), 'Test' => 'FooBar'}
+    controller.ok('OK', headers).should == {:status => 200, :body => 'OK', :headers => headers}
+  end
+  
+  it "should provide extensive responders" do
+    controller = Specs.new(Rack::MockRequest.env_for('/'))
+    
+    should.raise(Halcyon::Exceptions::UnprocessableEntity) { controller.status(:unprocessable_entity) }
+    response = Rack::MockRequest.new(@app).get("/specs/unprocessable_entity_test")
+    response.body.should =~ %r{Unprocessable Entity}
+    
+    should.raise(Halcyon::Exceptions::UnprocessableEntity) { controller.status(:unprocessable_entity) }
+  end
+  
+  it "should indicate service is unavailable if an status specified is not found" do
+    controller = Specs.new(Rack::MockRequest.env_for('/'))
+    should.raise(Halcyon::Exceptions::ServiceUnavailable) { controller.status(:this_state_does_not_exist) }
   end
   
   it "should provide a quick way to find out what method the request was performed using" do
@@ -52,17 +69,59 @@ describe "Halcyon::Controller" do
     controller = Specs.new(Rack::MockRequest.env_for(""))
     controller.uri.should == '/'
   end
-
-  it 'should provide url accessor for resource index route' do
+  
+  it "should provide url accessor for resource index route" do
     controller = Resources.new(Rack::MockRequest.env_for("/resources"))
     controller.uri.should == controller.url(:resources)
   end
-
-  it 'should provide url accessor for resource show route' do
+  
+  it "should provide url accessor for resource show route" do
     resource = Model.new
     resource.id = 1
     controller = Resources.new(Rack::MockRequest.env_for("/resources/1"))
     controller.uri.should == controller.url(:resource, resource)
   end
   
+  it "should accept response headers" do
+    controller = Specs.new(Rack::MockRequest.env_for(""))
+    headers = {'Date' => Time.now.strftime("%a, %d %h %Y %H:%I:%S %Z"), 'Foo' => 'Bar'}
+    controller.ok('OK', headers).should == {:status => 200, :body => 'OK', :headers => headers}
+    controller.ok('OK').should == {:status => 200, :body => 'OK', :headers => {}}
+    
+    response = Rack::MockRequest.new(@app).get("/goob")
+    response['Date'].should == Time.now.strftime("%a, %d %h %Y %H:%I:%S %Z")
+    response['Content-Language'].should == 'en'
+  end
+  
+  it "should handle return values from actions not from the response helpers" do
+    {
+      'OK' => {'status' => 200, 'body' => 'OK'},
+      [200, {}, 'OK'] => {'status' => 200, 'body' => 'OK'},
+      [1, 2, 3] => {'status' => 200, 'body' => [1, 2, 3]},
+      {'foo' => 'bar'} => {'status' => 200, 'body' => {'foo' => 'bar'}}
+    }.each do |(value, expected)|
+      $return_value_for_gaff = value
+      response = JSON.parse(Rack::MockRequest.new(@app).get("/gaff").body).should == expected
+    end
+  end
+  
+  it "should run filters before or after actions" do
+    response = Rack::MockRequest.new(@app).get("/index")
+    response.body.should =~ %r{Found}
+    
+    # The Accepted exception is raised if +cause_exception_in_filter+ is set
+    response = Rack::MockRequest.new(@app).get("/index?cause_exception_in_filter=true")
+    response.body.should =~ %r{Accepted}
+    
+    response = Rack::MockRequest.new(@app).get("/foobar")
+    response.body.should =~ %r{fubr}
+    
+    # The Created exception is raised if +cause_exception_in_filter+ is set
+    response = Rack::MockRequest.new(@app).get("/foobar?cause_exception_in_filter=true")
+    response.body.should =~ %r{Created}
+    
+    response = Rack::MockRequest.new(@app).get("/hello/Matt?cause_exception_in_filter_block=true")
+    response.body.should =~ %r{Not Found}
+  end
+  
 end