big_band 0.2.1

data/lib/big_band/integration/bacon.rb

@@ -0,0 +1,10 @@
+require "big_band/integration/test"
+require "bacon"
+
+module BigBand::Integration
+  # Some Bacon example and description goes here.
+  module Bacon
+    ::Bacon::Context.send :include, self
+    include BigBand::Integration::Test
+  end
+end

data/lib/big_band/integration/monk.rb

@@ -0,0 +1,26 @@
+require "monk"
+require "big_band/integration"
+
+module BigBand::Integration
+  # In your Thorfile, place:
+  #
+  #   require "big_band/integration/monk"
+  #   class Monk < Thor
+  #     routes_task :list_routes
+  #   end
+  #
+  # Now, running 'monk list_routes' in you project directory should
+  # give you a list of all your routes.
+  module Monk
+    def routes_task(name = :routes)
+      desc "#{routes} [FILES=#{GLOBBER.inspect}]", "lists all routes"
+      define_method :routes do |files|
+        BigBand::Integration.each_route(files || GLOBBER) { |v,p| say_status v, p }
+      end
+    end
+  end
+end
+
+class Monk < Thor
+  extend BigBand::Integration::Monk
+end

data/lib/big_band/integration/rake.rb

@@ -0,0 +1,60 @@
+require "big_band/integration"
+require "rake"
+require "rake/tasklib"
+
+module BigBand::Integration
+  # In your Rakefile, do the following:
+  #
+  #   require "big_band/integration/rake"
+  #   include BigBand::Integration::Rake
+  #
+  #   RoutesTask.new
+  #
+  # then you can run 'rake routes' from your
+  # project directory and it will list all routes
+  # of your app. Per default it will scan for routes
+  # defined in ruby files in the directories lib, app,
+  # routes, models, views, and controllers (ignoring
+  # non-existant directories, of course). You can change
+  # that behavior by setting +source+ to another pattern:
+  #
+  #   RoutesTask.new { |t| t.source = "**/*.rb" }
+  #
+  # However, you may also just pass in a Sinatra app, so it
+  # will not have to scan through the source files:
+  #
+  #   require "my_app"
+  #   RoutesTask.new { |t| t.source = MyApp }
+  #
+  # Keep in mind that a broken my_app in this case would also make
+  # your Rakefile unusable.
+  #
+  # Also, you may set another name for the task either by setting
+  # the first argument or calling #name=:
+  #
+  #   RoutesTask.new(:some_routes) { |t| t.source = SomeApp }
+  #   RoutesTask.new do |t|
+  #     t.source = AnotherApp
+  #     t.name   = :other_routes
+  #   end
+  module Rake
+    class RoutesTask < ::Rake::TaskLib
+      attr_accessor :source, :name
+
+      def initialize(name = :routes)
+        @name = name
+        @source = BigBand::Integration::GLOBBER
+        yield self if block_given?
+        define
+      end
+
+      def define
+        desc "Lists routes defined in #{source}"
+        task(name) do
+          BigBand::Integration.each_route(source) { |v,p| puts "#{v.ljust 4} #{p}" }
+        end
+      end
+
+    end
+  end
+end

data/lib/big_band/integration/rspec.rb

@@ -0,0 +1,11 @@
+require "big_band/integration/test"
+require "spec"
+
+module BigBand::Integration
+  # Some RSpec example and description goes here.
+  module RSpec
+    include BigBand::Integration::Test
+    ::Spec::Runner.configure { |c| c.include self }
+  end
+  Rspec = RSpec
+end

data/lib/big_band/integration/test/spec.rb

@@ -0,0 +1,2 @@
+require "big_band/integration/test_spec"
+BigBand::Integration::Test::Spec = BigBand::Integration::TestSpec

data/lib/big_band/integration/test/unit.rb

@@ -0,0 +1,2 @@
+require "big_band/integration/test_unit"
+BigBand::Integration::Test::Unit = BigBand::Integration::TestUnit

data/lib/big_band/integration/test.rb

