big_band 0.2.1

data/lib/big_band/web_inspector.rb

@@ -0,0 +1,178 @@
+require "sinatra/base"
+require "monkey-lib"
+require "big_band/compass"
+
+class BigBand < Sinatra::Base
+
+  # The WebInspector allowes you to inspect a running Sinatra app.
+  # Just browse http://localhost:4567/\_\_inspect\_\_
+  #
+  # Per default this will only be activated in development mode.
+  module WebInspector
+
+    attr_reader :middleware 
+
+    class Middleware < Sinatra::Base
+
+      attr_accessor :sinatra_app
+      use_in_file_templates! __FILE__
+      register BasicExtensions
+      set :app_file, __FILE__
+      
+      # If this is a git project, then it returns the path to the .git directory.
+      def git_directory
+        @git_directory ||= root_glob(".{,.,./..,./../..}/.git").first
+      end
+      
+      # Whether or not this is a git project.
+      def git?
+        !!git_directory
+      end
+      
+      # Figures out some URLs to public git hosts by parsing the remote urls from the git config.
+      # Currently detects: GitHub, Codaset and Gitorious.
+      def git_remotes
+        @git_remotes ||= (File.read(git_directory / :config).scan(/\s*url\s*=\s*(.*)\n/).flatten.collect do |url|
+          case url
+          when %r{(github.com)[:/](.+)/(.+)/?\.git$}  then [$3, "GitHub",    "http://#$1/#$2/#$3", "http://#$1"]
+          when %r{(codaset.com)[:/](.+)/(.+)?\.git$}  then [$3, "Codaset",   "http://#$1/#$2/#$3", "http://#$1"]
+          when %r{(gitorious.org)[:/](.+)/.+/?\.git$} then [$2, "Gitorious", "http://#$1/#$2",     "http://#$1"]
+          end
+        end).compact
+      end
+      
+      # Recent git log.
+      def git_log
+        @git_format ||= begin
+          line = ["<a href='mailto:%ae'>%an</a>", "%s", "<date>%ai</date>"].map { |e| "<td>#{e}</td>" }.join
+          "<tr>#{line}</tr>"
+        end
+        %x[git log -50 --pretty=format:"#{@git_format}"]
+      end
+
+      # webinspector stylesheet.
+      get "/__inspect__/screen.css" do
+        content_type 'text/css', :charset => 'utf-8'
+        sass :stylesheet, ::Compass.sass_engine_options
+      end
+
+      # Route for inspection. Currently we display all information on a single page. In case the amount of data
+      # increases, we might split this on multiple pages. Also, this would ease hooking own data into the front-end.
+      get "/__inspect__/?" do
+        ruby_env = %w[RUBY_VERSION RUBY_DESCRIPTION RUBY_PATCHLEVEL RUBY_PLATFORM RUBY_ENGINE RUBY_ENGINE_VERSION]
+        ruby_env.map! { |var| [var, eval("#{var}.inspect if defined? #{var}")] }
+        haml :inspect, {}, :ruby_env => ruby_env
+      end
+
+    end
+
+    def self.registered(klass)
+      klass.register BasicExtensions
+      klass.register AdvancedRoutes
+      klass.use(Middleware) { |m| m.sinatra_app = klass }
+    end
+
+  end
+end
+
+__END__
+
+@@layout
+!!!
+%html
+  %head
+    %meta{:charset=>"utf-8"}/
+    %link{:rel => "stylesheet", :href => "/__inspect__/screen.css", :type => "text/css"}/
+    %title= "#{sinatra_app.name}.inspect"
+  %body
+    %header
+      %h1= "#{sinatra_app.name}.inspect"
+      Generated on
+      %date= Time.now
+      %nav
+        %a{:href => "/__inspect__/#routes"     } Routes
+        %a{:href => "/__inspect__/#extensions" } Extensions
+        %a{:href => "/__inspect__/#middleware" } Middleware
+        %a{:href => "/__inspect__/#system"     } System
+        - if git?
+          %a{:href => "/__inspect__/#git_log"  } Git Log
+    %article
+      !=yield
+    %footer
+      powered by
+      %a{:href => "http://www.sinatrarb.com"} Sinatra
+      and
+      %a{:href => "http://github.com/rkh/big_band"} BigBand
+
+@@stylesheet
+@import big_band/layouts/inspector.sass
++layout_inspector
+
+@@inspect
+
+%a{ :name => "routes" }
+%h2 Routes
+%table
+  %tr
+    %th Verb
+    %th Pattern
+    %th File
+    %th Keys
+    %th Conditions
+  - sinatra_app.each_route do |route|
+    %tr
+      %td= route.verb
+      %td= route.pattern.inspect
+      %td
+        - if route.file?
+          = route.file
+          %i= "(line #{route.line})" if route.line 
+      %td= route.keys.map { |e| e.inspect }.join ", "
+      %td= route.conditions.map { |e| e.inspect }.join ", "
+
+%a{ :name => "extensions" }
+%h2 Extensions
+%table
+  %tr
+    %th Extension
+    %th Status
+  - sinatra_app.extensions.each do |extension|
+    %tr
+      %td= extension.name
+      %td= extension.status if extension.respond_to? :status
+
+%a{ :name => "middleware" }
+%h2 Middleware
+%table
+  %tr
+    %th Middleware
+    %th Arguments
+    %th Block Given
+  - sinatra_app.middleware.each do |name, arguments, block|
+    %tr
+      %td= name
+      %td= arguments.map { |e| e.inspect }.join ", "
+      %td= block ? "yes" : "no"
+
+%a{ :name => "system" }
+%h2 System
+%table
+  %tr
+    %th Variable
+    %th Value
+  - ruby_env.each do |key, value|
+    %tr
+      %td= key
+      %td= value
+
+- if git?
+  %a{ :name => "git_log" }
+  %h2 Recent Git Log
+  - git_remotes.each do |name, service, url, service_url|
+    .note Visit <a href="#{url}">#{name}</a> on <a href="#{service_url}">#{service}</a>.
+  %table
+    %tr
+      %th Author
+      %th Subject
+      %th Date
+    != git_log

