merb-core 0.9.2

data/lib/merb-core/plugins.rb

@@ -0,0 +1,25 @@
+module Merb
+  
+  module Plugins
+
+    # ==== Returns
+    # Hash::
+    #   The configuration loaded from Merb.root / "config/plugins.yml" or, if
+    #   the load fails, an empty hash.
+    def self.config
+      @config ||= File.exists?(Merb.root / "config" / "plugins.yml") ? YAML.load(File.read(Merb.root / "config" / "plugins.yml")) || {} : {}
+    end
+    
+    # ==== Returns
+    # Array:: All Rakefiles for plugins.
+    def self.rakefiles
+      Merb.rakefiles
+    end
+
+    # ==== Parameters
+    # *rakefiles:: Rakefiles to add to the list of plugin Rakefiles.
+    def self.add_rakefiles(*rakefiles)
+      Merb.add_rakefiles *rakefiles
+    end
+  end
+end

data/lib/merb-core/rack.rb

@@ -0,0 +1,15 @@
+require 'rack'
+module Merb  
+  module Rack
+    autoload :Application,    "merb-core/rack/application"
+    autoload :Adapter,        "merb-core/rack/adapter"
+    autoload :Ebb,            "merb-core/rack/adapter/ebb"
+    autoload :EventedMongrel, "merb-core/rack/adapter/evented_mongrel"    
+    autoload :FastCGI,        "merb-core/rack/adapter/fcgi"
+    autoload :Irb,            "merb-core/rack/adapter/irb"
+    autoload :Mongrel,        "merb-core/rack/adapter/mongrel"
+    autoload :Runner,         "merb-core/rack/adapter/runner"    
+    autoload :Thin,           "merb-core/rack/adapter/thin"
+    autoload :WEBrick,        "merb-core/rack/adapter/webrick"
+  end # Rack
+end # Merb

data/lib/merb-core/rack/adapter.rb

@@ -0,0 +1,42 @@
+module Merb
+  
+  module Rack
+    
+    class Adapter
+
+      class << self
+        # ==== Parameters
+        # id<String>:: The identifier of the Rack adapter class to retrieve.
+        #
+        # ==== Returns.
+        # Class:: The adapter class.
+        def get(id)
+          Object.full_const_get(@adapters[id])
+        end
+
+        # Registers a new Rack adapter.
+        #
+        # ==== Parameters
+        # ids<Array>:: Identifiers by which this adapter is recognized by.
+        # adapter_class<Class>:: The Rack adapter class.
+        def register(ids, adapter_class)
+          @adapters ||= Hash.new
+          ids.each { |id| @adapters[id] = "Merb::Rack::#{adapter_class}" }
+        end
+      end # class << self
+      
+    end # Adapter
+    
+    # Register some Rack adapters
+    Adapter.register %w{ebb},          :Ebb
+    Adapter.register %w{emongrel},     :EventedMongrel
+    Adapter.register %w{fastcgi fcgi}, :FastCGI
+    Adapter.register %w{irb},          :Irb
+    Adapter.register %w{mongrel},      :Mongrel  
+    Adapter.register %w{runner},       :Runner
+    Adapter.register %w{thin},         :Thin
+    Adapter.register %w{webrick},      :WEBrick
+    
+  end # Rack
+end # Merb
+

data/lib/merb-core/rack/adapter/ebb.rb

@@ -0,0 +1,22 @@
+require 'ebb'
+module Merb
+  
+  module Rack
+
+    class Ebb
+      # start an Ebb server on given host and port.
+      
+      # ==== Parameters
+      # opts<Hash>:: Options for Thin (see below).
+      #
+      # ==== Options (opts)
+      # :host<String>:: The hostname that Thin should serve.
+      # :port<Fixnum>:: The port Ebb should bind to.
+      # :app:: The application
+      def self.start(opts={})
+        Merb.logger.warn!("Using Ebb adapter")
+        ::Ebb.start_server(opts[:app], opts)
+      end
+    end
+  end
+end

data/lib/merb-core/rack/adapter/evented_mongrel.rb

