sinatra-namespace 0.5.1 → 0.6.0

data/README.md

@@ -1,20 +1,37 @@
-Sinatra::Namespace
-==================
+# 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
--------
+## Features
 
-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.
+### Nesting by prefix
 
-Usage
------
+    require "sinatra"
+    require "sinatra/namespace"
+    
+    namespace '/blog' do
+      get { haml :index }
+    
+      get '/:entry_id' do |id|
+        @entry = Entry.find(id)
+        haml :entry
+      end
+    end
+
+### Nesting by condition
+
+    require "sinatra"
+    require "sinatra/namespace"
+    
+    namespace :host_name => "www.example.com" do
+      # ...
+    end
+    
+    namespace :host_name => "api.example.com" do
+      # ...
+    end
 
-Classic style:
+### Local helpers, filters and error handling
 
     require "sinatra"
     require "sinatra/namespace"
@@ -57,7 +74,7 @@ Classic style:
       end
     end
 
-Note how namespaces can have local helpers not available to the outer namespace but inherits the outer helpers.
+### With modules
 
 Modular style (you can of course use the `namespace` method there, too):
 
@@ -91,8 +108,7 @@ Modular style (you can of course use the `namespace` method there, too):
     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::Namespace` sets up `nested_method_missing` (from `monkey-lib`) to
-catch that cases.
+tried to call `prefix`, which is not defined.
 
 You can influence that behavior by setting `auto_namespace`:
 
@@ -129,12 +145,11 @@ 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-lib"
     
     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 }
+    get("#{admin_prefix}/new_user") { haml :new_user }
+    get("#{admin_prefix}/admin_stuff") { haml :admin_stuff }
 
 Middleware, shares no state/helpers:
 

data/lib/sinatra/namespace.rb

@@ -1,218 +1,156 @@
-require "monkey-lib"
-require "sinatra/base"
-require "sinatra/sugar"
+require 'sinatra/base'
 
 module Sinatra
   module Namespace
-    DONT_FORWARD = %w[call configure disable enable new register reset! run! set use template]
-
     module NestedMethods
-      def errors
-        @errors ||= {}
-      end
-
-      def prefix(value = nil)
-        @prefix = value if value
-        @prefix
+      DONT_FORWARD = %w[call configure disable enable new register reset! run! set use template layout]
+      attr_reader :prefix, :options, :base
+
+      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 before(name = "*", &block)                prefixed(:before, name,          &block) end
+      def after(name = "*", &block)                 prefixed(:after,  name,          &block) end
+
+      def helpers(*list, &block)
+        include(*list) unless list.empty?
+        class_eval(&block) if block
       end
 
-      def base(value = nil)
-        @base = value if value
-        @base
+      def settings
+        return base if base.is_a? Class
+        base.settings
       end
 
-      def helpers(*modules, &block)
-        modules.each { |m| include m }
-        class_eval(&block) if block
+      def respond_to?(*args)
+        return true if super
+        base.respond_to?(*args) and forward(args.first)
       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 error(codes=Exception, &block)
-        [*codes].each { |c| errors[c] = block }
+      def errors
+        @errors ||= {}
       end
 
       def not_found(&block)
         error(404, &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
-
-      def before_filters
-        @before_filters ||= []
-      end
-
-      def after_filters
-        @after_filters ||= []
-      end
-
-      def before(&block)
-        before_filters << block
-      end
-
-      def after(&block)
-        after_filters << block
+      def error(codes = Exception, &block)
+        [*codes].each { |c| errors[c] = block }
       end
 
       private
 
-      def always_activate
-        get(/.*/) { pass }
-      end
-
-      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?
+      def prefixed_path(name)
         if prefix.is_a? Regexp or name.is_a? Regexp
           path = /#{prefix}#{name}/
           path = /^#{path}$/ if base.is_a? Class
+          path
         else
-          path = prefix.to_s + name.to_s
+          prefix.to_s + name.to_s
         end
-        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 prepare_instance(app)
-        return if app.is_a? self
-        base.prepare_instance app if base.respond_to? :prepare_instance
-        class << app
-          @filters ||= {}
-          @filters[:after] ||= []
-          @after_filters ||= []
+      def prefixed(method, name, *args, &block)
+        if name.respond_to? :key?
+          args.unshift name
+          name = nil
         end
-        before_filters.each { |block| app.instance_eval(&block) }
-        after_filters.each { |block| app.singleton_class.after(&block) }
-        app.extend self
+        options.each { |o, a| settings.send(o, *a ) }
+        base.send(method, prefixed_path(name), *args, &block)
       end
 
-      def wrap(unbound_method, app, *args)
-        prepare_instance app
-        app.current_namespace = self
-        unbound_method.bind(app).call(*args)
+      def forward?(name)
+        not DONT_FORWARD.include? name.to_s
       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
+        return super unless base.respond_to? name and forward? name
         base.send(name, *args, &block)
       end
+    end
 
-      def forward?(name)
-        not Sinatra::Namespace::DONT_FORWARD.include? name.to_s
+    module ClassMethods
+      def namespace(prefix = nil, options = {}, &block)
+        Namespace.setup(self, prefix, options, Module.new, &block)
       end
-    end
 
-    def self.registered(klass)
-      klass.register Sinatra::Sugar
-      klass.__send__ :include, InstanceMethods
-      klass.enable :merge_namespaces, :auto_namespace, :always_activate_namespaces
-    end
+      def make_namespace(mod, options = {})
+        options[:base] ||= self
+        Namespace.make_namespace(mod, options)
+      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
+      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
-      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.send(:always_activate) if options[:base].always_activate_namespaces?
-      mod
     end
 
-    module InstanceMethods
-      attr_accessor :current_namespace
-
-      if Sinatra::VERSION > '1.0' or Sinatra::Base.respond_to? :filters # master is still 1.0
-        def filter!(type, base = self.class)
-          super
-          if type == :after and base == self.class and singleton_class.filters and singleton_class.after_filters
-            singleton_class.after_filters.each { |b| instance_eval(&b) }
-          end
-        end
-      else
-        def after_filter!(base = self.class)
-          super
-          if base == self.class and singleton_class.after_filters
-            singleton_class.after_filters.each { |b| instance_eval(&b) }
+    module ModularMethods
+      def setup(base, prefix = nil, options = {}, mixin = nil, &block)
+        prefix, options = nil, prefix if options.empty? and prefix.respond_to? :key?
+        prefix ||= ""
+        mixin  ||= self
+        mixin.class_eval { @prefix, @options, @base = prefix, options, base }
+        mixin.extend ClassMethods, NestedMethods
+        mixin.send(:define_method, :error_block!) do |*keys|
+          if block = keys.inject(nil) { |b,k| b ||= mixin.errors[k] }
+            instance_eval(&block)
+          else
+            super(*keys)
           end
         end
+        mixin.before { extend mixin }
+        mixin.class_eval(&block) if block
+        mixin
       end
+    end
 
-      def error_block!(*keys)
-        keys.detect do |key|
-          base = current_namespace || self.class
-          while base.respond_to? :errors
-            if block = base.errors[key]
-              # found a handler, eval and return result
-              return instance_eval(&block)
-            else
-              base = base.respond_to?(:base) ? base.base : base.superclass
-            end
-          end
+    module NamespaceDetector
+      Module.send(:include, self)
+      def method_missing(meth, *args, &block)
+        return super if is_a? Class or !name
+        base = Object
+        detected = name.split('::').any? do |name|
+          base = base.const_get(name)
+          base < Sinatra::Base
+        end
+        if detected and base.make_namespace?(self, meth)
+          Sinatra::Namespace.make_namespace self, :base => base
+          send(meth, *args, &block)
+        else
+          super
         end
       end
     end
 
-    def make_namespace(mod, options = {})
-      Sinatra::Namespace.make_namespace mod, options.merge(:base => self)
-    end
+    extend ModularMethods
 
-    def namespace(prefix, merge = nil, &block)
-      if merge or (merge.nil? and merge_namespaces?)
-        @namespaces ||= {}
-        @namespaces[prefix] ||= namespace prefix, false
-        @namespaces[prefix].class_eval(&block) if block
-        @namespaces[prefix]
-      else
-        mod = make_namespace Module.new, :prefix => prefix
-        mod.class_eval(&block) if block
-        mod
-      end
+    def self.make_namespace(mod, options = {})
+      from = caller[0] =~ /make_namespace/ ? caller[1] : caller[0]
+      base = options.delete(:base) || options.delete(:for)
+      options[:prefix] ||= '/' << mod.name.gsub(/^#{base.name}::/, '').
+        gsub(/::/, '/').gsub(/([a-z\d]+)([A-Z][a-z])/,'\1_\2').downcase
+      setup base, options.delete(:prefix), options, mod
     end
 
-    def nested_method_missing(klass, meth, *args, &block)
-      return super unless make_namespace? klass, meth
-      make_namespace klass
-      klass.send(meth, *args, &block)
+    def self.included(klass)
+      klass.extend ModularMethods
+      super
     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
+    def self.registered(klass)
+      klass.extend ClassMethods
+      klass.enable :auto_namespace
     end
   end
 
   register Namespace
-end
+end

data/sinatra-namespace.gemspec

@@ -0,0 +1,20 @@
+SPEC = Gem::Specification.new do |s|
+  # Get the facts.
+  s.name             = "sinatra-namespace"
+  s.version          = "0.6.0"
+  s.description      = "Adds namespaces to Sinatra, allows namespaces to have local helpers."
+
+  # Dependencies
+  s.add_dependency "sinatra", "~> 1.1"
+  s.add_development_dependency "sinatra-test-helper", "~> 0.5.0"
+  s.add_development_dependency "rspec", "~> 1.3.0"
+
+  # Those should be about the same in any BigBand extension.
+  s.authors          = ["Konstantin Haase"]
+  s.email            = "konstantin.mailinglists@googlemail.com"
+  s.files            = `git ls-files`.split("\n")
+  s.has_rdoc         = 'yard'
+  s.homepage         = "http://github.com/rkh/#{s.name}"
+  s.require_paths    = ["lib"]
+  s.summary          = s.description
+end

data/spec/sinatra/namespace_spec.rb

@@ -182,29 +182,29 @@ describe Sinatra::Namespace do
           app.new.should_not respond_to(:bar)
         end
 
-        it "allowes overwriting helpers for routes within a namespace" do
+        it "allows overwriting helpers for routes within a namespace" do
           helpers { define_method(:foo) { "foo" } }
           define_route(verb, "/foo") { foo }
-          app.namespace("/foo") do
+          app.namespace("/bar") 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
+          browse_route(verb, "/bar/foo").should be_ok
           unless verb == :head
             browse_route(verb, "/foo").body.should == "foo"
-            browse_route(verb, "/foo/foo").body.should == "bar"
+            browse_route(verb, "/bar/foo").body.should == "bar"
           end
         end
 
-        it "allowes accessing helpers defined outside the namespace" do
+        it "allows 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
+        it "allows calling super in helpers overwritten inside a namespace" do
           helpers { define_method(:foo) { "foo" } }
           app.namespace("/foo") do
             define_method(:foo) { super().upcase }
@@ -220,9 +220,7 @@ describe Sinatra::Namespace do
 
   describe :errors do
     it "should allow custom error handlers with not found" do
-      app.namespace('/en') { always_activate }
       app.namespace('/de') do
-        always_activate
         not_found { 'nicht gefunden' }
       end
       get('/foo').status.should     == 404
@@ -234,9 +232,7 @@ describe Sinatra::Namespace do
     end
 
     it "should allow custom error handlers with error" do
-      app.namespace('/en') { always_activate }
       app.namespace('/de') do
-        always_activate
         error(404) { 'nicht gefunden' }
       end
       get('/foo').status.should     == 404
@@ -248,6 +244,30 @@ describe Sinatra::Namespace do
     end
   end
 
+  describe 'conditions' do
+    it 'allows using conditions' do
+      app.namespace(:host_name => 'example.com') do
+        get('/') { 'yes' }
+      end
+      app.get('/') { 'no' }
+      get('/', {}, { 'HTTP_HOST' => 'example.com' })
+      last_response.body.should == 'yes'
+      get('/', {}, { 'HTTP_HOST' => 'example.org' })
+      last_response.body.should == 'no'
+    end
+
+    it 'allows combining conditions with a prefix' do
+      app.namespace('/foo', :host_name => 'example.com') do
+        get { 'yes' }
+      end
+      app.get('/foo') { 'no' }
+      get('/foo', {}, { 'HTTP_HOST' => 'example.com' })
+      last_response.body.should == 'yes'
+      get('/foo', {}, { 'HTTP_HOST' => 'example.org' })
+      last_response.body.should == 'no'
+    end
+  end
+
   describe 'memory' do
     before do
       app.namespace('/foo') { get('/bar') { 'blah' }}

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: sinatra-namespace
 version: !ruby/object:Gem::Version 
-  hash: 9
+  hash: 7
   prerelease: false
   segments: 
   - 0
-  - 5
-  - 1
-  version: 0.5.1
+  - 6
+  - 0
+  version: 0.6.0
 platform: ruby
 authors: 
 - Konstantin Haase
@@ -15,27 +15,26 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-18 00:00:00 +02:00
+date: 2010-10-30 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: monkey-lib
+  name: sinatra
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 13
         segments: 
-        - 0
-        - 5
-        - 2
-        version: 0.5.2
+        - 1
+        - 1
+        version: "1.1"
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: sinatra-sugar
+  name: sinatra-test-helper
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -48,46 +47,15 @@ dependencies:
         - 5
         - 0
         version: 0.5.0
-  type: :runtime
+  type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: sinatra-test-helper
+  name: rspec
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 0
-        - 5
-        - 0
-        version: 0.5.0
-  type: :development
-  version_requirements: *id003
-- !ruby/object:Gem::Dependency 
-  name: sinatra
-  prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 15
-        segments: 
-        - 1
-        - 0
-        version: "1.0"
-  type: :runtime
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
       - !ruby/object:Gem::Version 
         hash: 27
         segments: 
@@ -96,8 +64,8 @@ dependencies:
         - 0
         version: 1.3.0
   type: :development
-  version_requirements: *id005
-description: Adds namespaces to Sinatra, allows namespaces to have local helpers (part of BigBand).
+  version_requirements: *id003
+description: Adds namespaces to Sinatra, allows namespaces to have local helpers.
 email: konstantin.mailinglists@googlemail.com
 executables: []
 
@@ -106,11 +74,12 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- LICENSE
+- README.md
 - lib/sinatra/namespace.rb
+- sinatra-namespace.gemspec
 - spec/sinatra/namespace_spec.rb
 - spec/spec_helper.rb
-- README.md
-- LICENSE
 has_rdoc: yard
 homepage: http://github.com/rkh/sinatra-namespace
 licenses: []
@@ -144,6 +113,6 @@ rubyforge_project:
 rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
-summary: Adds namespaces to Sinatra, allows namespaces to have local helpers (part of BigBand).
+summary: Adds namespaces to Sinatra, allows namespaces to have local helpers.
 test_files: []