data/lib/big_band.rb

@@ -0,0 +1,239 @@
+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
+# * 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
+# * Configuration handling
+# * MSpec integration
+#
+# == Usage
+# 
+# Using all BigBand features:
+#
+#   require "big_band"  
+#   class Example < BigBand
+#     # Yay, BigBand!
+#   end
+#
+# Or for the lazy folks (read: you would don't subclass Sinatra::Base on your own):
+#
+#   require "sinatra"
+#   require "big_band"
+#   # Yay, BigBand!
+# 
+# Using just your favorite BigBand features:
+#
+#   require "big_band"
+#   class Example < Sinatra::Base
+#     register BigBand::SomeFeature
+#     # Yay, BigBand::SomeFeature!
+#   end
+#
+# Or, if you like a more handy syntax:
+#
+#   require "big_band"
+#   class Example < 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 "big_band"
+#   class Example < 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 :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
+
+end
+
+# Shorthand for BigBand.generate_class
+def BigBand(*options)
+  BigBand.generate_class(*options)
+end
+
+module Sinatra
+  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
+    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

data/lib/big_bang.rb

@@ -0,0 +1,6 @@
+require "big_band"
+
+unless defined? BigBang
+  warn "It is called BigBand, not BigBang!"
+  BigBang = BigBand
+end

data/lib/yard-sinatra.rb

@@ -0,0 +1,2 @@
+# This is a dummy file to hook into YARD.load_plugins
+require "big_band/integration/yard"