@@ -0,0 +1,24 @@
+require 'swiftcore/evented_mongrel'
+require 'merb-core/rack/handler/mongrel'
+module Merb
+  module Rack
+
+    class EventedMongrel < Mongrel
+      # Starts Mongrel as evented.
+      #
+      # ==== Parameters
+      # opts<Hash>:: Options for Mongrel (see below).
+      #
+      # ==== Options (opts)
+      # :host<String>:: The hostname that Mongrel should serve.
+      # :port<Fixnum>:: The port Mongrel should bind to.
+      # :app<String>>:: The application name.
+      def self.start(opts={})
+        Merb.logger.warn!("Using EventedMongrel adapter")
+        server = ::Mongrel::HttpServer.new(opts[:host], opts[:port].to_i)
+        server.register('/', ::Merb::Rack::Handler::Mongrel.new(opts[:app]))
+        server.run.join
+      end
+    end
+  end
+end

data/lib/merb-core/rack/adapter/fcgi.rb

@@ -0,0 +1,16 @@
+module Merb
+  module Rack
+    
+    class FastCGI
+      # ==== Parameters
+      # opts<Hash>:: Options for FastCGI (see below).
+      #
+      # ==== Options (opts)
+      # :app<String>>:: The application name.
+      def self.start(opts={})
+        Merb.logger.warn!("Using FastCGI adapter")
+        ::Rack::Handler::FastCGI.run(opts[:app], opts)
+      end
+    end
+  end
+end

data/lib/merb-core/rack/adapter/irb.rb

@@ -0,0 +1,108 @@
+module Merb
+  module Rack
+    class Console
+      # ==== Parameters
+      # name<~to_sym, Hash>:: The name of the route to generate.
+      # params<Hash>:: The params to use in the route generation.
+      #
+      # ==== Returns
+      # String:: The generated URL.
+      #
+      # ==== Alternatives
+      # If name is a hash, it will be merged with params.      
+      def url(name, params={})
+        Merb::Router.generate(name, params)
+      end
+      
+      # Reloads classes using Merb::BootLoader::ReloadClasses.
+      def reload!
+        Merb::BootLoader::ReloadClasses.reload
+      end
+      
+      # Prints all routes for the application.
+      def show_routes
+        seen = []
+        unless Merb::Router.named_routes.empty?
+          puts "Named Routes"
+          Merb::Router.named_routes.each do |name,route|
+            puts "  #{name}: #{route}"
+            seen << route
+          end
+        end
+        puts "Anonymous Routes"
+        (Merb::Router.routes - seen).each do |route|
+          puts "  #{route}"
+        end
+        nil
+      end
+      
+      # Starts a sandboxed session (delegates to any Merb::Orms::* modules).
+      #
+      # An ORM should implement Merb::Orms::MyOrm#open_sandbox! to support this.
+      # Usually this involves starting a transaction.
+      def open_sandbox!
+        puts "Loading #{Merb.environment} environment in sandbox (Merb #{Merb::VERSION})"
+        puts "Any modifications you make will be rolled back on exit"
+        orm_modules.each { |orm| orm.open_sandbox! if orm.respond_to?(:open_sandbox!) }
+      end
+      
+      # Ends a sandboxed session (delegates to any Merb::Orms::* modules).
+      #
+      # An ORM should implement Merb::Orms::MyOrm#close_sandbox! to support this.
+      # Usually this involves rolling back a transaction.
+      def close_sandbox!
+        orm_modules.each { |orm| orm.close_sandbox! if orm.respond_to?(:close_sandbox!) }
+        puts "Modifications have been rolled back"
+      end
+      
+      # Explictly show logger output during IRB session
+      def trace_log!
+        Merb.logger.auto_flush = true
+      end
+      
+      private
+      
+      # ==== Returns
+      # Array:: All Merb::Orms::* modules.
+      def orm_modules
+        if Merb.const_defined?('Orms')
+          Merb::Orms.constants.map { |c| Merb::Orms::const_get(c) }
+        else
+          []
+        end
+      end
+      
+    end
+
+    class Irb
+      # ==== Parameters
+      # opts<Hash>:
+      #   Options for IRB. Currently this is not used by the IRB adapter.
+      #
+      # ==== Notes
+      # If the +.irbrc+ file exists, it will be loaded into the IRBRC
+      # environment variable.
+      def self.start(opts={})
+        m = Merb::Rack::Console.new
+        m.extend Merb::Test::RequestHelper
+        Object.send(:define_method, :merb) { m }  
+        ARGV.clear # Avoid passing args to IRB 
+        m.open_sandbox! if sandboxed?
+        require 'irb' 
+        require 'irb/completion' 
+        if File.exists? ".irbrc"
+          ENV['IRBRC'] = ".irbrc"
+        end
+        IRB.start
+        at_exit do merb.close_sandbox! if sandboxed? end
+        exit
+      end
+      
+      private
+      
+      def self.sandboxed?
+        Merb::Config[:sandbox]
+      end      
+    end
+  end
+end

