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/test/run_specs.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/dispatch/dispatcher.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/rack/middleware/csrf.rb,
lib/merb-core/controller/exceptions.rb,
lib/merb-core/dispatch/router/route.rb,
lib/merb-core/rack/middleware/static.rb,
lib/merb-core/rack/middleware/tracer.rb,
lib/merb-core/tasks/merb_rake_helper.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/dispatch/router/resources.rb,
lib/merb-core/test/helpers/route_helper.rb,
lib/merb-core/dispatch/session/container.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/rack/middleware/content_length.rb,
lib/merb-core/test/helpers/controller_helper.rb,
lib/merb-core/rack/middleware/conditional_get.rb,
lib/merb-core/dispatch/session/store_container.rb,
lib/merb-core/rack/adapter/swiftiplied_mongrel.rb,
lib/merb-core/dispatch/default_exception/default_exception.rb,
lib/merb-core/rack/handler/mongrel.rb

Overview

Most of this list is simply constants frozen for efficiency

Defined Under Namespace

Modules: AuthenticationMixin, ConditionalGetMixin, Const, ControllerExceptions, ControllerMixin, CookiesMixin, GlobalHelpers, InlineTemplates, MemcacheStore, Plugins, Rack, RakeHelper, RenderMixin, ResponderMixin, Session, SessionMixin, Template, Test Classes: AcceptType, BootLoader, Config, Controller, CookieSession, Cookies, Counter, Dispatcher, Logger, MemcacheSession, MemorySession, MemorySessionStore, Request, Responder, Router, Server, SessionContainer, SessionStoreContainer, Worker

Constant Summary collapse

VERSION = 
'0.9.8'

Class Attribute Summary collapse

Class Method Summary collapse

Class Attribute Details

.adapter ⇒ Object

Returns the value of attribute adapter.



141
142
143
 
# File 'lib/merb-core.rb', line 141

def adapter
  @adapter
end

.environment ⇒ Object Also known as: env

Returns the value of attribute environment.



141
142
143
 
# File 'lib/merb-core.rb', line 141

def environment
  @environment
end

.environment_info ⇒ Object

Returns the value of attribute environment_info.



141
142
143
 
# File 'lib/merb-core.rb', line 141

def environment_info
  @environment_info
end

.exiting ⇒ Object

Returns the value of attribute exiting.



39
40
41
 
# File 'lib/merb-core.rb', line 39

def exiting
  @exiting
end

.klass_hashes ⇒ Object

Set up default variables under Merb



390
391
392
 
# File 'lib/merb-core.rb', line 390

def klass_hashes
  @klass_hashes
end

.load_paths ⇒ Object

Returns the value of attribute load_paths.



141
142
143
 
# File 'lib/merb-core.rb', line 141

def load_paths
  @load_paths
end

.orm ⇒ Object

Returns the default ORM for this application. For instance, :datamapper.

Returns

<Symbol>

default ORM.



390
391
392
 
# File 'lib/merb-core.rb', line 390

def orm
  @orm
end

.started ⇒ Object Also known as: started?

Returns the value of attribute started.



141
142
143
 
# File 'lib/merb-core.rb', line 141

def started
  @started
end

.template_engine ⇒ Object

Returns the default template engine for this application. For instance :haml.

Returns

<Symbol>

default template engine.



390
391
392
 
# File 'lib/merb-core.rb', line 390

def template_engine
  @template_engine
end

.test_framework ⇒ Object

Returns the default test framework for this application. For instance :rspec.

Returns

<Symbol>

default test framework.



390
391
392
 
# File 'lib/merb-core.rb', line 390

def test_framework
  @test_framework
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.



632
633
634
635
 
# File 'lib/merb-core.rb', line 632

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

.add_mime_type(key, transform_method, mimes, new_response_headers = {}, default_quality = 1, &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)



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

