thorero 0.9.4.4 → 0.9.4.5

data/bin/merb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require "merb-core"
+
+if ARGV[0] && ARGV[0] =~ /^[^-]/
+  ARGV.push "-H"
+end 
+
+unless %w[-a --adapter -i --irb-console -r --script-runner].any? { |o| ARGV.index(o) }
+  ARGV.push *%w[-a mongrel]
+end
+
+Merb.start

data/bin/merb-specs

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require File.join(File.dirname(__FILE__),"..","lib","merb-core","test","run_specs")
+
+run_specs ARGV

data/docs/bootloading.dox

@@ -0,0 +1,58 @@
+The Merb boot process starts when you run the Merb binary, which calls `Merb.start`. Merb.start performs the
+following tasks:
+
+list.
+* Loads merb.yml from the root directory or config directory and puts them in the Merb::Config hash
+* Parses config arguments from the command-line and adds them to the Merb::Config hash
+* Runs the BootLoaders (see below)
+* Starts the Merb Rack adapter
+
+The BootLoader is a configurable process, which, by default, runs the following processes:
+
+deflist.
+Environment: Sets the Merb environment based on any -e flag passed the merb binary
+BuildFramework: Set the framework paths, which can either be set in the Merb::Config[:framework]
+  variable or defaults to the paths described below.
+Dependencies: Load dependencies.rb, which should include any plugins that will be loaded, as well
+  as an after_app_loaded hook.
+Logger: Set up the logger in the `Merb.dir_for(:log)` directory. In test mode, it will be called
+  `test_logger`. In other modes, it will be set to `merb.#{pid}.log`. The log level will default
+  to `info` but can be specified via the Merb::Config[:log_level] option.
+LoadRouter: The router is loaded from `Merb.dir_for(:config)/router.rb`.
+LoadClasses: Files in all of the load paths are `require`d, and classes added during the load of
+  each files are tracked so they can be removed later during the reloading process.
+Templates: All templates under the `_template_root` of any loaded controllers, as well as all 
+  templates under `Merb.dir_for(:view)` are registered as inlined templates.
+MimeTypes: Register all MimeTypes (see below for defaults).
+AfterAppLoads: Call any `after_app_loads` hooks that were registered in dependencies.rb
+MixinSessionContainer: Register the session types and set the app to use one if 
+  `Merb::Config[:session_type]` is set.
+ChooseAdapter: Set `Merb.adapter` to be the adapter chosen via Merb::Config[:adapter] (which
+  can be specified via the `-a foo` command-line parameter).
+RackUpApplication: Set up a default rack application. Alternatively, allow for additional configuration 
+  in `Merb.dir_for(:config)/rack.rb`, which will be evaluated in the context of a Rack::Builder.new
+  block.
+ReloadClasses: If Merb::Config[:reload_classes] is set, begin the process of reloading classes
+  every time a class is modified.
+  
+deflist: Default Framework Paths.
+application: Merb.root/app/controller/application.rb
+config: Merb.root/config
+lib: Merb.root/lib
+log: Merb.root/log
+view: Merb.root/app/views
+model: Merb.root/app/models
+controller: Merb.root/app/controllers
+helper: Merb.root/app/helpers
+mailer: Merb.root/app/mailers
+part: Merb.root/app/parts
+
+deflist: MimeTypes.
+\:all: no transform, */*
+\:yaml: to_yaml, application/x-yaml or text/yaml
+\:text: to_text, text/plain
+\:html: to_html, text/html or application/xhtml+xml or application/html
+\:xml: to_xml, application/xml or text/xml or application/x-xml, adds "Encoding: UTF-8" response header
+\:js: to_json, text/javascript ot application/javascript or application/x-javascript
+\:json: to_json, application/json or text/x-json
+

data/docs/documentation_standards

@@ -0,0 +1,40 @@
+Every method should have documentation above the method definition that fits this basic model...
+
+# Render the specified item, with the specified options.
+#
+# ==== Parameters
+# thing<String, Symbol, nil>::
+#   The thing to render. This will default to the current action
+# opts<Hash>:: An options hash (see below)
+#
+# ==== Options (opts)
+# :format<Symbol>:: A registered mime-type format
+# :template<String>::
+#   The path to the template relative to the template root
+# :status<~to_i>::
+#   The status to send to the client. Typically, this would
+#   be an integer (200), or a Merb status code (Accepted)
+# :layout<~to_s>::
+#   A layout to use instead of the default. This should be
+#   relative to the layout root. By default, the layout will
+#   be either the controller_name or application. If you
+#   want to use an alternative content-type than the one
+#   that the base template was rendered as, you will need
+#   to do :layout => “foo.#{content_type}” (i.e. “foo.json”)
+#
+# ==== Returns
+# String:: The rendered template, including layout, if appropriate.
+#
+# ==== Raises
+# TemplateNotFound::
+#   There is no template for the specified location.
+#
+# ==== Alternatives
+# If you pass a Hash as the first parameter, it will be moved to
+# opts and “thing” will be the current action
+#
+#—
+# @public
+def render(thing = nil, opts = {})
+  <snip>
+end

data/docs/new_render_api

@@ -0,0 +1,51 @@
+## TEMPLATES
+
+# Render an action
+render :symbol
+
+# Render a string
+render "string"
+
+# Render an object; will call to_#{content-type} on this if the default template is not found
+display @obj
+
+# Provide an alternative default thing to render; note that we can use strings here for template paths
+# because strings would never fail and fallback to the @obj
+display @obj, :symbol
+display @obj, "full/path/to/template"
+
+# Render a template
+render_template "full/path/to/template"
+
+# Render with a mime-type (same as render, but with added mime-type set)
+render_json :symbol
+render_json "string"
+
+# Render nothing at all
+render_nothing
+
+# TEMPLATE OPTIONS (all functions above can use these options)
+
+# :format can be used to override the mime-type arrived at via content-negotiation
+render :symbol, :format => :xml
+
+# :status can set the status that will be returned to the browser
+render :symbol, :status => Successful::Accepted
+# or
+render :symbol, :status => 202
+
+# :layout sets the layout to use; default: controller.to_path || :application; :none means no layout
+render :symbol, :layout => :none
+
+## PARTIALS
+
+# Render a partial
+partial :symbol
+
+# Render a partial with an object (it will default to the local var "symbol" in the partial)
+partial :symbol, :with => @object
+partial :symbol, :with => @object, :as => "something"
+
+# Render a partial with a collection of objects (same :as semantics)
+partial :symbol, :with => [col, lec, tion]
+partial :symbol, :with => [col, lec, tion], :as => "name"

data/lib/merb-core.rb

@@ -0,0 +1,603 @@
+#---
+# require 'merb' must happen after Merb::Config is instantiated
+require 'rubygems'
+require 'set'
+require 'fileutils'
+require 'socket'
+require 'pathname'
+require "extlib"
+
+__DIR__ = File.dirname(__FILE__)
+
+$LOAD_PATH.unshift __DIR__ unless
+  $LOAD_PATH.include?(__DIR__) ||
+  $LOAD_PATH.include?(File.expand_path(__DIR__))
+
+require 'merb-core' / 'vendor' / 'facets'
+
+module Merb
+  module GlobalHelpers; end
+  class << self
+
+    # Merge environment settings
+    # Can allow you to have a "localdev" that runs like your "development"
+    #   OR
+    # A "staging" environment that runs like your "production"
+    #
+    # ==== Examples
+    # From any environment config file (ie, development.rb, custom.rb, localdev.rb, etc)
+    #   staging.rb:
+    #     Merb.merge_env "production"         #We want to use all the settings production uses
+    #     Merb::Config.use { |c|
+    #       c[:log_level]         = "debug"   #except we want debug log level
+    #       c[:exception_details] = true      #and we want to see exception details
+    #     }
+    #
+    # ==== Parameters
+    # env<~String>:: Environment to run like
+    # use_db<~Boolean>:: Should Merb use the merged environments DB connection
+    #     Defaults to +false+
+    def merge_env(env,use_db=false)
+      if Merb.environment_info.nil?
+        Merb.environment_info = {
+          :real_env => Merb.environment,
+          :merged_envs => [],
+          :db_env => Merb.environment
+        }
+      end
+      
+      #Only load if it hasn't been loaded
+      unless Merb.environment_info[:merged_envs].member? env
+        Merb.environment_info[:merged_envs] << env
+        
+        env_file = Merb.dir_for(:config) / "environments" / ("#{env}.rb")
+        if File.exists?(env_file)
+          load(env_file)
+        else
+          Merb.logger.warn! "Environment file does not exist! #{env_file}"
+        end
+        
+      end
+      
+      # Mark specific environment to load when ORM loads,
+      # if multiple environments are loaded, the last one
+      # with use_db as TRUE will be loaded
+      if use_db
+        Merb.environment_info[:db_env] = env
+      end
+    end
+
+
+    # Startup Merb by setting up the Config and starting the server.
+    # This is where Merb application environment and root path are set.
+    #
+    # ==== Parameters
+    # argv<String, Hash>::
+    #   The config arguments to start Merb with. Defaults to +ARGV+.
+    def start(argv=ARGV)
+      if Hash === argv
+        Merb::Config.setup(argv)
+      else
+        Merb::Config.parse_args(argv)
+      end
+      Merb.environment = Merb::Config[:environment]
+      Merb.root = Merb::Config[:merb_root]
+      case Merb::Config[:action]
+      when :kill
+        Merb::Server.kill(Merb::Config[:port], 1)
+      when :kill_9
+        Merb::Server.kill(Merb::Config[:port], 9)
+      else
+        Merb::Server.start(Merb::Config[:port], Merb::Config[:cluster])
+      end
+    end
+
+    # Start the Merb environment, but only if it hasn't been loaded yet.
+    #
+    # ==== Parameters
+    # argv<String, Hash>::
+    #   The config arguments to start Merb with. Defaults to +ARGV+.
+    def start_environment(argv=ARGV)
+      unless (@started ||= false)
+        start(argv)
+        @started = true
+      end
+    end
+
+    # Restart the Merb environment explicitly.
+    #
+    # ==== Parameters
+    # argv<String, Hash>::
+    #   The config arguments to restart Merb with. Defaults to +Merb::Config+.
+    def restart_environment(argv={})
+      @started = false
+      start_environment(Merb::Config.to_hash.merge(argv))
+    end
+
+    attr_accessor :environment, :load_paths, :adapter, :environment_info, :started
+
+    alias :env :environment
+    alias :started? :started
+
+    Merb.load_paths = Dictionary.new { [Merb.root] } unless Merb.load_paths.is_a?(Dictionary)
+
+    # This is the core mechanism for setting up your application layout.
+    # There are three application layouts in Merb:
+    #
+    # Regular app/:type layout of Ruby on Rails fame:
+    #
+    # app/models      for models
+    # app/mailers     for mailers (special type of controllers)
+    # app/parts       for parts, Merb components
+    # app/views       for templates
+    # app/controllers for controller
+    # lib             for libraries
+    #
+    # Flat application layout:
+    #
+    # application.rb       for models, controllers, mailers, etc
+    # config/init.rb       for initialization and router configuration
+    # config/framework.rb  for framework and dependencies configuration
+    # views                for views
+    #
+    # and Camping-style "very flat" application layout, where the whole Merb
+    # application and configs fit into a single file.
+    #
+    # ==== Notes
+    # Autoloading for lib uses empty glob by default. If you
+    # want to have your libraries under lib use autoload, add
+    # the following to Merb init file:
+    #
+    # Merb.push_path(:lib, Merb.root / "lib", "**/*.rb") # glob set explicity.
+    #
+    # Then lib/magicwand/lib/magicwand.rb with MagicWand module will
+    # be autoloaded when you first access that constant.
+    #
+    # ==== Examples
+    # This method gives you a way to build up your own application
+    # structure, for instance, to reflect the structure Rails
+    # uses to simplify transition of legacy application, you can
+    # set it up like this:
+    #
+    # Merb.push_path(:model,      Merb.root / "app" / "models",      "**/*.rb")
+    # Merb.push_path(:mailer,     Merb.root / "app" / "models",      "**/*.rb")
+    # Merb.push_path(:controller, Merb.root / "app" / "controllers", "**/*.rb")
+    # Merb.push_path(:view,       Merb.root / "app" / "views",       "**/*.rb")
+    #
+    # ==== Parameters
+    # type<Symbol>:: The type of path being registered (i.e. :view)
+    # path<String>:: The full path
+    # file_glob<String>::
+    #   A glob that will be used to autoload files under the path. Defaults to
+    #   "**/*.rb".
+    def push_path(type, path, file_glob = "**/*.rb")
+      enforce!(type => Symbol)
+      load_paths[type] = [Pathname.new(path), file_glob]
+    end
+
+    # Removes given types of application components
+    # from load path Merb uses for autoloading.
+    #
+    # ==== Parameters
+    # *args<Array(Symbol)>::
+    #   components names, for instance, :views, :models
+    #
+    # ==== Examples
+    # Using this combined with Merb::GlobalHelpers.push_path
+    # you can make your Merb application use legacy Rails
+    # application components.
+    #
+    # Merb.root = "path/to/legacy/app/root"
+    # Merb.remove_paths(:mailer)
+    # Merb.push_path(:mailer,     Merb.root / "app" / "models",      "**/*.rb")
+    #
+    # Will make Merb use app/models for mailers just like Ruby on Rails does.
+    def remove_paths(*args)
+      args.each {|arg| load_paths.delete(arg)}
+    end
+
+    # ==== Parameters
+    # type<Symbol>:: The type of path to retrieve directory for, e.g. :view.
+    #
+    # ==== Returns
+    # String:: The directory for the requested type.
+    def dir_for(type)
+      Merb.load_paths[type].first
+    end
+
+    # ==== Parameters
+    # type<Symbol>:: The type of path to retrieve glob for, e.g. :view.
+    #
+    # ===== Returns
+    # String:: The pattern with which to match files within the type directory.
+    def glob_for(type)
+      Merb.load_paths[type][1]
+    end
+
+    # ==== Returns
+    # String:: The Merb root path.
+    def root
+      app_root = @root || Merb::Config[:merb_root] || Dir.pwd
+
+      Pathname.new(app_root)
+    end
+
+    # ==== Parameters
+    # value<String>:: Path to the root directory.
+    def root=(value)
+      @root = Pathname.new(value)
+    end
+
+    # ==== Parameters
+    # *path::
+    #   The relative path (or list of path components) to a directory under the
+    #   root of the application.
+    #
+    # ==== Returns
+    # String:: The full path including the root.
+    #
+    # ==== Examples
+    #   Merb.root = "/home/merb/app"
+    #   Merb.path("images") # => "/home/merb/app/images"
+    #   Merb.path("views", "admin") # => "/home/merb/app/views/admin"
+    #---
+    # @public
+    def root_path(*path)
+      Pathname.new(File.join(root, *path))
+    end
+
+    # Logger settings
+    attr_accessor :logger
+
+    # ==== Returns
+    # String::
+    #   The path to the log file. If this Merb instance is running as a daemon
+    #   this will return +STDOUT+.
+    def log_file
+      if Merb::Config[:log_file]
+        Merb::Config[:log_file]
+      elsif Merb.testing?
+        log_path / "merb_test.log"
+      elsif !(Merb::Config[:daemonize] || Merb::Config[:cluster])
+        STDOUT
+      else
+        log_path / "merb.#{Merb::Config[:port]}.log"
+      end
+    end
+
+    # ==== Returns
+    # String:: Path to directory that contains the log file.
+    def log_path
+      path = case Merb::Config[:log_file]
+      when String then File.dirname(Merb::Config[:log_file])
+      else Merb.root_path("log")
+      end
+
+      Pathname.new(path)
+    end
+
+    # ==== Returns
+    # String:: The path of root directory of the Merb framework.
+    def framework_root
+      @framework_root ||= Pathname(File.dirname(__FILE__))
+    end
+
+    # ==== Returns
+    # RegExp::
+    #   Regular expression against which deferred actions
+    #   are matched by Rack application handler.
+    #
+    # ==== Notes
+    # Concatenates :deferred_actions configuration option
+    # values.
+    def deferred_actions
+      @deferred ||= begin
+        if Merb::Config[:deferred_actions].empty?
+          /^\0$/
+        else
+          /#{Merb::Config[:deferred_actions].join("|")}/
+        end
+      end
+    end
+
+    # Allows flat apps by setting no default framework directories and yielding
+    # a Merb::Router instance. This is optional since the router will
+    # automatically configure the app with default routes.
+    #
+    # ==== Block parameters
+    # r<Merb::Router::Behavior>::
+    #   The root behavior upon which new routes can be added.
+    def flat!(framework = {})
+      Merb::Config[:framework] = framework
+
+      Merb::Router.prepare do |r|
+        yield(r) if block_given?
+        r.default_routes
+      end
+    end
+
+    # Set up default variables under Merb
+    attr_accessor :generator_scope, :klass_hashes, :orm_generator_scope, :test_framework_generator_scope
+
+    # Returns registered ORM generators as symbols,
+    # for instance, :datamapper.
+    #
+    # ==== Returns
+    # <Array(Symbol>:: registered ORM generators.
+    def orm_generator_scope
+      @orm_generator_scope ||= :merb_default
+    end
+
+    # Returns registered test framework generators.
+    #
+    # ==== Returns
+    # <Array(Symbol>:: registred test framework generators.
+    def test_framework_generator_scope
+      @test_framework_generator_scope ||= :rspec
+    end
+
+    # Returns all registered generators plus Merb generator.
+    #
+    # ==== Returns
+    # <Array(Symbol>::
+    #   all registered generators, inc. needed by Merb itself.
+    def generator_scope
+      [:merb, orm_generator_scope, test_framework_generator_scope]
+    end
+
+
+    Merb.klass_hashes = []
+
+    attr_reader :registered_session_types
+
+    # ==== Parameters
+    # name<~to_s>:: Name of the session type to register.
+    # file<String>:: The file that defines this session type.
+    # description<String>:: An optional description of the session type.
+    #
+    # ==== Notes
+    # Merb currently supports memory, cookie and memcache session
+    # types.
+    def register_session_type(name, file, description = nil)
+      @registered_session_types ||= Dictionary.new
+      @registered_session_types[name] = {
+        :file => file,
+        :description => (description || "Using #{name} sessions")
+      }
+    end
+
+    attr_accessor :frozen
+
+    # ==== Returns
+    # Boolean:: True if Merb is running via merb-freezer or other freezer.
+    #
+    # ==== Notes
+    # Freezing means bundling framework libraries with your application
+    # making it independent from environment it runs in. This is a good
+    # practice to freeze application framework and gems it uses and
+    # very useful when application is run in some sort of sandbox,
+    # for instance, shared hosting with preconfigured gems.
+    def frozen?
+      @frozen
+    end
+
+    # Used by merb-freezer and other freezers to mark Merb as frozen.
+    # See Merb::GlobalHelpers.frozen? for more details on framework freezing.
+    def frozen!
+      @frozen = true
+    end
+
+    # Load configuration and assign logger.
+    #
+    # ==== Parameters
+    # options<Hash>:: Options to pass on to the Merb config.
+    #
+    # ==== Options
+    # :host<String>::             host to bind to,
+    #                             default is 0.0.0.0.
+    #
+    # :port<Fixnum>::             port to run Merb application on,
+    #                             default is 4000.
+    #
+    # :adapter<String>::          name of Rack adapter to use,
+    #                             default is "runner"
+    #
+    # :rackup<String>::           name of Rack init file to use,
+    #                             default is "rack.rb"
+    #
+    # :reload_classes<Boolean>::  whether Merb should reload
+    #                             classes on each request,
+    #                             default is true
+    #
+    # :environment<String>::      name of environment to use,
+    #                             default is development
+    #
+    # :merb_root<String>::        Merb application root,
+    #                             default is Dir.pwd
+    #
+    # :use_mutex<Boolean>::       turns action dispatch synchronization
+    #                             on or off, default is on (true)
+    #
+    # :session_id_key<String>::   session identifier,
+    #                             default is _session_id
+    #
+    # :session_store<String>::    session store to use (one of cookies,
+    #                             memcache or memory)
+    #
+    # :log_delimiter<String>::    what Merb logger uses as delimiter
+    #                             between message sections, default is " ~ "
+    #
+    # :log_auto_flush<Boolean>::  whether the log should automatically
+    #                             flush after new messages are
+    #                             added, defaults to true.
+    #
+    # :log_file<IO>::             IO for logger. Default is STDOUT.
+    #
+    # :log_level<Symbol>::        logger level, default is :warn
+    #
+    # :disabled_components<Array[Symbol]>::
+    #   array of disabled component names,
+    #   for instance, to disable json gem,
+    #   specify :json. Default is empty array.
+    #
+    # :deferred_actions<Array(Symbol, String)]>::
+    #   names of actions that should be deferred
+    #   no matter what controller they belong to.
+    #   Default is empty array.
+    #
+    # Some of these options come from command line on Merb
+    # application start, some of them are set in Merb init file
+    # or environment-specific.
+    def load_config(options = {})
+      Merb::Config.setup({ :log_file => STDOUT, :log_level => :warn, :log_auto_flush => true }.merge(options))
+      Merb::BootLoader::Logger.run
+    end
+
+    # Load all basic dependencies (selected BootLoaders only).
+    # This sets up Merb framework component paths
+    # (directories for models, controllers, etc) using
+    # framework.rb or default layout, loads init file
+    # and dependencies specified in it and runs before_app_loads hooks.
+    #
+    # ==== Parameters
+    # options<Hash>:: Options to pass on to the Merb config.
+    def load_dependencies(options = {})
+      load_config(options)
+      Merb::BootLoader::BuildFramework.run
+      Merb::BootLoader::Dependencies.run
+      Merb::BootLoader::BeforeAppLoads.run
+    end
+
+    # Reload application and framework classes.
+    # See Merb::BootLoader::ReloadClasses for details.
+    def reload
+      Merb::BootLoader::ReloadClasses.reload
+    end
+
+    # ==== Returns
+    # Boolean:: True if Merb environment is testing for instance,
+    # Merb is running with RSpec, Test::Unit of other testing facility.
+    def testing?
+      $TESTING || Merb::Config[:testing]
+    end
+
+    # Ask the question about which environment you're in.
+    # ==== Parameters
+    # env<Symbol, String>:: Name of the environment to query
+    #
+    # ==== Examples
+    # Merb.env #=> production
+    # Merb.env?(:production) #=> true
+    # Merb.env?(:development) #=> false
+    def env?(env)
+      Merb.env == env.to_s
+    end
+
+    # If block was given configures using the block.
+    #
+    # ==== Parameters
+    # &block:: Configuration parameter block, see example below.
+    #
+    # ==== Returns
+    # Hash:: The current configuration.
+    #
+    # ==== Notes
+    # See Merb::GlobalHelpers.load_config for configuration
+    # options list.
+    #
+    # ==== Examples
+    #   Merb.config do
+    #     beer               "good"
+    #     hashish            :foo => "bar"
+    #     environment        "development"
+    #     log_level          "debug"
+    #     use_mutex          false
+    #     session_store      "cookie"
+    #     session_secret_key "0d05a226affa226623eb18700"
+    #     exception_details  true
+    #     reload_classes     true
+    #     reload_time        0.5
+    #   end
+    def config(&block)
+      Merb::Config.configure(&block) if block_given?
+      Config
+    end
+
+    # Disables the given core components, like a Gem for example.
+    #
+    # ==== Parameters
+    # *args:: One or more symbols of Merb internal components.
+    def disable(*components)
+      disabled_components.push *components
+    end
+
+    # ==== Parameters
+    # Array:: All components that should be disabled.
+    def disabled_components=(components)
+      disabled_components.replace components
+    end
+
+    # ==== Returns
+    # Array:: All components that have been disabled.
+    def disabled_components
+      Merb::Config[:disabled_components] ||= []
+    end
+
+    # ==== Returns
+    # Boolean:: True if all components (or just one) are disabled.
+    def disabled?(*components)
+      components.all? { |c| disabled_components.include?(c) }
+    end
+
+    # ==== Returns
+    # Array(String):: Paths Rakefiles are loaded from.
+    #
+    # ==== Notes
+    # Recommended way to find out what paths Rakefiles
+    # are loaded from.
+    def rakefiles
+      @rakefiles ||= ['merb-core' / 'test' / 'tasks' / 'spectasks']
+    end
+    
+    # === Returns
+    # Array(String):: Paths generators are loaded from
+    #
+    # === Notes
+    # Recommended way to find out what paths generators
+    # are loaded from.
+    def generators
+      @generators ||= []
+    end
+
+    # ==== Parameters
+    # *rakefiles:: Rakefile pathss to add to the list of Rakefiles.
+    #
+    # ==== Notes
+    # Recommended way to add Rakefiles load path for plugins authors.
+    def add_rakefiles(*rakefiles)
+      @rakefiles ||= ['merb-core' / 'test' / 'tasks' / 'spectasks']
+      @rakefiles += rakefiles
+    end
+    
+    # ==== Parameters
+    # *generators:: Generator paths to add to the list of generators.
+    #
+    # ==== Notes
+    # Recommended way to add Generator load paths for plugin authors.
+    def add_generators(*generators)
+      @generators ||= []
+      @generators += generators
+    end
+
+  end
+end
+
+require 'merb-core' / 'autoload'
+require 'merb-core' / 'server'
+require 'merb-core' / 'gem_ext/erubis'
+require 'merb-core' / 'logger'
+require 'merb-core' / 'version'
+require 'merb-core' / 'controller/mime'
+
+# Set the environment if it hasn't already been set.
+Merb.environment ||= ENV['MERB_ENV'] || Merb::Config[:environment] || (Merb.testing? ? 'test' : 'development')