Module: Merb

Defined in:
lib/merb-core/logger.rb,
lib/merb-core.rb,
lib/merb-core/rack.rb,
lib/merb-core/test.rb,
lib/merb-core/config.rb,
lib/merb-core/server.rb,
lib/merb-core/plugins.rb,
lib/merb-core/version.rb,
lib/merb-core/autoload.rb,
lib/merb-core/autoload.rb,
lib/merb-core/constants.rb,
lib/merb-core/bootloader.rb,
lib/merb-core/rack/adapter.rb,
lib/merb-core/controller/mime.rb,
lib/merb-core/dispatch/router.rb,
lib/merb-core/dispatch/worker.rb,
lib/merb-core/rack/middleware.rb,
lib/merb-core/dispatch/cookies.rb,
lib/merb-core/dispatch/request.rb,
lib/merb-core/dispatch/session.rb,
lib/merb-core/rack/adapter/ebb.rb,
lib/merb-core/rack/adapter/irb.rb,
lib/merb-core/rack/application.rb,
lib/merb-core/rack/adapter/fcgi.rb,
lib/merb-core/rack/adapter/thin.rb,
lib/merb-core/rack/adapter/runner.rb,
lib/merb-core/rack/adapter/mongrel.rb,
lib/merb-core/rack/adapter/webrick.rb,
lib/merb-core/controller/exceptions.rb,
lib/merb-core/dispatch/router/route.rb,
lib/merb-core/rack/middleware/static.rb,
lib/merb-core/dispatch/session/cookie.rb,
lib/merb-core/dispatch/session/memory.rb,
lib/merb-core/rack/adapter/thin_turbo.rb,
lib/merb-core/dispatch/router/behavior.rb,
lib/merb-core/rack/middleware/profiler.rb,
lib/merb-core/test/helpers/view_helper.rb,
lib/merb-core/test/helpers/route_helper.rb,
lib/merb-core/dispatch/session/memcached.rb,
lib/merb-core/controller/mixins/responder.rb,
lib/merb-core/dispatch/router/cached_proc.rb,
lib/merb-core/rack/middleware/path_prefix.rb,
lib/merb-core/test/helpers/request_helper.rb,
lib/merb-core/controller/mixins/controller.rb,
lib/merb-core/rack/adapter/evented_mongrel.rb,
lib/merb-core/test/helpers/controller_helper.rb,
lib/merb-core/rack/adapter/swiftiplied_mongrel.rb,
lib/merb-core/rack/handler/mongrel.rb

Overview

Most of this code is taken from bitsweat’s implementation in rails

Defined Under Namespace

Modules: AuthenticationMixin, Const, ControllerExceptions, ControllerMixin, GlobalHelpers, InlineTemplates, Plugins, Rack, RenderMixin, ResponderMixin, SessionMixin, Template, Test Classes: AcceptType, BootLoader, Config, Controller, CookieSession, Cookies, Dispatcher, Logger, MemCacheSession, MemorySession, MemorySessionContainer, Request, Responder, Router, Server, Worker

Constant Summary collapse

VERSION = 
'0.9.4'
RELEASE =

Merb::RELEASE meanings: ‘dev’ : unreleased ‘pre’ : pre-release Gem candidates

nil    : released

You should never check in to trunk with this changed. It should stay ‘dev’. Change it to nil in release tags.

'dev'

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.adapter ⇒ Object

Returns the value of attribute adapter.



117
118
119
 
# File 'lib/merb-core.rb', line 117

def adapter
  @adapter
end

.environment ⇒ Object Also known as: env

Returns the value of attribute environment.



117
118
119
 
# File 'lib/merb-core.rb', line 117

def environment
  @environment
end

.environment_info ⇒ Object

Returns the value of attribute environment_info.



117
118
119
 
# File 'lib/merb-core.rb', line 117

def environment_info
  @environment_info
end

.frozen ⇒ Object

Returns the value of attribute frozen.



369
370
371
 
# File 'lib/merb-core.rb', line 369

def frozen
  @frozen
end

.generator_scope ⇒ Object

Returns all registered generators plus Merb generator.

Returns

