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/rack/helpers.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/stream_wrapper.rb,
lib/merb-core/test/test_ext/rspec.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/adapter/abstract.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/test/helpers/cookie_jar.rb,
lib/merb-core/dispatch/request_parsers.rb,
lib/merb-core/dispatch/router/behavior.rb,
lib/merb-core/rack/middleware/profiler.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/test/helpers/mock_request_helper.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 and lowered memory consumption. Every time Ruby VM comes across a string or a number or a regexp literal, new object is created.
This means if you refer to the same string 6 times per request and your application takes 100 requests per second, there are 600 objects for weak MRI garbage collector to work on.
GC cycles take up to 80% (!) time of request processing in some cases. Eventually Rubinius and maybe MRI 2.0 gonna improve this situation but at the moment, all commonly used strings, regexp and numbers used as constants so no extra objects created and VM just operates pointers.
Defined Under Namespace
Modules: AuthenticationMixin, ConditionalGetMixin, Const, ControllerExceptions, ControllerMixin, CookiesMixin, GlobalHelpers, InlineTemplates, MemcacheStore, Parse, Plugins, Rack, RakeHelper, RenderMixin, ResponderMixin, Session, SessionMixin, Template, Test Classes: AcceptType, BootLoader, Config, Controller, CookieSession, Cookies, Counter, Dispatcher, Logger, MemcacheSession, MemorySession, MemorySessionStore, Request, ReservedError, Responder, Router, Server, SessionContainer, SessionStoreContainer, Worker
Constant Summary collapse
- VERSION =
'1.0.3'
- DM_VERSION =
'0.9.7'
Class Attribute Summary collapse
-
.adapter ⇒ Object
:api: public.
-
.environment ⇒ Object
(also: env)
:api: public.
-
.environment_info ⇒ Object
:api: private.
-
.exiting ⇒ Object
Returns the value of attribute exiting.
-
.klass_hashes ⇒ Object
Set up default variables under Merb.
-
.load_paths ⇒ Object
:api: private.
-
.orm ⇒ Object
Returns the default ORM for this application.
-
.started ⇒ Object
(also: started?)
:api: private.
-
.template_engine ⇒ Object
Returns the default template engine for this application.
-
.test_framework ⇒ Object
Returns the default test framework for this application.
Class Method Summary collapse
-
.add_generators(*generators) ⇒ Object
Parameters *generators:: Generator paths to add to the list of generators.
-
.add_mime_type(key, transform_method, mimes, new_response_headers = {}, default_quality = 1, &block) ⇒ Object
Any specific outgoing headers should be included here.
-
.add_rakefiles(*rakefiles) ⇒ Object
Parameters *rakefiles:: Rakefile paths to add to the list of Rakefiles.
-
.at_exit(&blk) ⇒ Object
Register a proc to run when Merb is exiting gracefully.
-
.at_exit_procs ⇒ Object
The list of procs that have been registered with Merb to run when Merb exits gracefully.
-
.available_accepts ⇒ Object
Returns Hash=> Symbol:: A hash mapping Content-Type values to the mime type key of the appropriate entry in #available_mime_types.
-
.available_mime_types ⇒ Object
Returns a hash of the available mime types.
-
.bundled? ⇒ Boolean
Returns Boolean:: True if Merb is running as an application with bundled gems.
-
.config(&block) ⇒ Object
If block was given configures using the block.
-
.deferred_actions ⇒ Object
Returns RegExp:: Regular expression against which deferred actions are matched by Rack application handler.
-
.dir_for(type) ⇒ Object
Parameters type<Symbol>:: The type of path to retrieve directory for, e.g.
-
.disable(*components) ⇒ Object
Disables the given core components, like a Gem for example.
-
.disabled?(*components) ⇒ Boolean
Returns Boolean:: True if all components (or just one) are disabled.
-
.disabled_components ⇒ Object
Returns Array:: All components that have been disabled.
-
.disabled_components=(components) ⇒ Object
Parameters Array:: All components that should be disabled.
-
.env?(env) ⇒ Boolean
Ask the question about which environment you’re in.
-
.exception(e) ⇒ Object
Required to show exceptions in the log file.
-
.fatal!(str, e = nil) ⇒ Object
Perform a hard Exit.
-
.forking_environment? ⇒ Boolean
:api: plugin.
-
.framework_root ⇒ Object
Returns String:: The path of root directory of the Merb framework.
-
.generators ⇒ Object
Returns Array(String):: Paths generators are loaded from.
-
.glob_for(type) ⇒ Object
Parameters type<Symbol>:: The type of path to retrieve glob for, e.g.
-
.load_config(options = {}) ⇒ Object
Load configuration and assign the logger.
-
.load_dependencies(options = {}) ⇒ Object
Load all basic dependencies (selected BootLoaders only).
-
.log_path ⇒ Object
Returns String:: Path to the log directory which contains the log file.
-
.log_stream(port = "main") ⇒ Object
Returns String:: The path to the log file.
-
.logger ⇒ Object
Return the Merb Logger object for the current thread.
-
.merge_env(env, use_db = false) ⇒ Object
Merge environment settings.
-
.mime_transform_method(key) ⇒ Object
Parameters key<Symbol>:: The key that represents the mime-type.
-
.on_jruby? ⇒ Boolean
:api: plugin.
-
.on_windows? ⇒ Boolean
:api: plugin.
- .orm_generator_scope ⇒ Object deprecated Deprecated.
-
.print_colorized_backtrace(e) ⇒ Object
Print a colorized backtrace to the merb logger.
-
.push_path(type, path, file_glob = "**/*.rb") ⇒ Object
This is the mechanism for setting up your application layout.
-
.rakefiles ⇒ Object
Returns Array(String):: Paths Rakefiles are loaded from.
-
.reload ⇒ Object
Reload application and framework classes.
-
.remove_mime_type(key) ⇒ Object
Removes a MIME-type from the mime-type list.
-
.remove_paths(*args) ⇒ Object
Removes given types of application components from load path Merb uses for autoloading.
-
.reset_logger! ⇒ Object
Removes the logger for the current thread (nil).
-
.restart_environment(argv = {}) ⇒ Object
Restart the Merb environment explicitly.
-
.root ⇒ Object
Returns String:: The Merb root path.
-
.root=(value) ⇒ Object
Parameters value<String>:: Path to the root directory.
-
.root_path(*path) ⇒ Object
Parameters *path:: The relative path (or list of path components) to a directory under the root of the application.
- .run_later(&blk) ⇒ Object
-
.start(argv = ARGV) ⇒ Object
Start Merb by setting up the Config and then starting the server.
-
.start_environment(argv = ARGV) ⇒ Object
Start the Merb environment, but only if it hasn’t been loaded yet.
- .test_framework_generator_scope ⇒ Object deprecated Deprecated.
-
.testing? ⇒ Boolean
Returns Boolean:: True if Merb environment is testing for instance, Merb is running with RSpec, Test::Unit of other testing facility.
-
.trap(signal, &block) ⇒ Object
- Install a signal handler for a given signal unless signals have been disabled with Merb.disable(:signals) ==== Parameters signal
-
The name of the signal to install a handler for.
Class Attribute Details
.adapter ⇒ Object
:api: public
199 200 201 |
# File 'lib/merb-core.rb', line 199 def adapter @adapter end |
.environment ⇒ Object Also known as: env
:api: public
199 200 201 |
# File 'lib/merb-core.rb', line 199 def environment @environment end |
.environment_info ⇒ Object
:api: private
201 202 203 |
# File 'lib/merb-core.rb', line 201 def environment_info @environment_info end |
.exiting ⇒ Object
Returns the value of attribute exiting.
44 45 46 |
# File 'lib/merb-core.rb', line 44 def exiting @exiting end |
.klass_hashes ⇒ Object
Set up default variables under Merb
471 472 473 |
# File 'lib/merb-core.rb', line 471 def klass_hashes @klass_hashes end |
.load_paths ⇒ Object
:api: private
201 202 203 |
# File 'lib/merb-core.rb', line 201 def load_paths @load_paths end |
.orm ⇒ Object
Returns the default ORM for this application. For instance, :datamapper.
Returns
- <Symbol>
-
default ORM.
:api: public
471 472 473 |
# File 'lib/merb-core.rb', line 471 def orm @orm end |
.started ⇒ Object Also known as: started?
:api: private
201 202 203 |
# File 'lib/merb-core.rb', line 201 def started @started end |
.template_engine ⇒ Object
Returns the default template engine for this application. For instance :haml.
Returns
- <Symbol>
-
default template engine.
:api: public
471 472 473 |
# File 'lib/merb-core.rb', line 471 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.
:api: public
471 472 473 |
# File 'lib/merb-core.rb', line 471 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.
:api: public
750 751 752 753 |
# File 'lib/merb-core.rb', line 750 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)
Returns
nil
:api: public
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 |
# File 'lib/merb-core/controller/mime.rb', line 70 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 nil end |
.add_rakefiles(*rakefiles) ⇒ Object
Parameters
- *rakefiles
-
Rakefile paths to add to the list of Rakefiles.
Notes
Recommended way to add Rakefiles load path for plugins authors.
:api: public
738 739 740 741 |
# File 'lib/merb-core.rb', line 738 def add_rakefiles(*rakefiles) @rakefiles ||= [] @rakefiles += rakefiles end |
.at_exit(&blk) ⇒ Object
Register a proc to run when Merb is exiting gracefully. It will not be run when Merb exits quickly.
Returns
- Array
-
The current list of procs to run when Merb exits gracefully
:api: plugin
85 86 87 |
# File 'lib/merb-core.rb', line 85 def at_exit(&blk) self.at_exit_procs << blk end |
.at_exit_procs ⇒ Object
The list of procs that have been registered with Merb to run when Merb exits gracefully.
Returns
- Array
-
The current list of procs
:api: private
53 54 55 |
# File 'lib/merb-core.rb', line 53 def at_exit_procs @at_exit_procs ||= [] end |
.available_accepts ⇒ Object
Returns
- Hash=> Symbol
-
A hash mapping Content-Type values to the mime type key of the appropriate entry in #available_mime_types
:api: public
30 31 32 |
# File 'lib/merb-core/controller/mime.rb', line 30 def available_accepts ResponderMixin::MIMES end |
.available_mime_types ⇒ Object
Returns a hash of the available mime types.
Returns
- Hash=> Hash{Symbol => Object}
-
The available mime types.
Notes
Each entry corresponds to a call to add_mime_type, having the mime type key (:html, :xml, :json, etc.) as the key and a hash containing the following entries:
:accepts # the mime types that will be recognized by this entry
:transform_method # the method called on an object to convert it to content of this type (such as to_json)
:content_type # the value set to the "Content-Type" HTTP header when this mime is sent in a response
:response_headers # sent in a response using this content type
:default_quality # the scale factor used in describing content type preference
:response_block # the block to be called with the controller when a request responds to this mime type
:api: public
21 22 23 |
# File 'lib/merb-core/controller/mime.rb', line 21 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. It is a good practice to freeze application framework and gems and is very useful when application is run in some sort of sandbox, for instance, shared hosting with preconfigured gems.
:api: public
528 529 530 |
# File 'lib/merb-core.rb', line 528 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
:api: public
669 670 671 672 |
# File 'lib/merb-core.rb', line 669 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.
:api: public
426 427 428 429 430 431 432 433 434 |
# File 'lib/merb-core.rb', line 426 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.
:api: public
295 296 297 |
# File 'lib/merb-core.rb', line 295 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.
:api: public
680 681 682 |
# File 'lib/merb-core.rb', line 680 def disable(*components) disabled_components.push(*components) end |
.disabled?(*components) ⇒ Boolean
Returns
- Boolean
-
True if all components (or just one) are disabled.
:api: public
704 705 706 |
# File 'lib/merb-core.rb', line 704 def disabled?(*components) components.all? { |c| disabled_components.include?(c) } end |
.disabled_components ⇒ Object
Returns
- Array
-
All components that have been disabled.
:api: public
696 697 698 |
# File 'lib/merb-core.rb', line 696 def disabled_components Merb::Config[:disabled_components] ||= [] end |
.disabled_components=(components) ⇒ Object
Parameters
- Array
-
All components that should be disabled.
:api: public
688 689 690 |
# File 'lib/merb-core.rb', line 688 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
:api: public
640 641 642 |
# File 'lib/merb-core.rb', line 640 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
:api: plugin
346 347 348 349 |
# File 'lib/merb-core/controller/exceptions.rb', line 346 def self.exception(e) "#{ e. } - (#{ e.class })\n" << "#{(e.backtrace or []).join("\n")}" end |
.fatal!(str, e = nil) ⇒ Object
Perform a hard Exit. Print a backtrace to the merb logger before exiting if verbose is enabled.
:api: private
440 441 442 443 444 445 446 447 448 449 450 451 452 |
# File 'lib/merb-core.rb', line 440 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] if Merb::Config[:show_ugly_backtraces] raise e else exit(1) end end |
.forking_environment? ⇒ Boolean
:api: plugin
769 770 771 |
# File 'lib/merb-core.rb', line 769 def forking_environment? !on_windows? && !on_jruby? end |
.framework_root ⇒ Object
Returns
- String
-
The path of root directory of the Merb framework.
:api: public
413 414 415 |
# File 'lib/merb-core.rb', line 413 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.
:api: public
727 728 729 |
# File 'lib/merb-core.rb', line 727 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.
:api: public
306 307 308 |
# File 'lib/merb-core.rb', line 306 def glob_for(type) Merb.load_paths[type][1] end |
.load_config(options = {}) ⇒ Object
Load configuration and assign the 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_stream<IO>
-
IO handle for logger. Defaults to STDOUT.
- :log_file<String>
-
File path for logger. Overrides :log_stream.
- :log_level<Symbol>
-
logger level, default is :info
- :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.
:api: public
591 592 593 594 |
# File 'lib/merb-core.rb', line 591 def load_config( = {}) Merb::Config.setup(Merb::Config.defaults.merge()) 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.
:api: public
606 607 608 609 610 611 |
# File 'lib/merb-core.rb', line 606 def load_dependencies( = {}) load_config() Merb::BootLoader::BuildFramework.run Merb::BootLoader::Dependencies.run Merb::BootLoader::BeforeAppLoads.run end |
.log_path ⇒ Object
Returns
- String
-
Path to the log directory which contains the log file.
:api: public
402 403 404 405 406 407 |
# File 'lib/merb-core.rb', line 402 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
.
Notes
When Merb.testing? the port is modified to become :test - this keeps this special environment situation from ending up in the memoized @streams just once, thereby never taking changes into account again. Now, it will be memoized as :test - and just logging to merb_test.log.
:api: public
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 |
# File 'lib/merb-core.rb', line 371 def log_stream(port = "main") port = :test if Merb.testing? @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
Return the Merb Logger object for the current thread. Set it up if it does not exist.
:api: public
348 349 350 |
# File 'lib/merb-core.rb', line 348 def logger Thread.current[:merb_logger] ||= Merb::Logger.new end |
.merge_env(env, use_db = false) ⇒ Object
Merge environment settings
This can allow you to have a “localdev” environment that runs like your “development”.
OR
A “staging” environment that runs identical to your “production” environment.
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 do |c|
c[:log_level] = "debug" # except we want debug log level
c[:log_stream] = @some_io # and log to this IO handle
c[:exception_details] = true # and we want to see exception details
end
Parameters
- env<~String>
-
Environment to run like
- use_db<~Boolean>
-
Should Merb use the merged environments DB connection
Defaults to +false+
:api: public
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 |
# File 'lib/merb-core.rb', line 111 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_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.
:api: private
129 130 131 132 |
# File 'lib/merb-core/controller/mime.rb', line 129 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 |
.on_jruby? ⇒ Boolean
:api: plugin
774 775 776 |
# File 'lib/merb-core.rb', line 774 def on_jruby? RUBY_PLATFORM =~ Merb::Const::JAVA_PLATFORM_REGEXP end |
.on_windows? ⇒ Boolean
:api: plugin
779 780 781 |
# File 'lib/merb-core.rb', line 779 def on_windows? RUBY_PLATFORM =~ Merb::Const::WIN_PLATFORM_REGEXP end |
.orm_generator_scope ⇒ Object
484 485 486 487 488 |
# File 'lib/merb-core.rb', line 484 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
Print a colorized backtrace to the merb logger.
:api: private
457 458 459 460 461 462 463 464 465 466 467 468 |
# File 'lib/merb-core.rb', line 457 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.}\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 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
-
Camping-style “very flat” application layout, where the whole Merb
application and configs are contained within a single file.
Notes
Autoloading for lib uses an 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”.
:api: public
261 262 263 264 |
# File 'lib/merb-core.rb', line 261 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.
:api: public
716 717 718 |
# File 'lib/merb-core.rb', line 716 def rakefiles @rakefiles ||= [] end |
.reload ⇒ Object
Reload application and framework classes. See Merb::BootLoader::ReloadClasses for details.
:api: public
617 618 619 |
# File 'lib/merb-core.rb', line 617 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.
Returns
- (Boolean, Hash=> Object)
-
If it was present, the old specification of the MIME-type. Same structure
as a value in Merb.available_mime_types. False if the key was not present.
Notes
:all is the key for /; It can’t be removed.
:api: public
114 115 116 117 |
# File 'lib/merb-core/controller/mime.rb', line 114 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)>
-
component(s) 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.
:api: public
284 285 286 |
# File 'lib/merb-core.rb', line 284 def remove_paths(*args) args.each {|arg| load_paths.delete(arg)} end |
.reset_logger! ⇒ Object
Removes the logger for the current thread (nil).
:api: public
355 356 357 |
# File 'lib/merb-core.rb', line 355 def reset_logger! Thread.current[:merb_logger] = nil 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
.
:api: public
193 194 195 196 |
# File 'lib/merb-core.rb', line 193 def restart_environment(argv={}) @started = false start_environment(Merb::Config.to_hash.merge(argv)) end |
.root ⇒ Object
Returns
- String
-
The Merb root path.
:api: public
314 315 316 |
# File 'lib/merb-core.rb', line 314 def root @root || Merb::Config[:merb_root] || File.(Dir.pwd) end |
.root=(value) ⇒ Object
Parameters
- value<String>
-
Path to the root directory.
:api: public
322 323 324 |
# File 'lib/merb-core.rb', line 322 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"
340 341 342 |
# File 'lib/merb-core.rb', line 340 def root_path(*path) File.join(root, *path) end |
.run_later(&blk) ⇒ Object
783 784 785 |
# File 'lib/merb-core.rb', line 783 def run_later(&blk) Merb::Dispatcher.work_queue << blk end |
.start(argv = ARGV) ⇒ Object
Start Merb by setting up the Config and then starting the server. Set the Merb application environment and the root path.
Parameters
- argv<String, Hash>
-
The config arguments to start Merb with. Defaults to
ARGV
.
:api: public
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 |
# File 'lib/merb-core.rb', line 148 def start(argv = ARGV) Merb::Config[:original_log_stream] = Merb::Config[:log_stream] Merb::Config[:log_stream] ||= STDOUT if Hash === argv Merb::Config.setup(argv) elsif !argv.nil? 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]) @started = true 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
.
:api: public
182 183 184 |
# File 'lib/merb-core.rb', line 182 def start_environment(argv=ARGV) start(argv) unless (@started ||= false) end |
.test_framework_generator_scope ⇒ Object
501 502 503 504 |
# File 'lib/merb-core.rb', line 501 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.
:api: public
626 627 628 |
# File 'lib/merb-core.rb', line 626 def testing? $TESTING ||= env?(:test) || Merb::Config[:testing] end |
.trap(signal, &block) ⇒ Object
Install a signal handler for a given signal unless signals have been disabled with Merb.disable(:signals)
Parameters
- signal
-
The name of the signal to install a handler for.
- &block
-
The block to be run when the given signal is received.
:api: public
762 763 764 765 766 |
# File 'lib/merb-core.rb', line 762 def trap(signal, &block) if Signal.list.include?(signal) Kernel.trap(signal, &block) unless Merb.disabled?(:signals) end end |