halcyon 0.4.0 → 0.5.0

data/lib/halcyon/logging/log4r.rb

@@ -0,0 +1,25 @@
+require 'log4r'
+include Log4r
+module Halcyon
+  module Logging
+    class Log4r < Log4r::Logger
+      
+      class << self
+        
+        def setup(config)
+          logger = self.new(config[:label] || Halcyon.app)
+          if config[:file]
+            logger.outputters = Log4r::FileOutputter.new(:filename => config[:file])
+          else
+            logger.outputters = Log4r::Outputter.stdout
+          end
+          logger.level = Object.const_get((config[:level] || 'debug').upcase.to_sym)
+          logger.outputters[0].formatter = Log4r::PatternFormatter.new(:pattern => "%5l [%d] (#{$$}) #{Halcyon.app} :: %m\n", :date_pattern => "%Y-%m-%d %H:%M:%S")
+          logger
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/halcyon/logging/logger.rb

@@ -0,0 +1,20 @@
+require 'logger'
+module Halcyon
+  module Logging
+    class Logger < ::Logger
+      
+      class << self
+        
+        def setup(config)
+          logger = config[:logger] || self.new(config[:file] || STDOUT)
+          logger.formatter = proc{|s,t,p,m|"%5s [%s] (%s) %s :: %s\n" % [s, t.strftime("%Y-%m-%d %H:%M:%S"), $$, p, m]}
+          logger.progname = Halcyon.app
+          logger.level = Logger.const_get((config[:level] || 'info').upcase)
+          logger
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/halcyon/logging/logging.rb

@@ -0,0 +1,19 @@
+require 'logging'
+module Halcyon
+  module Logging
+    class Logging < Logging::Logger
+      
+      class << self
+        
+        def setup(config)
+          logger = config[:logger] || ::Logging.logger(config[:file] || STDOUT)
+          logger.level = config[:level].downcase.to_sym
+          logger.instance_variable_get("@appenders")[0].instance_variable_set("@layout", ::Logging::Layouts::Pattern.new(:pattern => "%5l [%d] (%p) #{Halcyon.app} :: %m\n", :date_pattern => "%Y-%m-%d %H:%M:%S"))
+          logger
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/halcyon/runner.rb

@@ -0,0 +1,141 @@
+module Halcyon
+  
+  # Handles initializing and running the application, including:
+  # * setting up the logger
+  # * loading initializers
+  # * loading controllers
+  # 
+  # The Runner is a full-fledged Rack application, and accepts calls to #call.
+  # 
+  # Also handles running commands form the command line.
+  # 
+  # Examples
+  #   # start serving the current app (in .)
+  #   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
+      
+      @app = Halcyon::Application.new
+    end
+    
+    # Calls the application, which gets proxied to the dispatcher.
+    #   +env+ the request environment details
+    # 
+    # Returns [Fixnum:status, {String:header => String:value}, [String:body]]
+    def call(env)
+      @app.call(env)
+    end
+    
+    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.
+      # 
+      # 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 || {})
+      end
+      
+    end
+    
+  end
+end

data/lib/halcyon/runner/commands.rb