data/spec/big_band/advanced_routes_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(__FILE__ + "/../../spec_helper.rb")
+
+describe BigBand::AdvancedRoutes do
+  before { app :AdvancedRoutes }
+
+  [:get, :head, :post, :put, :delete].each do |verb|
+
+    describe "HTTP #{verb.to_s.upcase}" do
+
+      describe "activation" do
+
+        it "is able to deactivate routes from the outside" do
+          route = define_route(verb, "/foo") { "bar" }
+          route.should be_active
+          browse_route(verb, "/foo").should be_ok
+          route.deactivate
+          route.should_not be_active
+          browse_route(verb, "/foo").should_not be_ok
+        end
+
+        it "is able to deacitvate routes from a before filter" do
+          route = define_route(verb, "/foo") { "bar" }
+          app.before { route.deactivate }
+          route.should be_active
+          browse_route(verb, "/foo").should_not be_ok
+          route.should_not be_active
+        end
+
+        it "is able to reactivate deactivated routes" do
+          route = define_route(verb, "/foo") { "bar" }
+          route.deactivate
+          route.activate
+          route.should be_active
+          browse_route(verb, "/foo").should be_ok
+        end
+
+      end
+
+      describe "inspection" do
+        it "exposes app, path, file, verb, pattern, " do
+          route = define_route(verb, "/foo") { }
+          route.app.should        == app
+          route.path.should       == "/foo"
+          route.file.should       == __FILE__.expand_path
+          route.verb.should       == verb.to_s.upcase
+          route.pattern.should    == route[0]
+          route.keys.should       == route[1]
+          route.conditions.should == route[2]
+          route.block.should      == route[3]
+        end
+      end
+
+      describe "promotion" do
+        it "preffers promoted routes over earlier defined routes" do
+          next if verb == :head # cannot check body for head
+          bar = define_route(verb, "/foo") { "bar" }
+          baz = define_route(verb, "/foo") { "baz" }
+          browse_route(verb, "/foo").body.should == "bar"
+          baz.promote
+          browse_route(verb, "/foo").body.should == "baz"
+          bar.promote
+          browse_route(verb, "/foo").body.should == "bar"
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/big_band/basic_extensions_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(__FILE__ + "/../../spec_helper.rb")
+
+describe BigBand::BasicExtensions do
+
+  before { app :BasicExtensions }
+
+  describe "set" do
+
+    it "adds hooks to Sinatra::Base#set" do
+      extension = Module.new
+      extension.should_receive(:set_foo).with(app)
+      extension.should_receive(:set_value).with(app, :foo)
+      app.register extension
+      app.set :foo, 42
+    end
+
+    it "allows passing a block" do
+      app.set(:foo) { 42 }
+      app.foo.should == 42
+    end
+
+    it "merges hash values" do
+      app.set :foo, :bar => 42
+      app.set :foo, :baz => 23
+      app.foo[:bar].should == 42
+      app.foo[:baz].should == 23
+    end
+
+  end
+
+  describe "register" do
+    it "registers an extension only once" do
+      extension = Module.new
+      extension.should_receive(:registered).once.with(app)
+      10.times { app.register extension }
+    end
+  end
+
+end

data/spec/big_band/more_server_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(__FILE__ + "/../../spec_helper.rb")
+
+describe BigBand::MoreServer do
+  before { app :MoreServer }
+  it("should offer unicorn")   { app.server.should include("unicorn")  }
+  it("should offer rainbows")  { app.server.should include("rainbows") }
+end

data/spec/big_band/sass_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path(__FILE__ + "/../../spec_helper.rb")
+
+describe BigBand::Sass do
+
+  def evaluate_sass(value)
+    Sass::Script::Parser.parse(value, 0, 0).perform(Sass::Environment.new).to_s
+  end
+
+  it "returns the smaller value for min" do
+    evaluate_sass("min(10px, 20px)").should == evaluate_sass("10px")
+    evaluate_sass("min(50%, 10%)").should == evaluate_sass("10%")
+    evaluate_sass("min(42, 42)").should == evaluate_sass("42")
+  end
+
+  it "returns the greater value for max" do
+    evaluate_sass("max(10px, 20px)").should == evaluate_sass("20px")
+    evaluate_sass("max(50%, 10%)").should == evaluate_sass("50%")
+    evaluate_sass("max(42, 42)").should == evaluate_sass("42")
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,5 @@
+--colour
+--format progress
+--loadby mtime
+--reverse
+-b

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+ENV['RACK_ENV'] = 'test'
+
+$LOAD_PATH.unshift File.expand_path(__FILE__ + "../../lib")
+require "big_band/integration/rspec"

data/yard-sinatra.gemspec

@@ -0,0 +1,24 @@
+$LOAD_PATH.unshift "lib"
+require "lib/big_band/version"
+
+YARD_SINATRA_SPEC = Gem::Specification.new do |s|
+
+  s.name          = "yard-sinatra"
+  s.version       = BigBand::VERSION
+  s.date          = BigBand::DATE
+  s.author        = "Konstantin Haase"
+  s.email         = "konstantin.mailinglists@googlemail.com"
+  s.homepage      = "http://github.com/rkh/big_band"
+  s.platform      = Gem::Platform::RUBY
+  s.summary       = "YARD plugin for parsing sinatra routes" 
+  s.files         = ["yard-sinatra.gemspec", "lib/yard-sinatra.rb", "lib/big_band/version.rb"]
+  s.require_paths = ['lib']
+  s.description   = s.summary + " See README.rdoc for more infos."
+  s.has_rdoc      = false
+
+  s.add_dependency "big_band", "= #{BigBand::VERSION}"
+
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+end