Module: Padrino

Extended by:
Configuration, Loader
Defined in:
lib/padrino-core/version.rb,
lib/padrino-core.rb,
lib/padrino-core/tasks.rb,
lib/padrino-core/caller.rb,
lib/padrino-core/filter.rb,
lib/padrino-core/loader.rb,
lib/padrino-core/logger.rb,
lib/padrino-core/module.rb,
lib/padrino-core/router.rb,
lib/padrino-core/server.rb,
lib/padrino-core/command.rb,
lib/padrino-core/mounter.rb,
lib/padrino-core/cli/base.rb,
lib/padrino-core/reloader.rb,
lib/padrino-core/application.rb,
lib/padrino-core/cli/adapter.rb,
lib/padrino-core/cli/binstub.rb,
lib/padrino-core/path_router.rb,
lib/padrino-core/cli/launcher.rb,
lib/padrino-core/configuration.rb,
lib/padrino-core/reloader/rack.rb,
lib/padrino-core/reloader/storage.rb,
lib/padrino-core/application/flash.rb,
lib/padrino-core/path_router/route.rb,
lib/padrino-core/application/routing.rb,
lib/padrino-core/path_router/matcher.rb,
lib/padrino-core/path_router/compiler.rb,
lib/padrino-core/path_router/error_handler.rb,
lib/padrino-core/application/show_exceptions.rb,
lib/padrino-core/application/application_setup.rb,
lib/padrino-core/application/params_protection.rb,
lib/padrino-core/mounter/application_extension.rb,
lib/padrino-core/application/authenticity_token.rb

Overview

Manages current Padrino version for use in gem generation.

We put this in a separate file so you can get padrino version without include full padrino core.

Defined Under Namespace

Modules: ApplicationSetup, Cli, Configuration, Flash, Loader, Module, ParamsProtection, PathRouter, Reloader, Routing, Tasks Classes: Application, ApplicationLoadError, AuthenticityToken, Filter, Logger, Mounter, Router, Server, ShowExceptions

Constant Summary collapse

PADRINO_IGNORE_CALLERS =

List of callers in a Padrino application that should be ignored as part of a stack trace.

[
  %r{lib/padrino-.*$},
  %r{/padrino-.*/(lib|bin)},
  %r{/bin/padrino$},
  %r{/sinatra(/(base|main|show_?exceptions))?\.rb$},
  %r{lib/tilt.*\.rb$},
  %r{lib/rack.*\.rb$},
  %r{lib/mongrel.*\.rb$},
  %r{lib/shotgun.*\.rb$},
  %r{bin/shotgun$},
  %r{\(.*\)},
  %r{shoulda/context\.rb$},
  %r{mocha/integration},
  %r{test/unit},
  %r{rake_test_loader\.rb},
  %r{custom_require\.rb$},
  %r{active_support},
  %r{/thor},
  %r{/lib/bundler},
]
VERSION =

The version constant for the current version of Padrino.

'0.15.3'

Class Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Configuration

config, configure

Methods included from Loader

after_load, before_load, called_from, clear!, dependency_paths, load!, loaded?, precompile_all_routes!, reload!, require_dependencies

Class Attribute Details

.mounted_root(*args) ⇒ String

Returns the root to the mounted apps base directory.

Parameters:

  • args (Array)

Returns:

  • (String) —

    the root to the mounted apps base directory.



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

def mounted_root(*args)
  Padrino.root(@mounted_root ||= "", *args)
end

Class Method Details

.add_middleware(router) ⇒ Object

Creates Rack stack with the router added to the middleware chain.



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

def add_middleware(router)
  builder = Rack::Builder.new
  middleware.each{ |mw,args,block| builder.use(mw, *args, &block) }
  builder.run(router)
  builder.to_app
end

.application ⇒ Padrino::Router

The resulting rack builder mapping each ‘mounted’ application.

Returns:

Raises:



71
72
73
74
75
76
 
# File 'lib/padrino-core.rb', line 71

def application
  warn 'WARNING! No apps are mounted. Please, mount apps in `config/apps.rb`' if Padrino.mounted_apps.empty?
  router = Padrino::Router.new
  Padrino.mounted_apps.each { |app| app.map_onto(router) }
  middleware.empty? ? router : add_middleware(router)
end

.bin(*args) ⇒ Boolean

This method return the correct location of padrino bin or exec it using Kernel#system with the given args.

Examples:

