Module: Kernel
- Defined in:
- lib/merb-core/core_ext/kernel.rb,
lib/merb-core/test/test_ext/rspec.rb
Instance Method Summary collapse
-
#__caller_info__(i = 1) ⇒ Array[Array]
:api: private.
-
#__caller_lines__(file, line, size = 4) ⇒ Array[Array]
:api: private.
-
#__profile__(name, min = 1, iter = 100) ⇒ String
Takes a block, profiles the results of running the block specified number of times and generates HTML report.
-
#debugger ⇒ Object
Define debugger method so that code even works if debugger was not requested.
-
#dependencies(*args) ⇒ Object
Loads both gem and library dependencies that are passed in as arguments.
-
#dependency(name, *opts, &blk) ⇒ Object
Loads the given string as a gem.
-
#enforce!(opts = {}) ⇒ Object
Checks that the given objects quack like the given conditions.
-
#extract_options_from_args!(args) ⇒ Object
Extracts an options hash if it is the last item in the args array.
- #given(*args, &example_group_block) ⇒ Object
-
#load_dependencies(*args) ⇒ Object
Loads both gem and library dependencies that are passed in as arguments.
-
#load_dependency(name, *ver, &blk) ⇒ Gem::Dependency
Loads the given string as a gem.
- #rescue_require(library, message = nil) ⇒ Object deprecated Deprecated.
-
#track_dependency(name, *ver, &blk) ⇒ Gem::Dependency
Keep track of all required dependencies.
-
#use_orm(orm, &blk) ⇒ Object
Used in Merb.root/config/init.rb to tell Merb which ORM (Object Relational Mapper) you wish to use.
-
#use_template_engine(template_engine, &blk) ⇒ Object
Used in Merb.root/config/init.rb to tell Merb which template engine to prefer.
- #use_test(*args) ⇒ Object
-
#use_testing_framework(test_framework, *test_dependencies) ⇒ Object
Used in Merb.root/config/init.rb to tell Merb which testing framework to use.
Instance Method Details
#__caller_info__(i = 1) ⇒ Array[Array]
:api: private
325 326 327 |
# File 'lib/merb-core/core_ext/kernel.rb', line 325 def __caller_info__(i = 1) file, line, meth = caller[i].scan(/(.*?):(\d+):in `(.*?)'/).first end |
#__caller_lines__(file, line, size = 4) ⇒ Array[Array]
:api: private
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 |
# File 'lib/merb-core/core_ext/kernel.rb', line 350 def __caller_lines__(file, line, size = 4) line = line.to_i if file =~ /\(erubis\)/ yield :error, "Template Error! Problem while rendering", false elsif !File.file?(file) || !File.readable?(file) yield :error, "File `#{file}' not available", false else lines = File.read(file).split("\n") first_line = (f = line - size - 1) < 0 ? 0 : f if first_line.zero? new_size = line - 1 lines = lines[first_line, size + new_size + 1] else new_size = nil lines = lines[first_line, size * 2 + 1] end lines && lines.each_with_index do |str, index| line_n = index + line line_n = (new_size.nil?) ? line_n - size : line_n - new_size yield line_n, str.chomp end end end |
#__profile__(name, min = 1, iter = 100) ⇒ String
Requires ruby-prof (sudo gem install ruby-prof
)
Takes a block, profiles the results of running the block specified number of times and generates HTML report.
:api: private
403 404 405 406 407 408 409 410 411 412 413 414 415 416 |
# File 'lib/merb-core/core_ext/kernel.rb', line 403 def __profile__(name, min=1, iter=100) require 'ruby-prof' unless defined?(RubyProf) return_result = '' result = RubyProf.profile do iter.times{return_result = yield} end printer = RubyProf::GraphHtmlPrinter.new(result) path = File.join(Merb.root, 'log', "#{name}.html") File.open(path, 'w') do |file| printer.print(file, {:min_percent => min, :print_file => true}) end return_result end |
#debugger ⇒ Object
Define debugger method so that code even works if debugger was not requested. Drops a note to the logs that Debugger was not available.
454 455 456 457 458 |
# File 'lib/merb-core/core_ext/kernel.rb', line 454 def debugger Merb.logger.info! "\n***** Debugger requested, but was not " + "available: Start server with --debugger " + "to enable *****\n" end |
#dependencies(*args) ⇒ Object
Loads both gem and library dependencies that are passed in as arguments. Execution is deferred to the Merb::BootLoader::Dependencies.run during bootup.
Parameters
*args<String, Hash, Array> The dependencies to load.
Returns
- Array[(Gem::Dependency, Array)]
-
Gem::Dependencies for the
dependencies specified in args.
:api: public
168 169 170 171 172 173 174 175 176 |
# File 'lib/merb-core/core_ext/kernel.rb', line 168 def dependencies(*args) args.map do |arg| case arg when String then dependency(arg) when Hash then arg.map { |r,v| dependency(r, v) } when Array then arg.map { |r| dependency(r) } end end end |
#dependency(name, *opts, &blk) ⇒ Object
Loads the given string as a gem. Execution is deferred until after the logger has been instantiated and the framework directory structure is defined.
If that has already happened, the gem will be activated immediately, but it will still be registered.
Parameters
name<String> The name of the gem to load. *ver<Gem::Requirement, Gem::Version, Array, #to_str>
Version requirements to be passed to Gem::Dependency.new.
If the last argument is a Hash, extract the :immediate option,
forcing a dependency to load immediately.
Options
:immediate when true, gem is loaded immediately even if framework is not yet ready. :require_as file name to require for this gem.
See examples below.
Notes
If block is given, it is called after require is called. If you use a block to require multiple files, require first using :require_as option and the rest in the block.
Examples
Usage scenario is typically one of the following:
-
Gem name and loaded file names are the same (ex.: amqp gem uses amqp.rb). In this case no extra options needed.
dependency “amqp”
-
Gem name is different from the file needs to be required (ex.: ParseTree gem uses parse_tree.rb as main file).
dependency “ParseTree”, :require_as => “parse_tree”
-
You need to require a number of files from the library explicitly (ex.: cherry pick features from xmpp4r). Pass an array to :require_as.
dependency “xmpp4r”, :require_as => %w(xmpp4r/client xmpp4r/sasl xmpp4r/vcard)
-
You need to require a specific version of the gem.
dependency “RedCloth”, “3.0.4”
-
You want to load dependency as soon as the method is called.
dependency “syslog”, :immediate => true
-
You need to execute some arbitraty code after dependency is loaded:
dependency “ruby-growl” do
g = Growl.new "localhost", "ruby-growl",
["ruby-growl Notification"]
g.notify "ruby-growl Notification", "Ruby-Growl is set up",
"Ruby-Growl is set up"
end
When specifying a gem version to use, you can use the same syntax RubyGems support, for instance, >= 3.0.2 or >~ 1.2.
See rubygems.org/read/chapter/16 for a complete reference.
Returns
- Gem::Dependency
-
The dependency information.
:api: public
110 111 112 113 114 115 116 117 |
# File 'lib/merb-core/core_ext/kernel.rb', line 110 def dependency(name, *opts, &blk) immediate = opts.last.delete(:immediate) if opts.last.is_a?(Hash) if immediate || Merb::BootLoader.finished?(Merb::BootLoader::Dependencies) load_dependency(name, *opts, &blk) else track_dependency(name, *opts, &blk) end end |
#enforce!(opts = {}) ⇒ Object
Checks that the given objects quack like the given conditions.
:api: public
444 445 446 447 448 |
# File 'lib/merb-core/core_ext/kernel.rb', line 444 def enforce!(opts = {}) opts.each do |k,v| raise ArgumentError, "#{k.inspect} doesn't quack like #{v.inspect}" unless k.quacks_like?(v) end end |
#extract_options_from_args!(args) ⇒ Object
Extracts an options hash if it is the last item in the args array. Used internally in methods that take *args.
:api: public
430 431 432 |
# File 'lib/merb-core/core_ext/kernel.rb', line 430 def (args) args.pop if Hash === args.last end |
#given(*args, &example_group_block) ⇒ Object
3 4 5 6 7 8 9 10 11 12 13 14 |
# File 'lib/merb-core/test/test_ext/rspec.rb', line 3 def given(*args, &example_group_block) args << {} unless Hash === args.last params = args.last params[:shared] = true describe(*args) do prepend_before(:each) do self.instance_eval(&example_group_block) end end end |
#load_dependencies(*args) ⇒ Object
Each argument can be:
- String
-
Single dependency.
- Hash
-
Multiple dependencies where the keys are names and the values versions.
- Array
-
Multiple string dependencies.
Loads both gem and library dependencies that are passed in as arguments.
:api: private
194 195 196 197 198 199 200 201 202 |
# File 'lib/merb-core/core_ext/kernel.rb', line 194 def load_dependencies(*args) args.map do |arg| case arg when String then load_dependency(arg) when Hash then arg.map { |r,v| load_dependency(r, v) } when Array then arg.map { |r| load_dependency(r) } end end end |
#load_dependency(name, *ver, &blk) ⇒ Gem::Dependency
If the gem cannot be found, the method will attempt to require the string as a library.
Loads the given string as a gem.
This new version tries to load the file via ROOT/gems first before moving off to the system gems (so if you have a lower version of a gem in ROOT/gems, it’ll still get loaded).
:api: private
137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 |
# File 'lib/merb-core/core_ext/kernel.rb', line 137 def load_dependency(name, *ver, &blk) dep = name.is_a?(Gem::Dependency) ? name : track_dependency(name, *ver, &blk) gem(dep) rescue Gem::LoadError => e Merb.fatal! "The gem #{name}, #{ver.inspect} was not found", e ensure begin require dep.require_as rescue LoadError => e Merb.fatal! "The file #{dep.require_as} was not found", e end if block = dep.require_block block.call end Merb.logger.verbose!("loading gem '#{dep.name}' ...") return dep # ensure needs explicit return end |
#rescue_require(library, message = nil) ⇒ Object
Does a basic require, and prints a message if an error occurs.
:api: private
211 212 213 214 215 216 217 |
# File 'lib/merb-core/core_ext/kernel.rb', line 211 def rescue_require(library, = nil) Merb.logger.warn("Deprecation warning: rescue_require is deprecated") sleep 2.0 require library rescue LoadError, RuntimeError Merb.logger.error!() if end |
#track_dependency(name, *ver, &blk) ⇒ Gem::Dependency
Keep track of all required dependencies.
:api: private
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
# File 'lib/merb-core/core_ext/kernel.rb', line 21 def track_dependency(name, *ver, &blk) = ver.pop if ver.last.is_a?(Hash) new_dep = Gem::Dependency.new(name, ver.empty? ? nil : ver) new_dep.require_block = blk new_dep.require_as = ( && [:require_as]) || name deps = Merb::BootLoader::Dependencies.dependencies idx = deps.each_with_index {|d,i| break i if d.name == new_dep.name} idx = idx.is_a?(Array) ? deps.size + 1 : idx deps.delete_at(idx) deps.insert(idx - 1, new_dep) new_dep end |
#use_orm(orm, &blk) ⇒ Object
Used in Merb.root/config/init.rb to tell Merb which ORM (Object Relational Mapper) you wish to use. Currently Merb has plugins to support ActiveRecord, DataMapper, and Sequel.
Parameters
- orm<Symbol>
-
The ORM to use.
Returns
nil
Example
use_orm :datamapper
# This will use the DataMapper generator for your ORM
$ merb-gen model ActivityEvent
Notes
If for some reason this is called more than once, latter
call takes over other.
:api: public
240 241 242 243 244 245 246 247 248 249 250 |
# File 'lib/merb-core/core_ext/kernel.rb', line 240 def use_orm(orm, &blk) begin Merb.orm = orm orm_plugin = "merb_#{orm}" Kernel.dependency(orm_plugin, &blk) rescue LoadError => e Merb.logger.warn!("The #{orm_plugin} gem was not found. You may need to install it.") raise e end nil end |
#use_template_engine(template_engine, &blk) ⇒ Object
Used in Merb.root/config/init.rb to tell Merb which template engine to prefer.
Parameters
template_engine<Symbol>
The template engine to use.
Returns
nil
Example
use_template_engine :haml
# This will now use haml templates in generators where available.
$ merb-gen resource_controller Project
:api: public
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 |
# File 'lib/merb-core/core_ext/kernel.rb', line 297 def use_template_engine(template_engine, &blk) Merb.template_engine = template_engine if template_engine != :erb if template_engine.in?(:haml, :builder) template_engine_plugin = "merb-#{template_engine}" else template_engine_plugin = "merb_#{template_engine}" end Kernel.dependency(template_engine_plugin, &blk) end nil rescue LoadError => e Merb.logger.warn!("The #{template_engine_plugin} gem was not found. You may need to install it.") raise e end |
#use_test(*args) ⇒ Object
276 277 278 |
# File 'lib/merb-core/core_ext/kernel.rb', line 276 def use_test(*args) use_testing_framework(*args) end |
#use_testing_framework(test_framework, *test_dependencies) ⇒ Object
Used in Merb.root/config/init.rb to tell Merb which testing framework to use. Currently Merb has plugins to support RSpec and Test::Unit.
Parameters
- test_framework<Symbol>
-
The test framework to use. Currently only supports :rspec and :test_unit.
Returns
nil
Example
use_test :rspec
# This will now use the RSpec generator for tests
$ merb-gen model ActivityEvent
:api: public
269 270 271 272 273 274 |
# File 'lib/merb-core/core_ext/kernel.rb', line 269 def use_testing_framework(test_framework, *test_dependencies) Merb.test_framework = test_framework Kernel.dependencies test_dependencies if Merb.env == "test" || Merb.env.nil? nil end |