def add_mime_type(key, transform_method, mimes, new_response_headers = {}, default_quality = 1, &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,
     :default_quality   => default_quality,
     :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.



622
623
624
625
 
# File 'lib/merb-core.rb', line 622

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

.available_accepts ⇒ Object 



10
11
12
 
# File 'lib/merb-core/controller/mime.rb', line 10

def available_accepts
  ResponderMixin::MIMES
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

.bundled? ⇒ Boolean

Returns

Boolean

True if Merb is running as an application with bundled gems.

Notes

Bundling required gems makes your application independent from the 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) 


439
440
441
 
# File 'lib/merb-core.rb', line 439

def bundled?
  $BUNDLE || ENV.key?("BUNDLE")
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
  exception_details  true
  reload_classes     true
  reload_time        0.5
end



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

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.



335
336
337
338
339
340
341
342
343
 
# File 'lib/merb-core.rb', line 335

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.



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

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.



575
576
577
 
# File 'lib/merb-core.rb', line 575

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

.disabled?(*components) ⇒ Boolean

Returns

Boolean

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

Returns:

  • (Boolean) 


593
594
595
 
# File 'lib/merb-core.rb', line 593

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

.disabled_components ⇒ Object

Returns

Array

All components that have been disabled.



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

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

.disabled_components=(components) ⇒ Object

Parameters

Array

All components that should be disabled.



581
582
583
 
# File 'lib/merb-core.rb', line 581

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) 


539
540
541
 
# File 'lib/merb-core.rb', line 539

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

.fatal!(str, e = nil) ⇒ Object 



367
368
369
370
371
372
373
374
 
# File 'lib/merb-core.rb', line 367

def fatal!(str, e = nil)
  Merb.logger.fatal!
  Merb.logger.fatal!("\e[1;31;47mFATAL: #{str}\e[0m")
  Merb.logger.fatal!

  print_colorized_backtrace(e) if e && Merb::Config[:verbose]
  exit(1)
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.



352
353
354
355
356
357
358
359
360
361
362
363
364
365
 
# File 'lib/merb-core.rb', line 352

def flat!(framework = {})
  default = {
    :framework => { :public => [Merb.root / "public", nil] },
    :session_store => 'none',
    :exception_details => true
  }
        
  Merb::Config[:framework] = default.merge(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.



323
324
325
 
# File 'lib/merb-core.rb', line 323

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

.generators ⇒ Object

Returns

Array(String)

Paths generators are loaded from

Notes

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



613
614
615
 
# File 'lib/merb-core.rb', line 613

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.



237
238
239
 
# File 'lib/merb-core.rb', line 237

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)

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



498
499
500
501
 
# File 'lib/merb-core.rb', line 498

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.



511
512
513
514
515
516
 
# File 'lib/merb-core.rb', line 511

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

.log_path ⇒ Object

Returns

String

Path to directory that contains the log file.



314
315
316
317
318
319
 
# File 'lib/merb-core.rb', line 314

def log_path
  case Merb::Config[:log_file]
  when String then File.dirname(Merb::Config[:log_file])
  else Merb.root_path("log")
  end
end

.log_stream(port = "main") ⇒ Object

Returns

String

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



286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
 
# File 'lib/merb-core.rb', line 286

def log_stream(port = "main")
  @streams ||= {}
  @streams[port] ||= begin
    log = if Merb.testing?
      log_path / "merb_test.log"
    elsif !Merb::Config[:daemonize] && !Merb::Config[:force_logging]
      STDOUT
    else
      log_path / "merb.#{port}.log"
    end
    
    if log.is_a?(IO)
      stream = log
    elsif File.exist?(log)
      stream = File.open(log, (File::WRONLY | File::APPEND))
    else
      FileUtils.mkdir_p(File.dirname(log))
      stream = File.open(log, (File::WRONLY | File::APPEND | File::CREAT))
      stream.write("#{Time.now.httpdate} #{Merb::Config[:log_delimiter]} " \
        "info #{Merb::Config[:log_delimiter]} Logfile created\n")
    end
    stream.sync = true
    stream
  end
end

.logger ⇒ Object

