sinatra-namespace 0.4.0.a

data/README.md

@@ -0,0 +1,135 @@
+Sinatra::Namespace
+==================
+
+Adds namespaces to [Sinatra](http://sinatrarb.com). Allows namespaces to have local helpers.
+Not wanting local helpers probably is a sign that what you really want is writing rack middleware instead.
+See alternatives section.
+
+BigBand
+-------
+
+Sinatra::Namespace is part of the [BigBand](http://github.com/rkh/big_band) stack.
+Check it out if you are looking for other fancy Sinatra extensions.
+
+Usage
+-----
+
+Classic style:
+
+    require "sinatra"
+    require "sinatra/namespace"
+    
+    helpers do
+      def title
+        "foo bar"
+      end
+      
+      def posts
+        Post.all
+      end
+    end
+    
+    get "/" do
+      haml :index
+    end
+    
+    namspace "/ruby" do
+      helpers do
+        def posts
+          super.where :topic => "ruby"
+        end
+      end
+      
+      get { haml :index }
+      
+      get "/new" do
+        haml :new, {}, :object => Post.new(:topic => "ruby")
+      end
+    end
+
+Note how namespaces can have local helpers not available to the outer namespace but inherits the outer helpers.
+
+Modular style (you can of course use the `namespace` method there, too):
+
+    require "sinatra/base"
+    require "sinatra/namespace"
+    
+    class Application < Sinatra::Base
+      def title
+        "foo bar"
+      end
+      
+      def posts
+        Post.all
+      end
+      
+      module RubyPosts
+        # If you would have called that module Ruby, you would not have to set
+        # your prefix by hand, ain't that cool, huh?
+        prefix "/ruby"
+        
+        def posts
+          super.where :topic => "ruby"
+        end
+        
+        get { haml :index }
+
+        get "/new" do
+          haml :new, {}, :object => Post.new(:topic => "ruby")
+        end
+      end
+    end
+
+Wait, did that module turn into a namespace all by itself? No, actually it got turned into one by `Application` when it
+tried to call `prefix`, which is not defined. `Sinatra::Namspace` sets up `nested_method_missing` (from `monkey-lib`) to
+catch that cases.
+
+You can influence that behavior by setting `auto_namespace`:
+
+    class Application < Sinatra::Base
+      # enables auto namespacing, is default
+      enable :auto_namespace
+      
+      # disables auto namespacing, is default
+      disable :auto_namespace
+      
+      # triggers auto namespaceing only on prefix and get
+      set :auto_namespace, :only => [:prefix, :get]
+      
+      # triggers auto namespacing on all public methods of Sinatra::Namspace::NestedMethods except prefix
+      set :auto_namespace, :except => :prefix
+    end
+
+So, how does one create a namespace from a module without that auto detection? Simple:
+
+    Application.make_namespace SomeModule, :prefix => "/somewhere"
+
+Alternatives
+------------
+
+Sinatra::Namespace is made for sharing some state/helpers.
+If that is no what you are looking for, you have two alternative directions.
+
+Simple prefixing, shares all state/helpers:
+
+    require "sinatra/base"
+    require "monkey"
+    
+    admin_prefix = "/this/is/the/admin/prefix"
+    get(admin_prefix) { haml :admin_index }
+    get(admin_prefix / "new_user") { haml :new_user }
+    get(admin_prefix / "admin_stuff") { haml :admin_stuff }
+
+Middleware, shares no state/helpers:
+
+    require "sinatra/base"
+    
+    class Application < Sinatra::Base
+      class AdminNamespace < Sinatra::Base
+        get("admin/prefix") { haml :admin_index }
+        get("admin/new_user") { haml :new_user }
+        get("admin/admin_stuff") { haml :admin_stuff }
+      end
+      
+      use AdminNamespace
+    end

data/lib/sinatra/namespace.rb

@@ -0,0 +1,132 @@
+require "monkey"
+require "sinatra/base"
+require "sinatra/sugar"
+require "sinatra/advanced_routes"
+
+module Sinatra
+  module Namespace
+    DONT_FORWARD = %w[after before call configure disable enable error new not_found register reset! run! set use]
+
+    module NestedMethods
+      def prefix(value = nil)
+        @prefix = value if value
+        @prefix
+      end
+
+      def base(value = nil)
+        @base = value if value
+        @base
+      end
+
+      def helpers(*modules, &block)
+        modules.each { |m| include m }
+        class_eval(&block) if block
+      end
+
+      def get(name = nil, options = {}, &block);    prefixed(:get,    name, options, &block); end
+      def put(name = nil, options = {}, &block);    prefixed(:put,    name, options, &block); end
+      def post(name = nil, options = {}, &block);   prefixed(:post,   name, options, &block); end
+      def delete(name = nil, options = {}, &block); prefixed(:delete, name, options, &block); end
+      def head(name = nil, options = {}, &block);   prefixed(:head,   name, options, &block); end
+
+      def respond_to?(name)
+        super or (base.respond_to? name and forward? name)
+      end
+
+      def methods(*args)
+        (super + base.methods(*args).select { |m| forward? m }).uniq
+      end
+
+      private
+
+      def application
+        klass = self
+        klass = klass.base while klass.respond_to? :base
+        klass
+      end
+
+      def prefixed(verb, name = nil, options = {}, &block)
+        name, options = nil, name if name.is_a? Hash and options.empty?
+        path = prefix.to_s + name.to_s
+        application.send(:define_method, "#{verb} #{path}", &block)
+        unbound_method, container = application.instance_method("#{verb} #{path}"), self
+        if block.arity != 0 
+          wrapper = proc { |*args| container.send(:wrap, unbound_method, self, *args) }
+        else
+          wrapper = proc { container.send(:wrap, unbound_method, self) }
+        end
+        base.send(verb, path, options, &wrapper)
+      end
+
+      def wrap(unbound_method, app, *args)
+        app.extend self
+        unbound_method.bind(app).call(*args)
+      end
+
+      def method_missing(name, *args, &block)
+        Monkey.invisible { super }
+      rescue NameError => error # allowes adding method_missing in mixins
+        raise error unless base.respond_to? name and forward? name
+        base.send(name, *args, &block)
+      end
+
+      def forward?(name)
+        not Sinatra::NameError::DONT_FORWARD.include? name.to_s
+      end
+    end
+
+    def self.registered(klass)
+      klass.register Sinatra::Sugar
+      klass.set :merge_namespaces => false, :auto_namespace => true
+    end
+
+    def self.make_namespace(mod, options = {})
+      unless options[:base] ||= options[:for]
+        base = mod
+        base = base.parent until base.is_a? Class
+        raise ArgumentError, "base class not given/detected" if base == Object
+        options[:base] = base
+      end
+      options[:prefix] ||= "/" << mod.name.gsub(/^#{options[:base]}::/, '').to_const_path
+      mod.extend self
+      mod.extend NestedMethods
+      options.each { |k,v| mod.send(k, v) }
+      mod
+    end
+
+    def make_namespace(mod, options = {})
+      Sinatra::Namespace.make_namespace mod, options.merge(:base => self)
+    end
+
+    def namespace(prefix, merge = nil, &block)
+      prefix = prefix.to_s
+      if merge or (merge.nil? and merge_namespaces?)
+        @namespaces ||= {}
+        @namespaces[prefix] ||= namespace prefix, false
+        @namespaces[prefix].class_eval(&block) if block
+      else
+        mod = make_namespace Module.new, :prefix => prefix
+        mod.class_eval(&block) if block
+        mod
+      end
+    end
+
+    def nested_method_missing(klass, meth, *args, &block)
+      return super unless make_namespace? klass, meth
+      make_namespace klass
+      klass.send(meth, *args, &block)
+    end
+
+    def make_namespace?(klass, meth)
+      return false if !auto_namespace? or klass.is_a? NestedMethods
+      meths = NestedMethods.instance_methods.map { |m| m.to_s }
+      if auto_namespace != true
+        meths = [auto_namespace[:only]].flatten.map { |m| m.to_s } if auto_namespace.include? :only
+        [auto_namespace[:except]].flatten.each { |m| meths.delete m.to_s } if auto_namespace.include? :except
+      end
+      meths.include? meth.to_s
+    end
+  end
+
+  register Namespace
+end

data/spec/sinatra/namespace_spec.rb

@@ -0,0 +1,165 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe Sinatra::Namespace do
+  [:get, :head, :post, :put, :delete].each do |verb|
+    describe "HTTP #{verb.to_s.upcase}" do
+      before :each do
+        Object.send :remove_const, :App if Object.const_defined? :App
+        class ::App < Sinatra::Base
+          register Sinatra::Namespace
+        end
+        app App
+      end
+
+      describe :namespace do
+        it "should add routes including prefix to the base app" do
+          app.namespace "/foo" do
+            send(verb, "/bar") { "baz" }
+          end
+          browse_route(verb, "/foo/bar").should be_ok
+          browse_route(verb, "/foo/bar").body.should == "baz" unless verb == :head
+        end
+
+        it "should allowes adding routes with no path" do
+          app.namespace "/foo" do
+            send(verb) { "bar" }
+          end
+          browse_route(verb, "/foo").should be_ok
+          browse_route(verb, "/foo").body.should == "bar" unless verb == :head
+        end
+      end
+
+      describe :make_namespace do
+        it "extends modules make_namespace is called on" do
+          mod = Module.new
+          mod.should_not respond_to(verb)
+          app.make_namespace(mod, :prefix => "/foo")
+          mod.should respond_to(verb)
+        end
+
+        it "returns the module" do
+          mod = Module.new
+          app.make_namespace(mod, :prefix => "/foo").should == mod
+        end
+
+        it "sets base" do
+          app.make_namespace(Module.new, :prefix => "/foo").base.should == app
+        end
+
+        it "sets prefix" do
+          app.make_namespace(Module.new, :prefix => "/foo").prefix.should == "/foo"
+        end
+
+        it "automatically sets a prefix based on module name if none is given" do
+          # FooBar = Module.new  <= does not work in Ruby 1.9
+          module ::FooBar; end
+          app.make_namespace ::FooBar
+          ::FooBar.prefix.should == "/foo_bar"
+        end
+
+        it "does not add the application name to auto-generated prefixes" do
+          #App::FooBar = Module.new <= does not work in Ruby 1.9
+          class ::App < Sinatra::Base; module FooBar; end; end
+          app.make_namespace App::FooBar
+          App::FooBar.prefix.should == "/foo_bar"
+        end
+      end
+
+      describe :auto_namespace do
+        before do
+          class ::App < Sinatra::Base; module Foo; end; end
+        end
+
+        it "detects #{verb}" do
+          App::Foo.should_not respond_to(verb)
+          App::Foo.send(verb, "/bar") { "baz" }
+          App::Foo.should respond_to(verb)
+          browse_route(verb, "/foo/bar").should be_ok
+          browse_route(verb, "/foo/bar").body.should == "baz" unless verb == :head
+        end
+
+        it "ignores #{verb} if auto namespaceing is disabled" do
+          app.disable :auto_namespace
+          App::Foo.should_not respond_to(verb)
+          proc { App::Foo.send(verb, "/bar") { "baz" } }.should raise_error(NameError)
+          App::Foo.should_not respond_to(verb)
+        end
+
+        it "ignores #{verb} if told to via :except" do
+          app.set :auto_namespace, :except => verb
+          App::Foo.should_not respond_to(verb)
+          proc { App::Foo.send(verb, "/bar") { "baz" } }.should raise_error(NameError)
+          App::Foo.should_not respond_to(verb)
+        end
+
+        it "does not ignore #{verb} if not included in :except" do
+          app.set :auto_namespace, :except => ["prefix"]
+          App::Foo.should_not respond_to(verb)
+          App::Foo.send(verb, "/bar") { "baz" }
+          App::Foo.should respond_to(verb)
+        end
+
+        it "does ignore #{verb} if not included in :only" do
+          app.set :auto_namespace, :only => "prefix"
+          App::Foo.should_not respond_to(verb)
+          proc { App::Foo.send(verb, "/bar") { "baz" } }.should raise_error(NameError)
+          App::Foo.should_not respond_to(verb)
+        end
+
+        it "does not ignore #{verb} if included in :only" do
+          app.set :auto_namespace, :only => ["prefix", verb]
+          App::Foo.should_not respond_to(verb)
+          App::Foo.send(verb, "/bar") { "baz" }
+          App::Foo.should respond_to(verb)
+        end
+
+        it "detects prefix" do
+          App::Foo.should_not respond_to(:prefix)
+          App::Foo.prefix.should == "/foo"
+        end
+      end
+
+      describe :helpers do
+        it "makes helpers defined inside a namespace not available to routes outside that namespace" do
+          helpers { define_method(:foo) { 42 } }
+          app.namespace("/foo").helpers { define_method(:bar) { 42 } }
+          app.new.should respond_to(:foo)
+          app.new.should_not respond_to(:bar)
+        end
+
+        it "allowes overwriting helpers for routes within a namespace" do
+          helpers { define_method(:foo) { "foo" } }
+          define_route(verb, "/foo") { foo }
+          app.namespace("/foo") do
+            define_method(:foo) { "bar" }
+            send(verb, "/foo") { foo }
+          end
+          browse_route(verb, "/foo").should be_ok
+          browse_route(verb, "/foo/foo").should be_ok
+          unless verb == :head
+            browse_route(verb, "/foo").body.should == "foo"
+            browse_route(verb, "/foo/foo").body.should == "bar"
+          end
+        end
+
+        it "allowes accessing helpers defined outside the namespace" do
+          helpers { define_method(:foo) { "foo" } }
+          app.namespace("/foo").send(verb, "") { foo }
+          browse_route(verb, "/foo").should be_ok
+          browse_route(verb, "/foo").body.should == "foo" unless verb == :head
+        end
+
+        it "allowes calling super in helpers overwritten inside a namespace" do
+          helpers { define_method(:foo) { "foo" } }
+          app.namespace("/foo") do
+            define_method(:foo) { super().upcase }
+            send(verb) { foo }
+          end
+          browse_route(verb, "/foo").should be_ok
+          browse_route(verb, "/foo").body.should == "FOO" unless verb == :head
+        end
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require "sinatra/rspec"
+require "sinatra/namespace"

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification 
+name: sinatra-namespace
+version: &id001 !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 0
+  - 4
+  - 0
+  - a
+  version: 0.4.0.a
+platform: ruby
+authors: 
+- Konstantin Haase
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-01 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: monkey-lib
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - *id001
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sinatra-sugar
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - *id001
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sinatra-test-helper
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - *id001
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        - 4
+        version: 0.9.4
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id006
+description: Adds namespaces to Sinatra, allows namespaces to have local helpers (part of BigBand).
+email: konstantin.mailinglists@googlemail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/sinatra/namespace.rb
+- spec/sinatra/namespace_spec.rb
+- spec/spec_helper.rb
+- README.md
+has_rdoc: yard
+homepage: http://github.com/rkh/sinatra-namespace
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Adds namespaces to Sinatra, allows namespaces to have local helpers (part of BigBand).
+test_files: []
+