Padrino.bin('start', '-e production')

Parameters:

  • args (Array) —

    command or commands to execute

Returns:

  • (Boolean) 


16
17
18
19
 
# File 'lib/padrino-core/command.rb', line 16

def self.bin(*args)
  @_padrino_bin ||= [self.ruby_command, File.expand_path("../../../bin/padrino", __FILE__)]
  args.empty? ? @_padrino_bin : system(args.unshift(@_padrino_bin).join(" "))
end

.clear_middleware! ⇒ Array

Clears all previously configured middlewares.

Returns:

  • (Array) —

    An empty array



147
148
149
 
# File 'lib/padrino-core.rb', line 147

def clear_middleware!
  @middleware = []
end

.configure_apps { ... } ⇒ Object

Configure Global Project Settings for mounted apps. These can be overloaded in each individual app’s own personal configuration. This can be used like:

Examples:

Padrino.configure_apps do
  enable  :sessions
  disable :raise_errors
end

Yields:

  • The given block will be called to configure each application.



91
92
93
94
 
# File 'lib/padrino-core.rb', line 91

def configure_apps(&block)
  return  unless block_given?
  global_configurations << block
end

.env ⇒ Symbol

Helper method that return RACK_ENV.

Returns:

  • (Symbol) —

    The Padrino Environment.



58
59
60
 
# File 'lib/padrino-core.rb', line 58

def env
  @_env ||= RACK_ENV.to_s.downcase.to_sym
end

.gem(name, main_module) ⇒ Object

Registers a gem with padrino. This relieves the caller from setting up loadpaths by itself and enables Padrino to look up apps in gem folder.

The name given has to be the proper gem name as given in the gemspec.

Parameters:

  • name (String) —

    The name of the gem being registered.

  • main_module (Module) —

    The main module of the gem.



180
181
182
183
184
185
 
# File 'lib/padrino-core.rb', line 180

def gem(name, main_module)
  _, spec = Gem.loaded_specs.find{|spec_pair| spec_pair[0] == name }
  gems << spec
  modules << main_module
  spec.full_gem_path
end

.gems ⇒ Object 



189
190
191
 
# File 'lib/padrino-core.rb', line 189

def gems
  @gems ||= []
end

.global_configurations ⇒ Object

Stores global configuration blocks.



99
100
101
 
# File 'lib/padrino-core.rb', line 99

def global_configurations
  @_global_configurations ||= []
end

.insert_mounted_app(mounter) ⇒ Object

Inserts a Mounter object into the mounted applications (avoids duplicates).

Parameters:



254
255
256
 
# File 'lib/padrino-core/mounter.rb', line 254

def insert_mounted_app(mounter)
  Padrino.mounted_apps.push(mounter) unless Padrino.mounted_apps.include?(mounter)
end

.logger ⇒ Padrino::Logger

Examples:

logger.debug "foo"
logger.warn "bar"

Returns:



17
18
19
 
# File 'lib/padrino-core/logger.rb', line 17

def self.logger
  Padrino::Logger.logger
end

.logger=(value) ⇒ Object

Set the padrino logger.

Examples:

using ruby default logger

require 'logger'
new_logger = ::Logger.new(STDOUT)
new_logger.extend(Padrino::Logger::Extensions)
Padrino.logger = new_logger

using ActiveSupport

require 'active_support/buffered_logger'
Padrino.logger = Buffered.new(STDOUT)

using custom logger class

require 'logger'
class CustomLogger < ::Logger
  include Padrino::Logger::Extensions
end
Padrino.logger = CustomLogger.new(STDOUT)

Parameters:

  • value (Object) —

    an object that respond to <<, write, puts, debug, warn, devel, etc..

Returns:

  • (Object) —

    The given value.



47
48
49
 
# File 'lib/padrino-core/logger.rb', line 47

def self.logger=(value)
  Padrino::Logger.logger = value
end

.middleware ⇒ Array<Array<Class, Array, Proc>>

A Rack::Builder object that allows to add middlewares in front of all Padrino applications.

Returns:

  • (Array<Array<Class, Array, Proc>>) —

    The middleware classes.



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

def middleware
  @middleware ||= []
end

.modules ⇒ Object 



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

def modules
  @modules ||= []
end

.mount(name, options = {}) ⇒ Object

Mounts a new sub-application onto Padrino project.

Examples:

Padrino.mount("blog_app").to("/blog")