data/lib/merb-core/rack/adapter/mongrel.rb

@@ -0,0 +1,25 @@
+require 'mongrel'
+require 'merb-core/rack/handler/mongrel'
+module Merb
+
+  module Rack
+
+    class Mongrel
+      # start server on given host and port.
+      
+      # ==== Parameters
+      # opts<Hash>:: Options for Mongrel (see below).
+      #
+      # ==== Options (opts)
+      # :host<String>:: The hostname that Mongrel should serve.
+      # :port<Fixnum>:: The port Mongrel should bind to.
+      # :app<String>>:: The application name.
+      def self.start(opts={})
+        Merb.logger.warn!("Using Mongrel adapter")
+        server = ::Mongrel::HttpServer.new(opts[:host], opts[:port].to_i)
+        server.register('/', ::Merb::Rack::Handler::Mongrel.new(opts[:app]))
+        server.run.join
+      end
+    end
+  end
+end

data/lib/merb-core/rack/adapter/runner.rb

@@ -0,0 +1,27 @@
+module Merb
+  
+  module Rack
+    
+    class Runner
+      # ==== Parameters
+      # opts<Hash>:: Options for the runner (see below).
+      #
+      # ==== Options (opts)
+      # :runner_code<String>:: The code to run.
+      #
+      # ==== Notes
+      # If opts[:runner_code] matches a filename, that file will be read and
+      # the contents executed. Otherwise the code will be executed directly.
+      def self.start(opts={})
+        if opts[:runner_code]
+          if File.exists?(opts[:runner_code])
+            eval(File.read(opts[:runner_code]), TOPLEVEL_BINDING, __FILE__, __LINE__)
+          else
+            eval(opts[:runner_code], TOPLEVEL_BINDING, __FILE__, __LINE__)
+          end
+          exit
+        end  
+      end
+    end
+  end
+end

data/lib/merb-core/rack/adapter/thin.rb

@@ -0,0 +1,27 @@
+require 'thin'
+module Merb
+  
+  module Rack
+
+    class Thin
+      # start a Thin server on given host and port.
+      
+      # ==== Parameters
+      # opts<Hash>:: Options for Thin (see below).
+      #
+      # ==== Options (opts)
+      # :host<String>:: The hostname that Thin should serve.
+      # :port<Fixnum>:: The port Thin should bind to.
+      # :app<String>>:: The application name.
+      def self.start(opts={})
+        Merb.logger.warn!("Using Thin adapter")
+        if opts[:host].include?('/')
+          opts[:host] =  "#{opts[:host]}-#{opts[:port]}"
+        end  
+        server = ::Thin::Server.new(opts[:host], opts[:port], opts[:app])
+        ::Thin::Logging.silent = true
+        server.start!
+      end
+    end
+  end
+end

data/lib/merb-core/rack/adapter/webrick.rb