@@ -0,0 +1,42 @@
+require "sinatra"
+Sinatra::Base.set :environment, :test
+
+require "big_band"
+require "big_band/integration"
+
+require "rack/test"
+#require "webrat"
+#Webrat.configure { |config| config.mode = :sinatra }
+
+module BigBand::Integration
+  # This encapsulates general test helpers. See Bacon, RSpec, Test::Spec and Test::Unit for examples.
+  module Test
+
+    #include Webrat::Methods
+    include Rack::Test::Methods
+
+    attr_writer :app
+    def app(*options, &block)
+      unless block.nil? and options.empty?
+        superclass   = options.first if options.size == 1 and options.first.is_a? Class
+        superclass ||= BigBand(*options)
+        @app         = Class.new(superclass, &block)
+        inspection   = "app"
+        inspection << "(" << options.map { |o| o.inspect }.join(", ") << ")" unless options.empty?
+        inspection << " { ... }" if block
+        @app.class_eval "def self.inspect; #{inspection.inspect}; end"
+      end
+      @app || BigBand.applications.last || Sinatra::Application
+    end
+
+    def define_route(verb, *args, &block)
+      app.send(verb, *args, &block)
+    end
+
+    def browse_route(verb, *args, &block)
+      send(verb, *args, &block)
+      last_response
+    end
+
+  end
+end

data/lib/big_band/integration/test_spec.rb

@@ -0,0 +1,8 @@
+require "big_band/integration/test_unit"
+
+module BigBand::Integration
+  # Some TestSpec example and description goes here.
+  module TestSpec
+    ::Test::Unit::TestCase.send :include, self
+  end
+end

data/lib/big_band/integration/test_unit.rb

@@ -0,0 +1,10 @@
+require "big_band/integration/test"
+require "test/unit"
+
+module BigBand::Integration
+  # Some TestUnit example and description goes here.
+  module TestUnit
+    ::Test::Unit::TestCase.send :include, self
+    include BigBand::Integration::Test
+  end
+end

data/lib/big_band/integration/yard.rb