See Also:

  • Padrino::Mounter#new


266
267
268
 
# File 'lib/padrino-core/mounter.rb', line 266

def mount(name, options={})
  Mounter.new(name, options)
end

.mounted_apps ⇒ Array

Returns the mounted padrino applications (MountedApp objects).

Returns:

  • (Array) —

    the mounted padrino applications (MountedApp objects)



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

def mounted_apps
  @mounted_apps ||= []
end

.replace_with_binstub(executable) ⇒ Object

Replaces the current process with it’s binstub.



5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/padrino-core/cli/binstub.rb', line 5

def self.replace_with_binstub(executable)
  begin
    return if Bundler.definition.missing_specs.empty?
  rescue NameError, NoMethodError, Bundler::GemfileNotFound
  end

  project_root = Dir.pwd
  until project_root.empty?
    break if File.file?(File.join(project_root, 'Gemfile'))
    project_root = project_root.rpartition('/').first
  end

  if %w(Gemfile .components).all? { |file| File.file?(File.join(project_root, file)) }
    binstub = File.join(project_root, 'bin', executable)
    if File.file?(binstub)
      exec Gem.ruby, binstub, *ARGV
    else
      puts 'Please run `bundle install --binstubs` from your project root to generate bundle-specific executables'
      exit!
    end
  end
end

.root(*args) ⇒ String

Helper method for file references.

Examples:

# Referencing a file in config called settings.yml
Padrino.root("config", "settings.yml")
# returns PADRINO_ROOT + "/config/setting.yml"

Parameters:

  • args (Array<String>) —

    The directories to join to PADRINO_ROOT.

Returns:

  • (String) —

    The absolute path.



48
49
50
 
# File 'lib/padrino-core.rb', line 48

def root(*args)
  File.expand_path(File.join(PADRINO_ROOT, *args))
end

.ruby_command ⇒ String

Return the path to the ruby interpreter taking into account multiple installations and windows extensions.

Returns:

  • (String) —

    path to ruby bin executable



28
29
30
31
32
33
34
35
36
37
 
# File 'lib/padrino-core/command.rb', line 28

def self.ruby_command
  @ruby_command ||= begin
    ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
    ruby << RbConfig::CONFIG['EXEEXT']

    # escape string in case path to ruby executable contain spaces.
    ruby.sub!(/.*\s.*/m, '"\&"')
    ruby
  end
end

.run!(options = {}) ⇒ Object

Runs the Padrino apps as a self-hosted server using: thin, mongrel, or WEBrick in that order.

Examples:

Padrino.run! # with these defaults => host: "127.0.0.1", port: "3000", adapter: the first found
Padrino.run!("0.0.0.0", "4000", "mongrel") # use => host: "0.0.0.0", port: "4000", adapter: "mongrel"


10
11
12
13
 
# File 'lib/padrino-core/server.rb', line 10

def self.run!(options={})
  Padrino.load!
  Server.start(*detect_application(options))
end

.set_encoding ⇒ NilClass

Set Encoding.default_internal and Encoding.default_external to Encoding::UFT_8.

Please note that in 1.9.2 with some template engines like haml you should turn off Encoding.default_internal to prevent problems.

Returns:

  • (NilClass)

See Also:



114
115
116
117
118
 
# File 'lib/padrino-core.rb', line 114

def set_encoding
  # remove after 0.15
  warn 'Warning! Padrino.set_encoding is deprecated. Padrino no longer manages ruby default encodings'
  nil
end

.use(mw, *args) { ... } ⇒ Object

Convenience method for adding a Middleware to the whole padrino app.

Parameters:

  • m (Class) —

    The middleware class.

  • args (Array) —

    The arguments for the middleware.

Yields:

  • The given block will be passed to the initialized middleware.



163
164
165
 
# File 'lib/padrino-core.rb', line 163

def use(mw, *args, &block)
  middleware << [mw, args, block]
end

.version ⇒ String

The current Padrino version.

Returns:

  • (String) —

    The version number.



17
18
19
 
# File 'lib/padrino-core/version.rb', line 17

def self.version
  VERSION
end

Instance Method Details

#RUBY_IGNORE_CALLERS ⇒ Object

Add rubinius (and hopefully other VM implementations) ignore patterns …



28
 
# File 'lib/padrino-core/caller.rb', line 28

PADRINO_IGNORE_CALLERS.concat(RUBY_IGNORE_CALLERS)