@@ -0,0 +1,35 @@
+require 'webrick'
+require 'rack/handler/webrick'
+module Merb
+  module Rack
+
+    class WEBrick
+      # start WEBrick server on given host and port.
+      
+      # ==== Parameters
+      # opts<Hash>:: Options for WEBrick (see below).
+      #
+      # ==== Options (opts)
+      # :host<String>:: The hostname that WEBrick should serve.
+      # :port<Fixnum>:: The port WEBrick should bind to.
+      # :app<String>>:: The application name.
+      def self.start(opts={})
+        Merb.logger.warn!("Using Webrick adapter")
+      
+        options = {
+          :Port        => opts[:port],
+          :BindAddress => opts[:host],
+          :Logger      => Merb.logger,
+          :AccessLog   => [
+            [Merb.logger, ::WEBrick::AccessLog::COMMON_LOG_FORMAT],
+            [Merb.logger, ::WEBrick::AccessLog::REFERER_LOG_FORMAT]
+          ]
+        }
+     
+        server = ::WEBrick::HTTPServer.new(options)
+        server.mount("/", ::Rack::Handler::WEBrick, opts[:app])
+        server.start
+      end
+    end
+  end
+end

data/lib/merb-core/rack/application.rb

@@ -0,0 +1,77 @@
+module Merb
+  
+  module Rack
+
+    class Application
+      # ==== Parameters
+      # options<Hash>::
+      #   Options for creating a new application. Currently ignored.
+      def initialize(options={})
+        @static_server = ::Rack::File.new Merb.dir_for(:public)
+        if prefix = ::Merb::Config[:path_prefix]
+          @path_prefix = /^#{Regexp.escape(prefix)}/
+        end
+      end
+
+      # ==== Parameters
+      # env<Hash>:: Environment variables to pass on to the application.
+      #
+      # ==== Returns
+      # Array[Array]::
+      #   A 3 element tuple consisting of response status, headers and body.
+      def call(env) 
+        strip_path_prefix(env) if @path_prefix  # Strip out the path_prefix if one was set 
+        path = env['PATH_INFO'] ? env['PATH_INFO'].chomp('/') : ""
+        cached_path = (path.empty? ? 'index' : path) + '.html'
+        Merb.logger.info "Request: #{path}"
+        if file_exist?(path) && env['REQUEST_METHOD'] =~ /GET|HEAD/ # Serve the file if it's there and the request method is GET or HEAD
+          serve_static(env)
+        elsif file_exist?(cached_path) && env['REQUEST_METHOD'] =~ /GET|HEAD/ # Serve the page cache if it's there and the request method is GET or HEAD
+          env['PATH_INFO'] = cached_path
+          serve_static(env)
+        else                              # No static file, let Merb handle it
+          if path =~ /favicon\.ico/
+            return [404, {"Content-Type"=>"text/html"}, "404 Not Found."]
+          end  
+          begin
+            controller = ::Merb::Dispatcher.handle(env)
+          rescue Object => e
+            return [500, {"Content-Type"=>"text/html"}, e.message + "<br/>" + e.backtrace.join("<br/>")]
+          end
+          Merb.logger.info "\n\n"
+          Merb.logger.flush
+          [controller.status, controller.headers, controller.body]
+        end
+      end
+
+      # ==== Parameters
+      # path<String>:: The path to the file relative to the server root.
+      #
+      # ==== Returns
+      # Boolean:: True if file exists under the server root and is readable.
+      def file_exist?(path)
+        full_path = ::File.join(@static_server.root, ::Merb::Request.unescape(path))
+        ::File.file?(full_path) && ::File.readable?(full_path)
+      end
+
+      # ==== Parameters
+      # env<Hash>:: Environment variables to pass on to the server.
+      def serve_static(env)
+        env["PATH_INFO"] = ::Merb::Request.unescape(env["PATH_INFO"])        
+        @static_server.call(env)
+      end
+      
+      # ==== Parameters
+      # env<Hash>:: Environment variables to pass on to the server.
+      def strip_path_prefix(env)
+        ['PATH_INFO', 'REQUEST_URI'].each do |path_key|
+          if env[path_key] =~ @path_prefix
+            env[path_key].sub!(@path_prefix, '')
+            env[path_key] = '/' if env[path_key].empty?
+          end
+        end
+      end
+      
+    end
+  end  
+end