@@ -0,0 +1,104 @@
+require "big_band/integration"
+require "yard"
+
+module BigBand::Integration
+  # Some YARD example and description goes here.
+  module YARD
+
+    module CodeObjects
+      class RouteObject < ::YARD::CodeObjects::MethodObject
+
+        ISEP = ::YARD::CodeObjects::ISEP
+
+        attr_accessor :http_verb, :http_path, :real_name
+        def name(prefix = false)
+          return super unless show_real_name?
+          prefix ? (sep == ISEP ? "#{sep}#{real_name}" : real_name.to_s) : real_name.to_sym
+        end
+
+        def show_real_name?
+          real_name and caller[1] =~ /`signature'/
+        end
+
+      end
+    end
+
+    module Handlers
+
+      # Displays Sinatra routes in YARD documentation.
+      # Can also be used to parse routes from files without executing those files.
+      module Sinatra
+
+        # Logic both handlers have in common.
+        module AbstractRouteHandler
+
+          def self.routes
+            @routes ||= []
+          end
+
+          def process
+            path = http_path
+            path = $1 if path =~ /^"(.*)"$/
+            register_route(http_verb, path)
+            register_route('HEAD', path) if http_verb == 'GET'
+          end
+
+          def register_route(verb, path, doc = nil)
+            # HACK: Removing some illegal letters.
+            method_name = "" << verb << "_" << path.gsub(/[^\w_]/, "_")
+            real_name   = "" << verb << " " << path
+            route = register CodeObjects::RouteObject.new(namespace, method_name, :instance) do |o|
+              o.visibility = "public"
+              o.source     = statement.source
+              o.signature  = real_name
+              o.explicit   = true
+              o.scope      = scope
+              o.docstring  = statement.comments
+              o.http_verb  = verb
+              o.http_path  = path
+              o.real_name  = real_name
+              o.add_file(parser.file, statement.line)
+            end
+            AbstractRouteHandler.routes << route
+            yield(route) if block_given?
+          end
+
+        end
+
+        # Route handler for YARD's source parser.
+        class RouteHandler < ::YARD::Handlers::Ruby::Base
+          include AbstractRouteHandler
+          handles method_call(:get)
+          handles method_call(:post)
+          handles method_call(:put)
+          handles method_call(:delete)
+          handles method_call(:head)
+          def http_verb
+            statement.method_name(true).to_s.upcase
+          end
+          def http_path
+            statement.parameters.first.source
+          end
+        end
+
+        # Route handler for YARD's legacy parser.
+        module Legacy
+          class RouteHandler < ::YARD::Handlers::Ruby::Legacy::Base
+            include AbstractRouteHandler
+            handles /\A(get|post|put|delete|head)[\s\(].*/m
+            def http_verb
+              statement.tokens.first.text.upcase
+            end
+            def http_path
+              statement.tokens[2].text
+            end
+          end
+        end
+
+      end
+    end
+  end
+
+  Yard = YARD
+
+end

data/lib/big_band/integration.rb

@@ -0,0 +1,42 @@
+unless defined? Sinatra::Base
+  module Sinatra # :nodoc:
+    class Base # :nodoc:
+    end
+  end
+end
+
+class BigBand < Sinatra::Base
+  module Integration
+    GLOBBER = "{lib/**,app/**,routes/**,models/**,views/**,controllers/**,.}/*.rb"
+
+    def self.routes_for(source)
+      case source
+      when Class
+        source.routes
+      when String
+        require "big_band/integration/yard"
+        ::YARD::Registry.load(Dir[source], true)
+        YARD::Handlers::Sinatra::AbstractRouteHandler.routes.inject({}) do |routes, route_object|
+          routes[route_object.http_verb] ||= []
+          routes[route_object.http_verb] << route_object.http_path
+          routes
+        end
+      else
+        raise ArgumentError, "cannot retrieve routes for #{source.inspect}"
+      end
+    end
+
+    def self.each_route(source)
+      routes_for(source).each do |verb, routes|
+        routes.each do |route|
+          path   = route.path    if route.respond_to? :path
+          path ||= route.pattern if route.respond_to? :pattern
+          path ||= route[0]      if route.is_a? Array
+          path ||= route
+          yield(verb, path)
+        end
+      end
+    end
+
+  end
+end

data/lib/big_band/more_helpers.rb

@@ -0,0 +1,50 @@
+require "haml"
+require "big_band/integration" unless defined? BigBand # so this is usable without sinatra
+
+class BigBand < Sinatra::Base
+
+  # Adds more helper methods (more docs coming soon).
+  module MoreHelpers
+
+    module InstanceMethods
+      include Haml::Helpers
+
+      def content_for(name, &block)
+        name = name.to_s
+        @content_for ||= Hash.new {|h,k| h[k] = [] }
+        @content_for[name] << block if block
+        @content_for[name]
+      end
+
+      def yield_content(name, *args)
+        haml_helper do
+          content_for(name).each do |block|
+            result = block.call(*args)
+            haml_concat result unless block_is_haml? block
+          end
+        end
+      end
+
+      def get_content(name, *args)
+        non_haml { yield_content(name, *args) }
+      end
+
+      private
+
+      # Will make use of capture_haml depending on whether it is called from
+      # within Haml code or not. Thus helpers may be shared between Haml and
+      # others (like ERB), but still enjoy all the fancy Haml::Helpers tools.
+      def haml_helper(&block)
+        return capture_haml(&block) unless is_haml?
+        yield
+      end
+
+    end
+
+    def self.registered(klass)
+      # Just in case #helpers does more magic some day.
+      klass.helpers InstanceMethods
+    end
+
+  end
+end

data/lib/big_band/more_server/rainbows.rb

@@ -0,0 +1,13 @@
+require "big_band/more_server/unicorn"
+require "rainbows"
+
+class BigBand < Sinatra::Base
+  module MoreServer
+    # Rack Handler to use Rainbows for Sinatra::Base.run!
+    module Rainbows
+      def self.run(app, options = {})
+        BigBand::MoreServer::Unicorn.run app, options.merge(:Backend => ::Rainbows)
+      end
+    end
+  end
+end

data/lib/big_band/more_server/unicorn.rb

@@ -0,0 +1,28 @@
+require "sinatra/base"
+require "unicorn"
+require "rack/content_length"
+require "rack/chunked"
+
+class BigBand < Sinatra::Base
+  module MoreServer
+    # Rack Handler to use Unicorn for Sinatra::Base.run!
+    module Unicorn
+      def self.run(app, options={})
+        app = Rack::Builder.new do
+          # TODO: env dependend stuff.
+          use Rack::CommonLogger, $stderr
+          use Rack::ShowExceptions
+          use Rack::Lint
+          run app
+        end.to_app
+        options[:Backend] ||= ::Unicorn
+        options[:Host] ||= ::Unicorn::Const::DEFAULT_HOST
+        options[:Port] ||= ::Unicorn::Const::DEFAULT_PORT
+        options[:listeners] = ["#{options.delete :Host}:#{options.delete :Port}"]
+        server = options.delete(:Backend)::HttpServer.new app, options
+        yield server if block_given?
+        server.start.join
+      end
+    end
+  end
+end

data/lib/big_band/more_server.rb

@@ -0,0 +1,14 @@
+require "sinatra/base"
+
+class BigBand < Sinatra::Base
+  # Adds more servers to Sinatra::Base#run! (currently unicorn and rainbows).
+  module MoreServer
+    autoload :Unicorn,  "big_band/more_server/unicorn"
+    autoload :Rainbows, "big_band/more_server/rainbows"
+    def self.registered(klass)
+      Rack::Handler.register "unicorn", "BigBand::MoreServer::Unicorn"
+      Rack::Handler.register "rainbows", "BigBand::MoreServer::Rainbows"
+      klass.server.unshift "rainbows", "unicorn"
+    end
+  end
+end

data/lib/big_band/reloader.rb

@@ -0,0 +1,113 @@
+require "sinatra/base"
+require "big_band/basic_extensions"
+
+class BigBand < Sinatra::Base
+
+  # Advanced reloader for sinatra. Reloads only files that have changed and automatically
+  # detects orphaned routes that have to be removed. Files defining routes will be added
+  # to the reload list per default. Avoid reloading with dont_reload. Add other files to
+  # the reload list with also_reload.
+  #
+  # Usage:
+  #
+  #   require "big_band"
+  #   class Foo < Sinatra::Base
+  #     configure(:development) do
+  #       register BigBand::Reloader
+  #       also_reload "app/models/*.rb"
+  #       dont_reload "lib/**/*.rb"
+  #     end
+  #   end
+  #
+  # Per default this will only be acitvated in development mode.
+  module Reloader
+
+    class FileWatcher < Array
+
+      attr_reader :file, :mtime
+
+      extend Enumerable
+      @map ||= {}
+
+      def self.register(route)
+        new(route.file) << route if route.file?
+      end
+
+      def self.new(file)
+        @map[file.expand_path] ||= super(file)
+      end
+
+      def self.each(&block)
+        @map.values.each(&block) 
+      end
+
+      def initialize(file)
+        @reload = true
+        @file, @mtime = file, File.mtime(file)
+        super()
+      end
+
+      def changed?
+        @mtime != File.mtime(file)
+      end
+
+      def dont_reload!(dont = true)
+        @reload = false
+      end
+
+      def reload?
+        @reload and changed?
+      end
+
+      def reload
+        reload! if reload?
+      end
+
+      def reload!
+        puts "reloading #{file}"
+        each { |route| route.deactivate }
+        $LOAD_PATH.delete file
+        $LOAD_PATH.delete file.expand_path
+        clear
+        require file
+      end
+
+    end
+
+    module ClassMethods
+
+      def dont_reload(*files)
+        files.flatten.each do |file|
+          FileWatcher.new(file).dont_reload!
+        end
+      end
+
+      def also_relaod(*files)
+        files.flatten.each do |file|
+          FileWatcher.new(file).dont_reload! false
+        end
+      end
+    end
+
+    def self.registered(klass)
+      klass.register AdvancedRoutes
+      klass.extend ClassMethods
+      klass.each_route { |route| advanced_route_added(route) }
+      klass.before { Reloader.reload_routes }
+    end
+
+    def self.advanced_route_added(route)
+      FileWatcher.register(route)
+    end
+
+    def self.thread_safe?
+      Thread and Thread.list.size > 1 and Thread.respond_to? :exclusive
+    end
+
+    def self.reload_routes(thread_safe = true)
+      return Thread.exclusive { reload_routes(false) } if thread_safe and thread_safe?
+      FileWatcher.each { |file| file.reload }
+    end
+
+  end
+end

data/lib/big_band/sass.rb

@@ -0,0 +1,28 @@
+require "sass"
+require "big_band/integration" unless defined? BigBand # so this is usable without sinatra
+
+class BigBand < Sinatra::Base
+
+  # BigBand::Sass extends SassScript with more functions like min or max.
+  #
+  # Example:
+  #   .someClass
+  #     width = max(!default_width - 10px, 200px)
+  #
+  # This can be used without BigBand or even Sinatra.
+  module Sass
+    module Functions
+      ::Sass::Script::Functions.send :include, self
+
+      def min(*args)
+        args.min { |a, b| a.value <=> b.value }
+      end
+
+      def max(*args)
+        args.max { |a, b| a.value <=> b.value }
+      end
+
+    end
+  end
+
+end  

data/lib/big_band/version.rb

@@ -0,0 +1,3 @@
+require "big_band/integration" unless defined? BigBand
+BigBand::VERSION = "0.2.1"
+BigBand::DATE    = "2009-12-28"