Logger settings



272
273
274
 
# File 'lib/merb-core.rb', line 272

def logger
  Thread.current[:merb_logger] ||= Merb::Logger.new
end

.logger=(obj) ⇒ Object 



276
277
278
279
280
 
# File 'lib/merb-core.rb', line 276

def logger=(obj)
  unless obj
    Thread.current[:merb_logger] = nil
  end
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+



59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/merb-core.rb', line 59

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.



106
107
108
 
# File 'lib/merb-core/controller/mime.rb', line 106

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) 


94
95
96
97
 
# File 'lib/merb-core/controller/mime.rb', line 94

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

.orm_generator_scope ⇒ Object

Deprecated. 


401
402
403
404
405
 
# File 'lib/merb-core.rb', line 401

def orm_generator_scope
  Merb.logger.warn!("WARNING: Merb.orm_generator_scope is deprecated")
  return :merb_default if Merb.orm == :none
  Merb.orm
end

.print_colorized_backtrace(e) ⇒ Object 



376
377
378
379
380
381
382
383
384
385
386
387
 
# File 'lib/merb-core.rb', line 376

def print_colorized_backtrace(e)
  e.backtrace.map! do |line|
    line.gsub!(/^#{Merb.framework_root}/, "\e[34mFRAMEWORK_ROOT\e[31m")
  end
  
  Merb.logger.fatal! "\e[34mFRAMEWORK_ROOT\e[0m = #{Merb.framework_root}"
  Merb.logger.fatal!
  Merb.logger.fatal! "\e[31m#{e.class}: \e[1;31;47m#{e.message}\e[0m"
  e.backtrace.each do |line|
    Merb.logger.fatal! "\e[31m#{line}\e[0m"
  end      
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”.



197
198
199
200
 
# File 'lib/merb-core.rb', line 197

def push_path(type, path, file_glob = "**/*.rb")
  enforce!(type => Symbol)
  load_paths[type] = [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.



603
604
605
 
# File 'lib/merb-core.rb', line 603

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

.reload ⇒ Object

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



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

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.



81
82
83
84
 
# File 'lib/merb-core/controller/mime.rb', line 81

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.



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

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.



136
137
138
139
 
# File 'lib/merb-core.rb', line 136

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

.root ⇒ Object

Returns

String

The Merb root path.



243
244
245
 
# File 'lib/merb-core.rb', line 243

def root
  @root || Merb::Config[:merb_root] || File.expand_path(Dir.pwd)
end

.root=(value) ⇒ Object

Parameters

value<String>

Path to the root directory.



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

def root=(value)
  @root = 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"



267
268
269
 
# File 'lib/merb-core.rb', line 267

def root_path(*path)
  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.



95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/merb-core.rb', line 95

def start(argv=ARGV)
  # Hardcode the log stream to STDOUT
  Merb::Config[:log_stream] = STDOUT
  if Hash === argv
    Merb::Config.setup(argv)
  else
    Merb::Config.parse_args(argv)
  end
  Merb::Config[:log_stream] = STDOUT
  
  Merb.environment = Merb::Config[:environment]
  Merb.root = Merb::Config[:merb_root]
  case Merb::Config[:action]
  when :kill
    Merb::Server.kill(Merb::Config[:port], 2)
  when :kill_9
    Merb::Server.kill(Merb::Config[:port], 9)
  when :fast_deploy
    Merb::Server.kill("main", "HUP")
  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.



124
125
126
127
128
129
 
# File 'lib/merb-core.rb', line 124

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

.test_framework_generator_scope ⇒ Object

Deprecated. 


416
417
418
419
 
# File 'lib/merb-core.rb', line 416

def test_framework_generator_scope
  Merb.logger.warn!("WARNING: Merb.test_framework_generator_scope is deprecated")
  Merb.test_framework
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) 


527
528
529
 
# File 'lib/merb-core.rb', line 527

def testing?
  $TESTING ||= env?(:test) || Merb::Config[:testing]
end