big_band 0.2.5 → 0.4.0

data/LICENSE

@@ -1,4 +1,4 @@
-copyright (c) 2009 Konstantin Haase.  All rights reserved.
+copyright (c) 2010 Konstantin Haase.  All rights reserved.
 
 Developed by: Konstantin Haase
               http://github.com/rkh/big_band

data/README.md

@@ -0,0 +1,82 @@
+Sinatra::BigBand
+================
+
+BigBand is a stack of [Sinatra](http://sinatrarb.com) extensions, most of them developed as part of BigBand, but usable without,
+each of available as a separate gem. All BigBand extensions follow the same release cycle.
+
+Usage
+-----
+
+Simply replace `Sinatra::Base` with `Sinatra::BigBand` in your application.
+
+A simple example would be:
+
+    require 'sinatra/big_band'
+    class MyApp < Sinatra::BigBand
+      # ...
+    end
+
+Maybe you want all extensions except `Sinatra::Compass`?
+
+    require 'sinatra/big_band'
+    class MyApp < Sinatra::BigBand :except => :Compass
+      # ...
+    end
+
+The BigBand Stack
+-----------------
+
+Sinatra Extensions
+
+* [Sinatra::AdvancedRoutes](http://github.com/rkh/sinatra-advanced-routes) – Makes routes first class objects
+* [Sinatra::Compass](http://github.com/rkh/sinatra-compass) – Integrates the Compass stylesheet framework
+* [Sinatra::ConfigFile](http://github.com/rkh/sinatra-config-file) – Adds YAML config file support
+* [Sinatra::MoreServer](http://github.com/rkh/sinatra-more-server) – Adds support for more web servers to Sinatra::Base#run!
+* [Sinatra::Namespace](http://github.com/rkh/sinatra-namespace) – Adds namespaces, allows namespaces to have local helpers.
+* [Sinatra::Reloader](http://github.com/rkh/sinatra-reloader) – Advanced and fast code reloader
+* [Sinatra::Sugar](http://github.com/rkh/sinatra-sugar) – Extensions for Sinatra's standard methods, like #set or #register
+
+Sinatra tool integration:
+
+* [AsyncRack](http://github.com/rkh/async-rack) – Makes standard rack middleware play nice with `async.callback`
+* [Haml::More](http://github.com/rkh/haml-more) – Adds more functionality to Haml and Sass
+* [monkey-lib](http://github.com/rkh/monkey-lib) – Thin layer over ruby extension libraries (like ActiveSupport) to make those pluggable
+* [Sinatra::TestHelper](http://github.com/rkh/sinatra-test-helper) – Adds helper methods and better integration for various testing frameworks
+* [Yard::Sinatra](http://github.com/rkh/yard-sinatra) – Displays Sinatra routes (including comments) in YARD output
+
+Besides those extensions, there are others in the BigBand stack, that are external:
+
+* [Rack Flash](http://github.com/nakajima/rack-flash) by Pat Nakajima
+
+Goals for 0.4.0
+---------------
+
+* No sub-project relies on BigBand
+* All sub-projects should work with MRI/REE >= 1.8.6 (including 1.9.x), JRuby >= 1.4.0 and Rubinius >= 1.0
+* Some sub-projects should work with MagLev and IronRuby (partial MacRuby support planned for later release)
+* Ease to modify the stack
+
+Setup via gem
+-------------
+
+Try:
+
+    gem install big_band
+
+Running the specs / Manual setup
+--------------------------------
+
+Try something like this:
+
+    # dependencies, rather mainstream. just in case you don't have one of those.
+    gem install sinatra rspec rack-test rake
+    
+    # get the source
+    git clone git://github.com/rkh/big_band.git
+    rake setup:read_only
+    
+    # run the specs
+    rake spec
+    
+    # run with multiple ruby implementations using rvm
+    rvm specs ree,1.9.1,rbx,jruby

data/Rakefile

@@ -1,190 +1,70 @@
-$LOAD_PATH.unshift "lib"
-load "depgen/depgen.task"
+# see tasks/*.task for rake tasks
 
-if ENV['RUN_CODE_RUN']
-  Rake::Task["dependencies:vendor:all"].invoke
-  task :default => :spec
-else
-  task :default => [:dummy_files, "dependencies:generate:rip", :gems] # gems will trigger spec
-end
-
-$LOAD_PATH.unshift(*Dir.glob(File.expand_path(__FILE__ + "/../vendor/*/lib")))
-require "erb"
-require "spec/rake/spectask"
-require "rake/clean"
-require "rake/rdoctask"
-require "monkey-lib"
-require "yard"
+$RELATIVE_LOAD_PATH = Dir.glob '{*,.}/lib'
+$LOAD_PATH.unshift('.', *$RELATIVE_LOAD_PATH)
+require 'subproject'
 
-$LOAD_PATH.unshift __FILE__.dirname.expand_path / "lib"
-require "big_band/integration/yard"
-require "big_band/integration/rake"
-require "big_band/version"
-
-include BigBand::Integration::Rake
-RoutesTask.new { |t| t.source = "lib/**/*.rb" }
-
-task :install => "gems:install"
-task :test    => :spec
-task :clobber => "doc:clobber_rdoc"
+task :default => ["setup:check", :spec]
 
+require "rake/clean"
 CLEAN.include "**/*.rbc"
-CLOBBER.include "*.gem", "README.rdoc"
-
-Spec::Rake::SpecTask.new('spec') do |t|
-  t.spec_opts = %w[--options spec/spec.opts]
-  t.spec_files = Dir.glob 'spec/**/*_spec.rb'
-end
-
-TOOL_NAMES = { :Rspec => :RSpec, :Yard => :YARD, :TestSpec => :"Test::Spec", :TestUnit => :"Test::Unit" }
-
-def yard(files)
-  YARD::Registry.load(Dir[files], true)
-  YARD::Registry.resolve(false, "BigBand")
-end
-
-def yard_children(ydoc, directory, defaults = {}, &block)
-  children = Dir.glob("#{directory}/*.rb").map { |f| f[(directory.size+1)..-4].to_const_string.to_sym }
-  children.select!(&block) if block
-  children.map! do |name|
-    rewritten_name = defaults[name] || name
-    ydoc.child(rewritten_name) or ydoc.child(name).tap { |c| c.name = rewritten_name unless c.nil? }
-  end
-  children.compact
-end
-
-def generate_readme(target = "README.rdoc", template = "README.rdoc.erb")
-  puts "generating #{target} from #{template}"
-  # HACK: loading other libraries later, for some strange heisenbug setting the docstring to an empty string later.
-  docstring   = yard("lib/big_band.rb").docstring
-  ydoc        = yard("lib/big_band/{**/,}*.rb")
-  extensions  = yard_children(ydoc, "lib/big_band") { |n| n != :Integration }
-  integration = yard_children(ydoc.child(:Integration), "lib/big_band/integration", TOOL_NAMES) { |n| n != :Test }
-  version     = BigBand::VERSION
-  File.open(target, "w") { |f| f << ERB.new(File.read(template), nil, "<>").result(binding) }
-end
+CLOBBER.include "*.gem", "doc"
 
-file "README.rdoc" => ["README.rdoc.erb", "lib/big_band.rb"] do
-  generate_readme
+def insert_desc(*values)
+  return unless Rake.application.last_comment
+  Rake.application.last_comment.replace(Rake.application.last_comment % values)
 end
 
-desc "Generate documentation"
-task "doc"    => "doc:yardoc"
-task "yardoc" => "doc:yardoc"
-task "rdoc"   => "doc:yardoc"
-
-namespace :doc do
-
-  task "yardoc" => "readme"
-  task "rdoc"   => "readme"
-  task "rerdoc" => "readme"
-
-  desc "Generate README.rdoc from source files"
-  task "readme" do |t|
-    generate_readme
-  end
-
-  Rake::RDocTask.new("rdoc") do |rdoc|
-    rdoc.rdoc_dir = 'doc'
-    rdoc.options += %w[-a -S -N -m README.rdoc -q -w 2 -t BigBand -c UTF-8]
-    rdoc.rdoc_files.add ['*.{rdoc,rb}', '{config,lib,routes}/**/*.rb']
-  end
-
-  YARD::Rake::YardocTask.new("yardoc") do |t|
-    t.options = %w[--main README.rdoc --backtrace]
-  end
-
-end
-
-task :gems => "gems:build"
-
-namespace :gems do
-
-  desc "Build gems (runs specs first)"
-  task :build => [:clobber, :spec, "doc:readme"] do
-    GEMS = []
-    Dir.glob("*.gemspec") do |file|
-      sh "gem build #{file}"
-      GEMS << "#{file[0..-9]}-#{BigBand::VERSION}.gem"
-    end
-  end
-
-  desc "Install gems"
-  task :install => :build do
-    GEMS.each { |file| sh "gem install #{file}" }
-  end
-
-  desc "Publish gems (gemcutter)"
-  task :push => :build do
-    GEMS.each { |file| sh "gem push #{file}" }
-  end
-
-end
-
-desc "generate dummy files"
-task :dummy_files do |t|
-  chdir "lib" do
-    rm_rf "sinatra/big_band/"
-    mkdir_p "sinatra/big_band/"
-    Dir.glob("big_band/**/*.rb") do |file|
-      target = "sinatra" / file
-      mkdir_p target.dirname
-      File.open(target, "w") do |f|
-        f.puts "# Generated file, run 'rake #{t.name}' to regenerate"
-        f.puts "require #{file[0..-4].inspect}"
+def project_namespace(parent = nil, all = true, &block)
+  return namespace(parent) { project_namespace(nil, all, &block) } if parent
+  project_was, default_desc_was = @project, @default_desc
+  namespaces = Subproject.inject({}) { |h, p| h.merge p.name => p}
+  namespaces[all == true ? nil : all] = :all if all
+  namespaces.each do |name, project|
+    @project, @default_desc = project, false
+    if name
+      namespace(name, &block)
+      if @default_desc
+        desc @default_desc
+        task name => "#{name}:default"
       end
+    else
+      yield
     end
   end
+  @project, @default_desc = project_was, default_desc_was
 end
 
-desc "make a release, will fail if there are uncommitted changes or the specs don't pass"
-task :release => "release:gem"
-namespace :release do
+def subproject
+  @subproject
+end
 
-  task(:committed) do
-    status = %x[git status]
-    raise "uncommitted changes" unless status =~ /nothing to commit/
-    raise "not on branch master" unless status =~ /On branch master\n/
+def subproject_block(project)
+  proc do |raketask|
+    @subproject, subproject_was = project, @subproject
+    yield raketask if block_given?
+    @subproject = subproject_was
   end
+end
 
-  task :version_bump => [:spec, :committed] do
-    new_version = ENV["VERSION"] || BigBand::VERSION.gsub(/\.(\d+)$/) { ".#{$1.to_i + 1}" }
-    old_source = File.read "lib/big_band/version.rb"
-    File.open("lib/big_band/version.rb", "w") do |f|
-      f.puts 'require "big_band/integration" unless defined? BigBand'
-      f.puts "BigBand::VERSION = #{new_version.inspect}"
-      f.puts "BigBand::DATE    = #{Date.today.to_s.inspect}"
-    end
-    puts "version bump: #{BigBand::VERSION} -> #{new_version}'"
-    BigBand::VERSION.replace new_version
+def project_task(name, &block)
+  return project_namespace { project_task(name, &block) } unless @project
+  name, dependencies = name.to_a.first if name.is_a? Hash
+  dependencies = [dependencies].flatten.compact
+  if @project == :all
+    dependencies += Subproject.map { |p| "#{p.name}:#{name}" }
+    block = nil
+    insert_desc "all subprojects"
+  else
+    insert_desc @project.name
   end
-
-  task :prepare => [:version_bump, "dependencies:generate:rip", :clobber, "doc:readme", "gems:build"]
-
-  task :git => :prepare do
-    message = "-m 'release: #{BigBand::VERSION}'"
-    sh "git ci -a #{message}"
-    sh "git tag -a v#{BigBand::VERSION} #{message}"
-    sh "git push && git push --tags"
+  if name.to_s == "default"
+    @default_desc = Rake.application.last_comment
+    desc nil
   end
-
-  task :gem => [:git, "gems:push"]
-
+  task({name => dependencies}, &subproject_block(@project, &block))
 end
 
-############
-# aliases
-
-task :c => [:clobber, "doc:readme"]
-task :s => :spec
-task :d
-namespace :d do
-  task :r => "doc:readme"
-  task :y => "doc:yardoc"
-end
-task :g => :gems
-namespace :g do
-  task :b => "gems:build"
-  task :i => "gems:install"
-  task :p => "gems:push"
+Dir.glob("tasks/*.task").sort.each do |file|
+  eval File.read(file), binding, file, 1
 end

data/TODO.md

@@ -0,0 +1,50 @@
+TODO
+====
+
+For 0.4.0 release
+-----------------
+
+All subprojects:
+
+* Add licenses, deps.rip, maybe dependencies file for monk
+
+BigBand:
+
+* Create some sort of website (GitHub Pages?)
+* Write example app
+
+After 0.4.0
+-----------
+
+General:
+
+* Implement more fancy stuff
+* Padrino integration (maybe an example app, maybe some docs, dunno)
+* Monk skeleton using big\_band
+* See if stack\_helper can be extracted and is of any use (stack\_helper branch)
+* Improve inline documentation (YARD tags)
+* Maybe switch to [sinatra-flash](http://github.com/SFEley/sinatra-flash)
+
+sinatra-advanced-routes:
+
+* Make compatible with [Usher](http://github.com/joshbuddy/usher)
+* Make compatible with [padrino-core/routing](http://github.com/padrino/padrino-framework/issues/issue/46)
+
+Subprojects to be published or written:
+
+* queueba (yet another message queue based on redis, maybe)
+* sinatra-postpone
+* "sinatra-queueba" or redis channel for pusher + pusher integration for sinatra
+
+Before 0.5.0
+------------
+
+BigBand:
+
+* remove `::BigBand`
+
+monkey-lib:
+
+* remove `Object#metaclass`
+* remove `Object#metaclass_eval`
+

data/lib/big_band.rb

@@ -1,264 +1,19 @@
-require "sinatra/base"
-#require "monkey-lib"
-require "set"
-
-# 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!
-class BigBand < Sinatra::Base
-
-  # Classes generated by BigBand.generate_class will be extended
-  # with this class.
-  module Generated
-
-    attr_reader :big_band_extensions, :big_band_constructor
-
-    # Adds extensions to subclass
-    def inherited(klass)
-      super
-      BigBand.applications << klass
-      BigBand.load_extensions(klass, *big_band_extensions)
-    end
-
-    # Use Generated#name for inspection.
-    def inspect
-      name
-    end
-
-    # Nice output for inspect and friends:
-    #   foo = Class.new BigBand(:SomeExtension)
-    #   foo.name # => BigBand(:SomeExtension)
-    #   Foo = foo
-    #   foo.name # => Foo
-    def name
-      real_name = super
-      real_name.empty? ? big_band_constructor : real_name
-    end
-
-  end
-
-  extend Generated
-
-  def self.applications
-    @applications ||= []
-  end
-
-  # Extensions to load.
-  def self.big_band_extensions
-    default_extensions
-  end
-
-  # 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
-  def self.generate_class(*options)
-    @generated_classes ||= {setify_parameters([]) => BigBand}
-    @generated_classes[setify_parameters(options)] ||=  Class.new(Sinatra::Base) do
-      extend BigBand::Generated
-      @big_band_extensions = options
-      @big_band_constructor = "BigBand(#{options.map { |o| o.inspect}.join ", "})"
-    end
-  end
-
-  # Adds extensions to a Sinatra application:
-  #
-  #   class MyApp < Sinatra::Base
-  #   end
-  #
-  #   BigBand.load_extensions MyApp, :SomeExtension, :development => :AnotherExtension
-  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
-
-  # Returns the module for a given extension identifier:
-  #
-  #   BigBand.module_for :BasicExtension # => BigBand::BasicExtension
-  #   BigBand.module_for Array           # => Array
-  #   BigBand.module_for "Foo::Bar"      # => BigBand::Foo::Bar or Foo::Bar or raises an exception
-  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
-
-  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
-
-  # 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
-  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
-
-  def self.default_extension(name, path = nil, env = nil)
-    autoload name, path if path
-    default_extensions(env ? {env => name} : name)
-  end
-
-  default_extension :AdvancedRoutes,  "big_band/advanced_routes"
-  default_extension :BasicExtensions, "big_band/basic_extensions"
-  default_extension :Compass,         "big_band/compass"
-  default_extension :ConfigFile,      "big_band/config_file"
-  default_extension :MoreHelpers,     "big_band/more_helpers"
-  default_extension :MoreServer,      "big_band/more_server"
-  default_extension :Reloader,        "big_band/reloader", :development
-  default_extension :Sass,            "big_band/sass"
-  default_extension :WebInspector,    "big_band/web_inspector", :development
+warn "#{caller.detect { |c| c !~ /require/ }}: require 'big_band' is deprecated, use require 'sinatra/big_band' instead."
+require "sinatra/big_band"
 
+def BigBand(*args, &block)
+  warn "#{caller.first}: Using BigBand is deprecated, use Sinatra::BigBand instead. It will be removed in BigBand 0.5."
+  Monkey.invisible { Sinatra::BigBand(*args, &block) }
 end
 
-# Shorthand for BigBand.generate_class
-def BigBand(*options)
-  BigBand.generate_class(*options)
-end
-
-module Sinatra
-  BigBand = ::BigBand
-  class Base
-    class << self
-      alias register_without_big_band register
-      def register(*extensions, &block)
-        big_band, normal = extensions.partition { |e| e.respond_to? :big_band_extensions }
-        big_band.each { |e| e.load_extensions self }
-        register_without_big_band(*normal, &block)
-        extensions
-      end
-    end
-  end
-  module Delegator
-    # Hooks into Sinatra to allow easy integration with "require 'sinatra'".
-    def self.included(klass)
-      BigBand.inherited(Sinatra::Application)
-      Sinatra::Application.extensions.each do |ext|
-        delegate(*ext.delegations) if ext.respond_to? :delegations
-      end
+Module.class_eval do
+  alias const_missing_without_deprecation_warnings const_missing
+  def const_missing(name)
+    Monkey.invisible __FILE__ do
+      return const_missing_without_deprecation_warnings(name) unless name == :BigBand and self != ::Sinatra
+      from = caller.detect { |e| e !~ /const_missing/ }
+      warn "#{from}: Using BigBand is deprecated, use Sinatra::BigBand instead. It will be removed in BigBand 0.5."
+      Sinatra::BigBand
     end
   end
 end
-
-# If require "sinatra" came before require "big_band" Sinatra::Delegator.included has not been called.
-Sinatra::Delegator.included(self) if is_a? Sinatra::Delegator