<Array(Symbol>

all registered generators, inc. needed by Merb itself.



320
321
322
 
# File 'lib/merb-core.rb', line 320

def generator_scope
  @generator_scope
end

.klass_hashes ⇒ Object

Set up default variables under Merb



320
321
322
 
# File 'lib/merb-core.rb', line 320

def klass_hashes
  @klass_hashes
end

.load_paths ⇒ Object

Returns the value of attribute load_paths.



117
118
119
 
# File 'lib/merb-core.rb', line 117

def load_paths
  @load_paths
end

.logger ⇒ Object

Logger settings



250
251
252
 
# File 'lib/merb-core.rb', line 250

def logger
  @logger
end

.orm_generator_scope ⇒ Object

Returns registered ORM generators as symbols, for instance, :datamapper.

Returns

<Array(Symbol>

registered ORM generators.



320
321
322
 
# File 'lib/merb-core.rb', line 320

def orm_generator_scope
  @orm_generator_scope
end

.registered_session_types ⇒ Object (readonly)

Returns the value of attribute registered_session_types.



351
352
353
 
# File 'lib/merb-core.rb', line 351

def registered_session_types
  @registered_session_types
end

.started ⇒ Object Also known as: started?

Returns the value of attribute started.



117
118
119
 
# File 'lib/merb-core.rb', line 117

def started
  @started
end

.test_framework_generator_scope ⇒ Object

Returns registered test framework generators.

Returns

<Array(Symbol>

registred test framework generators.



320
321
322
 
# File 'lib/merb-core.rb', line 320

def test_framework_generator_scope
  @test_framework_generator_scope
end

Class Method Details

.add_generators(*generators) ⇒ Object

Parameters

*generators

Generator paths to add to the list of generators.

Notes

Recommended way to add Generator load paths for plugin authors.



587
588
589
590
 
# File 'lib/merb-core.rb', line 587

def add_generators(*generators)
  @generators ||= []
  @generators += generators
end

.add_mime_type(key, transform_method, mimes, new_response_headers = {}, &block) ⇒ Object

Any specific outgoing headers should be included here. These are not the content-type header but anything in addition to it. transform_method should be set to a symbol of the method used to transform a resource into this mime type. For example for the :xml mime type an object might be transformed by calling :to_xml, or for the :js mime type, :to_json. If there is no transform method, use nil.

Autogenerated Methods

Adding a mime-type adds a render_type method that sets the content type and calls render.

By default this does: def render_all, def render_yaml, def render_text, def render_html, def render_xml, def render_js, and def render_yaml

Parameters

key<Symbol>

The name of the mime-type. This is used by the provides API

transform_method<~to_s>

The associated method to call on objects to convert them to the appropriate mime-type. For instance, :json would use :to_json as its transform_method.

mimes<Array>

A list of possible values sent in the Accept header, such as text/html, that should be associated with this content-type.

new_response_headers<Hash>

The response headers to set for the the mime type. For example: ‘Content-Type’ => ‘application/json; charset=utf-8’; As a shortcut for the common charset option, use :charset => ‘utf-8’, which will be correctly appended to the mimetype itself.

&block

a block which recieves the current controller when the format

is set (in the controller's #content_type method)



41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/merb-core/controller/mime.rb', line 41

def add_mime_type(key, transform_method, mimes, new_response_headers = {}, &block) 
  enforce!(key => Symbol, mimes => Array)
  
  content_type = new_response_headers["Content-Type"] || mimes.first
  
  if charset = new_response_headers.delete(:charset)
    content_type += "; charset=#{charset}"
  end
  
  ResponderMixin::TYPES.update(key => 
    {:accepts           => mimes, 
     :transform_method  => transform_method,
     :content_type      => content_type,
     :response_headers  => new_response_headers,
     :response_block    => block })

  mimes.each do |mime|
    ResponderMixin::MIMES.update(mime => key)
  end

  Merb::RenderMixin.class_eval <<-EOS, __FILE__, __LINE__
    def render_#{key}(thing = nil, opts = {})
      self.content_type = :#{key}
      render thing, opts
    end
  EOS
end

.add_rakefiles(*rakefiles) ⇒ Object

Parameters

*rakefiles

Rakefile pathss to add to the list of Rakefiles.

Notes

Recommended way to add Rakefiles load path for plugins authors.



577
578
579
580
 
# File 'lib/merb-core.rb', line 577

def add_rakefiles(*rakefiles)
  @rakefiles ||= ['merb-core' / 'test' / 'tasks' / 'spectasks']
  @rakefiles += rakefiles
end

.available_mime_types ⇒ Object

Returns

Hash

The available mime types.



6
7
8
 
# File 'lib/merb-core/controller/mime.rb', line 6

def available_mime_types
  ResponderMixin::TYPES
end

.config(&block) ⇒ Object

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



521
522
523
524
 
# File 'lib/merb-core.rb', line 521

def config(&block)
  Merb::Config.configure(&block) if block_given?
  Config
end

.deferred_actions ⇒ Object

Returns

RegExp

Regular expression against which deferred actions are matched by Rack application handler.

Notes

Concatenates :deferred_actions configuration option values.



293
294
295
296
297
298
299
300
301
 
# File 'lib/merb-core.rb', line 293

def deferred_actions
  @deferred ||= begin
    if Merb::Config[:deferred_actions].empty?
      /^\0$/
    else
      /#{Merb::Config[:deferred_actions].join("|")}/
    end
  end
end

.dir_for(type) ⇒ Object

Parameters

type<Symbol>

The type of path to retrieve directory for, e.g. :view.

Returns

String

The directory for the requested type.



204
205
206
 
# File 'lib/merb-core.rb', line 204

def dir_for(type)
  Merb.load_paths[type].first
end

.disable(*components) ⇒ Object

Disables the given core components, like a Gem for example.

Parameters

*args

One or more symbols of Merb internal components.



530
531
532
 
# File 'lib/merb-core.rb', line 530

def disable(*components)
  disabled_components.push *components
end

.disabled?(*components) ⇒ Boolean

Returns

Boolean

True if all components (or just one) are disabled.

Returns:

  • (Boolean) 


548
549
550
 
# File 'lib/merb-core.rb', line 548

def disabled?(*components)
  components.all? { |c| disabled_components.include?(c) }
end

.disabled_components ⇒ Object

Returns

Array

All components that have been disabled.



542
543
544
 
# File 'lib/merb-core.rb', line 542

def disabled_components
  Merb::Config[:disabled_components] ||= []
end

.disabled_components=(components) ⇒ Object

Parameters

Array

All components that should be disabled.



536
537
538
 
# File 'lib/merb-core.rb', line 536

def disabled_components=(components)
  disabled_components.replace components
end

.env?(env) ⇒ Boolean

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

Returns:

  • (Boolean) 


492
493
494
 
# File 'lib/merb-core.rb', line 492

def env?(env)
  Merb.env == env.to_s
end

.exception(e) ⇒ Object

Required to show exceptions in the log file

e<Exception>

The exception that a message is being generated for



297
298
299
300
 
# File 'lib/merb-core/controller/exceptions.rb', line 297

def self.exception(e)
  "#{ e.message } - (#{ e.class })\n" <<  
  "#{(e.backtrace or []).join("\n")}" 
end

.flat!(framework = {}) ⇒ Object

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.



310
311
312
313
314
315
316
317
 
# File 'lib/merb-core.rb', line 310

def flat!(framework = {})
  Merb::Config[:framework] = framework

  Merb::Router.prepare do |r|
    yield(r) if block_given?
    r.default_routes
  end
end

.framework_root ⇒ Object

Returns

String

The path of root directory of the Merb framework.



281
282
283
 
# File 'lib/merb-core.rb', line 281

def framework_root
  @framework_root ||= Pathname(File.dirname(__FILE__))
end

.frozen! ⇒ Object

Used by merb-freezer and other freezers to mark Merb as frozen. See Merb::GlobalHelpers.frozen? for more details on framework freezing.



386
387
388
 
# File 'lib/merb-core.rb', line 386

def frozen!
  @frozen = true
end

.frozen? ⇒ Boolean

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.

Returns:

  • (Boolean) 


380
381
382
 
# File 'lib/merb-core.rb', line 380

def frozen?
  @frozen
end

.generators ⇒ Object

Returns

Array(String)

Paths generators are loaded from

Notes

Recommended way to find out what paths generators are loaded from.



568
569
570
 
# File 'lib/merb-core.rb', line 568

def generators
  @generators ||= []
end

.glob_for(type) ⇒ Object

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.



213
214
215
 
# File 'lib/merb-core.rb', line 213

def glob_for(type)
  Merb.load_paths[type][1]
end

.load_config(options = {}) ⇒ Object

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>

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.



451
452
453
454
 
# File 'lib/merb-core.rb', line 451

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_dependencies(options = {}) ⇒ Object

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.



464
465
466
467
468
469
 
# File 'lib/merb-core.rb', line 464

def load_dependencies(options = {})
  load_config(options)
  Merb::BootLoader::BuildFramework.run
  Merb::BootLoader::Dependencies.run
  Merb::BootLoader::BeforeAppLoads.run
end

.log_file ⇒ Object

Returns

String

The path to the log file. If this Merb instance is running as a daemon this will return STDOUT.



256
257
258
259
260
261
262
263
264
265
266
 
# File 'lib/merb-core.rb', line 256

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

.log_path ⇒ Object

Returns

String

Path to directory that contains the log file.



270
271
272
273
274
275
276
277
 
# File 'lib/merb-core.rb', line 270

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

.merge_env(env, use_db = false) ⇒ Object

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+



40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/merb-core.rb', line 40

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

.mime_by_request_header(header) ⇒ Object

The mime-type for a particular inbound Accepts header.

Parameters

header<String>

The name of the header to find the mime-type for.

Returns

Hash

The mime type information.



101
102
103
 
# File 'lib/merb-core/controller/mime.rb', line 101

def mime_by_request_header(header)
  available_mime_types.find {|key,info| info[:accepts].include?(header)}.first
end

.mime_transform_method(key) ⇒ Object

Parameters

key<Symbol>

The key that represents the mime-type.

Returns

Symbol

The transform method for the mime type, e.g. :to_json.

Raises

ArgumentError

The requested mime type is not valid.

Raises:

  • (ArgumentError) 


89
90
91
92
 
# File 'lib/merb-core/controller/mime.rb', line 89

def mime_transform_method(key)
  raise ArgumentError, ":#{key} is not a valid MIME-type" unless ResponderMixin::TYPES.key?(key)
  ResponderMixin::TYPES[key][:transform_method]
end

.push_path(type, path, file_glob = "**/*.rb") ⇒ Object

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”.



173
174
175
176
 
# File 'lib/merb-core.rb', line 173

def push_path(type, path, file_glob = "**/*.rb")
  enforce!(type => Symbol)
  load_paths[type] = [Pathname.new(path), file_glob]
end

.rakefiles ⇒ Object

Returns

Array(String)

Paths Rakefiles are loaded from.

Notes

Recommended way to find out what paths Rakefiles are loaded from.



558
559
560
 
# File 'lib/merb-core.rb', line 558

def rakefiles
  @rakefiles ||= ['merb-core' / 'test' / 'tasks' / 'spectasks']
end

.register_session_type(name, file, description = nil) ⇒ Object

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.



361
362
363
364
365
366
367
 
# File 'lib/merb-core.rb', line 361

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

.reload ⇒ Object

Reload application and framework classes. See Merb::BootLoader::ReloadClasses for details.



473
474
475
 
# File 'lib/merb-core.rb', line 473

def reload
  Merb::BootLoader::ReloadClasses.reload
end

.remove_mime_type(key) ⇒ Object

Removes a MIME-type from the mime-type list.

Parameters

key<Symbol>

The key that represents the mime-type to remove.

Notes

:all is the key for /; It can’t be removed.



76
77
78
79
 
# File 'lib/merb-core/controller/mime.rb', line 76

def remove_mime_type(key)
  return false if key == :all
  ResponderMixin::TYPES.delete(key)
end

.remove_paths(*args) ⇒ Object

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.



195
196
197
 
# File 'lib/merb-core.rb', line 195

def remove_paths(*args)
  args.each {|arg| load_paths.delete(arg)}
end

.restart_environment(argv = {}) ⇒ Object

Restart the Merb environment explicitly.

Parameters

argv<String, Hash>

The config arguments to restart Merb with. Defaults to Merb::Config.



112
113
114
115
 
# File 'lib/merb-core.rb', line 112

def restart_environment(argv={})
  @started = false
  start_environment(Merb::Config.to_hash.merge(argv))
end

.root ⇒ Object

Returns

String

The Merb root path.



219
220
221
222
223
 
# File 'lib/merb-core.rb', line 219

def root
  app_root = @root || Merb::Config[:merb_root] || Dir.pwd

  Pathname.new(app_root)
end

.root=(value) ⇒ Object

Parameters

value<String>

Path to the root directory.



227
228
229
 
# File 'lib/merb-core.rb', line 227

def root=(value)
  @root = Pathname.new(value)
end

.root_path(*path) ⇒ Object

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"



245
246
247
 
# File 'lib/merb-core.rb', line 245

def root_path(*path)
  Pathname.new(File.join(root, *path))
end

.start(argv = ARGV) ⇒ Object

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.



77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/merb-core.rb', line 77

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_environment(argv = ARGV) ⇒ Object

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.



100
101
102
103
104
105
 
# File 'lib/merb-core.rb', line 100

def start_environment(argv=ARGV)
  unless (@started ||= false)
    start(argv)
    @started = true
  end
end

.testing? ⇒ Boolean

Returns

Boolean

True if Merb environment is testing for instance,

Merb is running with RSpec, Test::Unit of other testing facility.

Returns:

  • (Boolean) 


480
481
482
 
# File 'lib/merb-core.rb', line 480

def testing?
  $TESTING || Merb::Config[:testing]
end