@@ -0,0 +1,141 @@
+require 'optparse'
+
+module Halcyon
+  class Runner
+    
+    autoload :Helpers, 'halcyon/runner/helpers'
+    
+    class Commands
+      class << self
+        
+        # Run the Halcyon application
+        def start(argv)
+          options = {
+            :port => 4647,
+            :server => (Gem.searcher.find('thin').nil? ? 'mongrel' : 'thin')
+          }
+          
+          OptionParser.new do |opts|
+            opts.banner = "Usage: halcyon start [options]"
+            
+            opts.separator ""
+            opts.separator "Start options:"
+            opts.on("-s", "--server SERVER", "") { |server| options[:server] = server }
+            
+            begin
+              opts.parse! argv
+            rescue OptionParser::InvalidOption => e
+              # the other options can be used elsewhere, like in RubiGen
+              argv = e.recover(argv)
+            end
+          end
+          
+          if options[:server] == 'thin'
+            # Thin is installed
+            command = "thin start -R runner.ru #{argv.join(' ')}"
+          else
+            # Thin is not installed
+            command = "rackup runner.ru -s #{options[:server]} #{argv.join(' ')}"
+          end
+          
+          # run command
+          exec command
+        end
+        
+        # Start the Halcyon server up in interactive mode
+        def console(argv)
+          # Notify user of environment
+          puts "(Starting Halcyon app in console...)"
+          
+          # Add ./lib to load path
+          $:.unshift(Halcyon.root/'lib')
+          
+          # prepare environment for IRB
+          ARGV.clear
+          require 'rack/mock'
+          require 'logger'
+          require 'irb'
+          require 'irb/completion'
+          if File.exists? '.irbrc'
+            ENV['IRBRC'] = '.irbrc'
+          end
+          
+          # 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
+            $response = nil
+          end
+          
+          # Setup helper methods
+          Object.send(:include, Halcyon::Runner::Helpers::CommandHelper)
+          
+          # Let users know what methods and values are available
+          puts "Call #usage for usage details."
+          
+          # Start IRB session
+          IRB.start
+          
+          exit
+        end
+        alias_method :interactive, :console
+        alias_method :irb, :console
+        alias_method :"-i", :console
+        
+        # Generate a new Halcyon application
+        def init(argv)
+          app_name = argv.last
+          
+          options = {
+            :generator => 'halcyon',
+            :git => false
+          }
+          
+          OptionParser.new do |opts|
+            opts.banner = "Usage: halcyon init [options]"
+            
+            opts.separator ""
+            opts.separator "Generator options:"
+            opts.on("-f", "--flat", "") { options[:generator] = 'halcyon_flat' }
+            
+            opts.separator ""
+            opts.separator "Additional options:"
+            opts.on("-g", "--git", "Initialize a Git repository when finished generating") { options[:git] = true }
+            opts.on("-G", "--git-commit", "Initialize a Git repo and commit") { options[:git] = options[:git_commit] = true }
+            
+            begin
+              opts.parse! argv
+            rescue OptionParser::InvalidOption => e
+              # the other options can be used elsewhere, like in RubiGen
+            end
+          end
+          
+          require 'rubigen'
+          require 'rubigen/scripts/generate'
+          RubiGen::Base.use_application_sources!
+          RubiGen::Base.sources << RubiGen::PathSource.new(:custom, File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', "support/generators")))
+          RubiGen::Scripts::Generate.new.run(argv, :generator => options[:generator])
+          
+          # Create a Git repository in the new app dir
+          if options[:git]
+            system("cd #{app_name} && git init -q && cd #{Dir.pwd}")
+            puts "Initialized Git repository in #{app_name}/"
+            File.open(File.join("#{app_name}",'.gitignore'),"w") {|f| f << "log/*.log" }
+            File.open(File.join("#{app_name}",'log','.gitignore'),"w") {|f| f << "" }
+          end
+          
+          # commit to the git repo
+          if options[:git_commit]
+            system("cd #{app_name} && git add . && git commit -m 'Initial import.' -q && cd #{Dir.pwd}")
+            puts "Committed empty application in #{app_name}/"
+            puts "Run `git commit --amend` to change the commit message."
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/halcyon/runner/helpers.rb

@@ -0,0 +1,9 @@
+module Halcyon
+  class Runner
+    class Helpers
+      
+      autoload :CommandHelper, 'halcyon/runner/helpers/command_helper'
+      
+    end
+  end
+end

data/lib/halcyon/runner/helpers/command_helper.rb

@@ -0,0 +1,71 @@
+module Halcyon
+  class Runner
+    class Helpers
+      module CommandHelper
+        
+        def usage
+          msg = <<-"end;"
+            
+            These methods will provide you with most of the
+            functionality you will need to test your app.
+            
+            #app      The loaded application
+            #log      The contents of the log (Ex: puts log)
+            #tail     The tail end of the log (Ex: tail)
+            #clear    Clears the log          (Ex: clear)
+            #get      Sends a GET request to the app
+                      Ex: get '/controller/action'
+            #post     Sends a POST request to #app
+                      Ex: post '/controller/action', :key => value
+            #put      See #post
+            #delete   See #get
+            #response Response of the last request
+            
+          end;
+          puts msg.gsub(/^[ ]{12}/, '')
+        end
+        
+        def app
+          $app
+        end
+        
+        def log
+          $log
+        end
+        
+        def tail
+          puts $log.split("\n").reverse[0..5].reverse.join("\n")
+        end
+        
+        def clear
+          $log = ''
+        end
+        
+        def get(path)
+          $response = Rack::MockRequest.new($app).get(path)
+          JSON.parse($response.body)
+        end
+        
+        def post(path, params = {})
+          $response = Rack::MockRequest.new($app).post(path, :input => params.to_params)
+          JSON.parse($response.body)
+        end
+        
+        def put(path, params = {})
+          $response = Rack::MockRequest.new($app).put(path, :input => params.to_params)
+          JSON.parse($response.body)
+        end
+        
+        def delete(path)
+          $response = Rack::MockRequest.new($app).delete(path)
+          JSON.parse($response.body)
+        end
+        
+        def response
+          $response
+        end
+        
+      end
+    end
+  end
+end

data/spec/halcyon/application_spec.rb

@@ -0,0 +1,70 @@
+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
+    @app = Halcyon::Runner.new
+  end
+  
+  it "should run startup hook if defined" do
+    # $started is set by the startup hook
+    $started.should.be.true?
+  end
+  
+  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/
+  end
+  
+  it "should handle requests and respond with JSON" do
+    body = JSON.parse(Rack::MockRequest.new(@app).get("/").body)
+    body['status'].should == 200
+    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
+    body['body'].should == "Not Found"
+  end
+  
+  it "should route unmatchable requests to the default route and return JSON with appropriate status" do
+    body = JSON.parse(Rack::MockRequest.new(@app).get("/garbage/request/url").body)
+    body['status'].should == 404
+    body['body'].should == "Not Found"
+  end
+  
+  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/
+  end
+  
+  it "should allow all requests by default" do
+    Halcyon.config[:allow_from].should == :all
+  end
+  
+  it "should handle exceptions gracefully" do
+    body = JSON.parse(Rack::MockRequest.new(@app).get("/specs/cause_exception").body)
+    body['status'].should == 500
+    body['body'].should == "Internal Server Error"
+  end
+  
+  it "should not confuse a NoMethodFound error in an action as a missing route" do
+    body = JSON.parse(Rack::MockRequest.new(@app).get("/specs/call_nonexistent_method").body)
+    body['status'].should.not == 404
+    body['body'].should == "Internal Server Error"
+  end
+  
+end