Class: BigBand
- Inherits:
-
Sinatra::Base
- Object
- Sinatra::Base
- BigBand
- Extended by:
- Generated
- Defined in:
- lib/big_band.rb,
lib/big_band/sass.rb,
lib/big_band/compass.rb,
lib/big_band/reloader.rb,
lib/big_band/config_file.rb,
lib/big_band/integration.rb,
lib/big_band/more_server.rb,
lib/big_band/more_helpers.rb,
lib/big_band/web_inspector.rb,
lib/big_band/advanced_routes.rb,
lib/big_band/basic_extensions.rb,
lib/big_band/more_server/unicorn.rb,
lib/big_band/more_server/rainbows.rb
Overview
BigBand is a collection of Sinatra extensions and offers better sinatra integration for common tools. It is pluggable and each extension can be used in stand alone mode.
The main features are:
-
Routes as first class objects
-
Better handling of #set: Merges hashes, more hooks
-
Better compass integration
-
YAML config files mapping to set (overwriting present values/methods is prevented)
-
Rails-like helpers, like content_for
-
Unicorn and Rainbows integration
-
Smart code reloader only reloading changed files and getting rid of old routes
-
Sass extensions
-
Routes for inspection in development mode
-
Helpers and configuration for Bacon, RSpec, Test::Spec and Test::Unit
-
Tasks listing all routes for Monk and Rake.
-
YARD: Add Sinatra routes to generated documentation
Planned features:
-
More template helpers
-
ORM integration
-
MSpec integration
Usage
Using all BigBand features:
require "sinatra/big_band"
class Example < Sinatra::BigBand
# Yay, BigBand!
end
Or you may use the extension style:
class AnotherExample < Sinatra::Base
register Sinatra::BigBand
end
Or for the lazy folks (if you use classic style):
require "sinatra"
require "sinatra/big_band"
# Yay, BigBand!
Sinatra::BigBand is just an alias for BigBand. It was introduced manly to (in my opinion) have prettier class signatures. First “class Example < Sinatra::BigBand” looks like Sinatra “class Example < BigBand”, lets give some credit to our beloved framework. Also, Sinatra::BigBand seems more akin to Sinatra::Base, Sinatra::Application and Sinatra::Default, than just BigBand. Other than that I do not plan to move BigBand completely into Sinatra simply to avoid more nesting. Last, but no least, the Sinatra docs sugest placing extensions inside Sinatra.
Using just your favorite BigBand features:
require "big_band"
class Example < Sinatra::Base
register BigBand::SomeFeature
# Yay, SomeFeature!
end
Or, if you like a more handy syntax:
require "sinatra/big_band"
class Example < Sinatra::BigBand :SomeFeature, MyStuff::Extension, :development => :DevelopmentOnlyFeature
# Yay, BigBand::SomeFeature!
# Yay, MyStuff::Extension!
# Yay, BigBand::DevelopmentOnlyFeature, if this is development mode!
end
Loading all but one feature:
require "sinatra/big_band"
class Example < Sinatra::BigBand :except => :SomeFeature
# Yay, all but BigBand::SomeFeature!
end
Or just your favorite feature without you subclassing Sinatra::Base manually:
require "sinatra"
require "big_band/some_feature"
Sinatra::Application.register BigBand::SomeFeature
# Yay, BigBand::SomeFeature!
Defined Under Namespace
Modules: AdvancedRoutes, BasicExtensions, Compass, ConfigFile, Generated, Integration, MoreHelpers, MoreServer, Reloader, Sass, WebInspector
Constant Summary collapse
- VERSION =
"0.2.3"
- DATE =
"2010-01-04"
- CALLERS_TO_IGNORE =
(class << Sinatra::Base; CALLERS_TO_IGNORE; end)
Instance Attribute Summary
Attributes included from Generated
#big_band_constructor, #big_band_extensions
Class Method Summary collapse
- .applications ⇒ Object
-
.big_band_extensions ⇒ Object
Extensions to load.
- .default_extension(name, path = nil, env = nil) ⇒ Object
-
.default_extensions(*extensions) ⇒ Object
Default extensions that will be used whenever you subclass BigBand.
-
.generate_class(*options) ⇒ Object
Generates a class for the given extensions.
-
.load_extensions(klass, *extensions) ⇒ Object
Adds extensions to a Sinatra application:.
-
.module_for(extension) ⇒ Object
Returns the module for a given extension identifier:.
- .setify_parameters(args) ⇒ Object
Methods included from Generated
Methods inherited from Sinatra::Base
register, register_without_big_band
Class Method Details
.applications ⇒ Object
118 119 120 |
# File 'lib/big_band.rb', line 118 def self.applications @applications ||= [] end |
.big_band_extensions ⇒ Object
Extensions to load.
123 124 125 |
# File 'lib/big_band.rb', line 123 def self.big_band_extensions default_extensions end |
.default_extension(name, path = nil, env = nil) ⇒ Object
217 218 219 220 |
# File 'lib/big_band.rb', line 217 def self.default_extension(name, path = nil, env = nil) autoload name, path if path default_extensions(env ? {env => name} : name) end |
.default_extensions(*extensions) ⇒ Object
Default extensions that will be used whenever you subclass BigBand. You can also use this to create your own extension collection:
class MyExtensions < BigBand(:except => :ExtensionIDontLike)
default_extension FunkyExtension, :development => DevExtension
end
Note: If given a string or symbol, it will also try to setup an autoloader:
MyExtensions.default_extensions :Foo
203 204 205 206 207 208 209 210 211 212 213 214 215 |
# File 'lib/big_band.rb', line 203 def self.default_extensions(*extensions) return @default_extensions if @default_extensions and extensions.empty? @nonenv_extensions ||= [] @env_extensions ||= {:development => []} extensions.each do |extension| if extension.respond_to? :each_pair extension.each_pair { |env, exts| (@env_extensions[env] ||= []).push(*exts) } else @nonenv_extensions.push(*extension) end end @default_extensions = [@nonenv_extensions, @env_extensions].flatten end |
.generate_class(*options) ⇒ Object
Generates a class for the given extensions. Note that this class is ment to be subclassed rather than used directly. Given extensione will only be available for subclasses.
class Foo < BigBand.generate_class(:except => :SomeExtension)
end
133 134 135 136 137 138 139 140 |
# File 'lib/big_band.rb', line 133 def self.generate_class(*) @generated_classes ||= {setify_parameters([]) => BigBand} @generated_classes[setify_parameters()] ||= Class.new(Sinatra::Base) do extend BigBand::Generated @big_band_extensions = @big_band_constructor = "BigBand(#{.map { |o| o.inspect}.join ", "})" end end |
.load_extensions(klass, *extensions) ⇒ Object
148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 |
# File 'lib/big_band.rb', line 148 def self.load_extensions(klass, *extensions) extensions = default_extensions if extensions.empty? extensions.flatten.each do |extension| if extension.respond_to? :each_pair extension.each_pair do |key, value| values = [value].flatten case key when :production, :test, :development klass.configure(key) { BigBand.load_extensions(klass, *values) } when :except exts = @nonenv_extensions.reject { |e| values.include? e } exts << @env_extensions.inject({}) do |accepted, (env, list)| accepted.merge env => list.reject { |e| values.include? e } end load_extensions(klass, *exts) else raise ArgumentError, "unknown key #{key.inspect}" end end else klass.register module_for(extension) end end end |
.module_for(extension) ⇒ Object
177 178 179 180 181 182 183 |
# File 'lib/big_band.rb', line 177 def self.module_for(extension) case extension when Module then extension when String then extension.split("::").inject(self) { |klass, name| klass.const_get name } when Symbol then const_get(extension) end end |
.setify_parameters(args) ⇒ Object
185 186 187 188 189 190 191 |
# File 'lib/big_band.rb', line 185 def self.setify_parameters(args) case args when Hash then args.inject({}) { |h,(k,v)| h k => setify_parameters(v) } when Array then args.flatten.to_set else args end end |