sinatra-advanced-routes 0.4.0.a

data/README.md

@@ -0,0 +1,49 @@
+Sinatra::AdvancedRoutes
+=======================
+
+Makes routes first class objects in [Sinatra](http://sinatrarb.com).
+
+BigBand
+-------
+
+Sinatra::AdvancedRoutes is part of the [BigBand](http://github.com/rkh/big_band) stack.
+Check it out if you are looking for other fancy Sinatra extensions.
+
+Example
+-------
+
+    require "sinatra"
+    require "sinatra/advanced_routes"
+
+    admin_route = get "/admin" do
+      administrate_stuff
+    end
+
+    before do
+      # Let's deactivate the route if we have no password file.
+      if File.exists? "admin_password" then admin_route.activate
+      else admin_route.deactivate 
+      end
+    end
+
+    first_route = get "/:name" do
+     # stuff
+    end
+
+    other_route = get "/foo_:name" do
+      # other stuff
+    end
+
+    # Unfortunatly first_route will catch all the requests other_route would
+    # have gotten, since it has been defined first. But wait, we can fix this!
+    other_route.promote
+
+Usage with Sinatra::Base
+------------------------
+
+    require "sinatra/base"
+    require "sinatra/advanced_routes"
+  
+    class Foo < Sinatra::Base
+      register Sinatra::AdvancedRoutes
+    end

data/lib/sinatra/advanced_routes.rb

@@ -0,0 +1,164 @@
+require "sinatra/base"
+require "sinatra/sugar"
+require "monkey"
+
+module Sinatra
+  Base.ignore_caller
+
+  module AdvancedRoutes
+
+    module ArrayMethods
+      ::Array.send :include, self
+
+      def to_route(verb, args = {})
+        dup.to_route! verb, args
+      end
+
+      def to_route!(verb, args = {})
+        extend Sinatra::AdvancedRoutes::Route
+        self.verb = verb
+        args.each do |key, value|
+          send "#{key}=", value
+        end
+        self
+      end
+
+      def signature
+        self
+      end
+
+    end
+
+    module Route
+
+      def self.new(verb, args = {})
+        [].to_route! verb, args
+      end
+
+      attr_accessor :app, :verb, :file, :line, :path, :docstring
+
+      def pattern;    self[0]; end
+      def keys;       self[1]; end
+      def conditions; self[2]; end
+      def block;      self[3]; end
+      alias to_proc block
+
+      def pattern=(value);    self[0] = value; end
+      def keys=(value);       self[1] = value; end
+      def conditions=(value); self[2] = value; end
+      def block=(value);      self[3] = value; end
+
+      def signature
+        [pattern, keys, conditions, block]
+      end
+
+      def active?
+        app.routes[verb].include? self
+      end
+
+      def activate(at_top = false)
+        also_change.each { |r| r.activate }
+        return if active?
+        meth = at_top ? :unshift : :push
+        (app.routes[verb] ||= []).send(meth, self)
+        invoke_hook :route_added, verb, path, block
+        invoke_hook :advanced_route_activated, self
+        self
+      end
+
+      def deactivate
+        also_change.each { |r| r.deactivate }
+        return unless active?
+        (app.routes[verb] ||= []).delete(signature)
+        invoke_hook :route_removed, verb, path, block
+        invoke_hook :advanced_route_deactivated, self
+        self
+      end
+
+      def promote(upwards = true)
+        also_change.each { |r| r.promote(upwards) }
+        deactivate
+        activate(upwards)
+      end
+
+      def file?
+        !!@file
+      end
+
+      def inspect
+        "#<Sinatra::AdvancedRoutes::Route #{ivar_inspect.join ", "}>"
+      end
+
+      def to_route(verb, args = {})
+        args = args.dup
+        [:app, :verb, :file, :line, :path].each { |key| args[key] ||= send(key) }
+        super(verb, args)
+      end
+
+      def also_change(*other_routes)
+        (@also_change ||= []).push(*other_routes)
+      end
+
+      private
+
+      def ivar_inspect
+        [:signature, :verb, :app, :file, :line].map do |var|
+          value = send(var)
+          "@#{var}=#{value.inspect}" unless value.nil?
+        end.compact
+      end
+
+      def invoke_hook(*args)
+        app.send(:invoke_hook, *args)
+      end
+
+    end
+
+    module ClassMethods
+
+      def get(path, opts={}, &block)
+        first_route, *other_routes = capture_routes { super }
+        first_route.also_change(*other_routes)
+        first_route
+      end
+
+      def route(verb, path, options={}, &block)
+        file, line = block.source_location if block.respond_to? :source_location
+        file ||= caller_files.first
+        route = super(verb, path, options, &block)
+        route.to_route! verb, :app => self, :file => file.expand_path, :line => line, :path => path
+        invoke_hook :advanced_route_added, route
+        @capture_routes << route if @capture_routes
+        route
+      end
+
+      def each_route(&block)
+        return enum_for(:each_route) if respond_to? :enum_for and not block
+        routes.inject([]) { |result, (verb, list)| result.push *list.each(&block) }
+      end
+
+      private
+
+      def capture_routes
+        capture_routes_was, @capture_routes = @capture_routes, []
+        yield
+        captured, @capture_routes = @capture_routes, capture_routes_was
+        captured
+      end
+
+    end
+
+    def self.registered(klass)
+      klass.extend ClassMethods
+      klass.routes.each do |verb, routes|
+        routes.each do |route|
+          route.to_route! verb, :app => klass
+          klass.send :invoke_hook, :advanced_root_added, route
+        end
+      end
+    end
+  end
+
+  register AdvancedRoutes
+
+end

data/spec/sinatra/advanced_routes_spec.rb

@@ -0,0 +1,92 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Sinatra::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
+        before { @route = define_route(verb, "/foo") { } }
+        it("exposes app")        { @route.app.should        == app                  }
+        it("exposes path")       { @route.path.should       == "/foo"               }
+        it("exposes file")       { @route.file.should       == __FILE__.expand_path }
+        it("exposes verb")       { @route.verb.should       == verb.to_s.upcase     }
+        it("exposes pattern")    { @route.pattern.should    == @route[0]            }
+        it("exposes keys")       { @route.keys.should       == @route[1]            }
+        it("exposes conditions") { @route.conditions.should == @route[2]            }
+        it("exposes block")      { @route.block.should      == @route[3]            }
+      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
+
+      describe "hooks" do
+        before do
+          @extension = Module.new
+          app.register @extension
+        end
+
+        it "triggers advanced_root_added hook" do
+          meth = @extension.should_receive(:advanced_route_added)
+          verb == :get ? meth.twice : meth.once
+          define_route(verb, "/foo") { }
+        end
+
+        it "triggers advanced_root_activated hook" do
+          route = define_route(verb, "/foo") { }
+          route.deactivate
+          meth = @extension.should_receive(:advanced_route_activated)
+          verb == :get ? meth.twice : meth.once
+          route.activate
+        end
+
+        it "triggers advanced_root_deactivated hook" do
+          route = define_route(verb, "/foo") { }
+          meth = @extension.should_receive(:advanced_route_deactivated)
+          verb == :get ? meth.twice : meth.once
+          route.deactivate
+        end
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require "sinatra/rspec"
+require "sinatra/advanced_routes"
+require "monkey"
+Sinatra::Base.set :environment, :test

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: sinatra-advanced-routes
+version: &id001 !ruby/object:Gem::Version 
+  version: 0.4.0.a
+platform: ruby
+authors: 
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-02-17 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: monkey-lib
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - *id001
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra-sugar
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - *id001
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra-test-helper
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - *id001
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+    version: 
+description: Make Sinatra routes first class objects (part of BigBand).
+email: konstantin.mailinglists@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/sinatra/advanced_routes.rb
+- spec/sinatra/advanced_routes_spec.rb
+- spec/spec_helper.rb
+- README.md
+has_rdoc: yard
+homepage: http://github.com/rkh/sinatra-advanced-routes
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 1.3.1
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Make Sinatra routes first class objects (part of BigBand).
+test_files: []
+