renee-url-generation 0.4.0.pre1

data/lib/renee/core/routing.rb

@@ -0,0 +1,319 @@
+module Renee
+  class Core
+    # Collection of useful methods for routing within a {Renee::Core} app.
+    module Routing
+      include Chaining
+
+      # Allow continued routing if a routing block fails to match
+      # 
+      # @param [Boolean] val
+      #   indicate if continued routing should be allowed.
+      #
+      # @api public
+      def continue_routing
+        if block_given?
+          original_env = @env.dup
+          begin
+            yield
+          rescue NotMatchedError
+            @env = original_env
+          end
+        else
+          create_chain_proxy(:continue_routing)
+        end
+      end
+      chainable :continue_routing
+
+      # Match a path to respond to.
+      #
+      # @param [String] p
+      #   path to match.
+      # @param [Proc] blk
+      #   block to yield
+      #
+      # @example
+      #   path('/')    { ... } #=> '/'
+      #   path('test') { ... } #=> '/test'
+      #
+      #   path 'foo' do
+      #     path('bar') { ... } #=> '/foo/bar'
+      #   end
+      #
+      # @api public
+      def path(p, &blk)
+        if blk
+          p = p[1, p.size] if p[0] == ?/
+          extension_part = detected_extension ? "|\\.#{Regexp.quote(detected_extension)}" : ""
+          part(/^\/#{Regexp.quote(p)}(?=\/|$#{extension_part})/, &blk)
+        else
+          create_chain_proxy(:path, p)
+        end
+      end
+      chainable :path
+
+      # Like #path, but doesn't look for leading slashes.
+      def part(p)
+        if block_given?
+          p = /^\/?#{Regexp.quote(p)}/ if p.is_a?(String)
+          if match = env['PATH_INFO'][p]
+            with_path_part(match) { yield }
+          end
+        else
+          create_chain_proxy(:part, p)
+        end
+      end
+
+      # Match parts off the path as variables. The parts matcher can conform to either a regular expression, or be an Integer, or
+      # simply a String.
+      # @param[Object] type the type of object to match for. If you supply Integer, this will only match integers in addition to casting your variable for you.
+      # @param[Object] default the default value to use if your param cannot be successfully matched.
+      #
+      # @example
+      #   path '/' do
+      #     variable { |id| halt [200, {}, id] }
+      #   end
+      #   GET /hey  #=> [200, {}, 'hey']
+      #
+      # @example
+      #   path '/' do
+      #     variable(:integer) { |id| halt [200, {}, "This is a numeric id: #{id}"] }
+      #   end
+      #   GET /123  #=> [200, {}, 'This is a numeric id: 123']
+      #
+      # @example
+      #   path '/test' do
+      #     variable { |foo, bar| halt [200, {}, "#{foo}-#{bar}"] }
+      #   end
+      #   GET /test/hey/there  #=> [200, {}, 'hey-there']
+      #
+      # @api public
+      def variable(type = nil, &blk)
+        blk ? complex_variable(type, '/', 1, &blk) : create_chain_proxy(:variable, type)
+      end
+      alias_method :var, :variable
+      chainable :variable, :var
+
+      def optional_variable(type = nil, &blk)
+        blk ? complex_variable(type, '/', 0..1) { |vars| blk[vars.first] } : create_chain_proxy(:variable, type)
+      end
+      alias_method :optional, :optional_variable
+      chainable :optional, :optional_variable
+
+      # Same as variable except you can match multiple variables with the same type.
+      # @param [Range, Integer] count The number of parameters to capture.
+      # @param [Symbol] type The type to use for match.
+      def multi_variable(count, type = nil, &blk)
+        blk ? complex_variable(type, '/', count, &blk) : create_chain_proxy(:multi_variable, count, type)
+      end
+      alias_method :multi_var, :multi_variable
+      alias_method :mvar, :multi_variable
+      chainable :multi_variable, :multi_var, :mvar
+
+      # Same as variable except it matches indefinitely.
+      # @param [Symbol] type The type to use for match.
+      def repeating_variable(type = nil, &blk)
+        blk ? complex_variable(type, '/', nil, &blk) : create_chain_proxy(:repeating_variable, type)
+      end
+      alias_method :glob, :repeating_variable
+      chainable :repeating_variable, :glob
+
+      # Match parts off the path as variables without a leading slash.
+      # @see #variable
+      # @api public
+      def partial_variable(type = nil, &blk)
+        blk ? complex_variable(type, nil, 1, &blk) : create_chain_proxy(:partial_variable, type)
+      end
+      alias_method :part_var, :partial_variable
+      chainable :partial_variable, :part_var
+
+      # Returns the matched extension. If no extension is present, returns `nil`.
+      #
+      # @example
+      #   halt [200, {}, path] if extension == 'html'
+      #
+      # @api public
+      def extension
+        detected_extension
+      end
+      alias_method :ext, :extension
+
+      # Match no extension.
+      #
+      # @example
+      #   no_extension { |path| halt [200, {}, path] }
+      #
+      # @api public
+      def no_extension(&blk)
+        blk.call unless detected_extension
+      end
+
+      # Match any remaining path.
+      #
+      # @example
+      #   remainder { |path| halt [200, {}, path] }
+      #
+      # @api public
+      def remainder(&blk)
+        blk ? with_path_part(env['PATH_INFO']) { |var| blk.call(var) } : create_chain_proxy(:remainder)
+      end
+      alias_method :catchall, :remainder
+      chainable :remainder, :catchall
+
+      # Respond to a GET request and yield the block.
+      #
+      # @example
+      #   get { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def get(&blk)
+        blk ? request_method('GET', &blk) : create_chain_proxy(:get)
+      end
+      chainable :get
+
+      # Respond to a POST request and yield the block.
+      #
+      # @example
+      #   post { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def post(&blk)
+        blk ? request_method('POST', &blk) : create_chain_proxy(:post)
+      end
+      chainable :post
+
+      # Respond to a PUT request and yield the block.
+      #
+      # @example
+      #   put { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def put(&blk)
+        blk ? request_method('PUT', &blk) : create_chain_proxy(:put)
+      end
+      chainable :put
+
+      # Respond to a DELETE request and yield the block.
+      #
+      # @example
+      #   delete { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def delete(&blk)
+        blk ? request_method('DELETE', &blk) : create_chain_proxy(:delete)
+      end
+      chainable :delete
+
+      # Match only when the path is either '' or '/'.
+      #
+      # @example
+      #   complete { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def complete(&blk)
+        if blk
+          with_path_part(env['PATH_INFO']) { blk.call } if complete?
+        else
+          create_chain_proxy(:complete)
+        end
+      end
+      chainable :complete
+
+      # Test if the path has been consumed
+      #
+      # @example
+      #   if complete?
+      #     halt "Hey, the path is done"
+      #   end
+      #
+      # @api public
+      def complete?
+        (detected_extension and env['PATH_INFO'] =~ /^\/?(\.#{Regexp.quote(detected_extension)}\/?)?$/) || (detected_extension.nil? and env['PATH_INFO'] =~ /^\/?$/)
+      end
+
+      # Match only when the path is ''.
+      #
+      # @example
+      #   empty { halt [200, {}, "hello world"] }
+      #
+      # @api public
+      def empty(&blk)
+        if blk
+          if env['PATH_INFO'] == ''
+            with_path_part(env['PATH_INFO']) { blk.call }
+          end
+        else
+          create_chain_proxy(:empty)
+        end
+      end
+      chainable :empty
+
+      private
+      def complex_variable(type, prefix, count)
+        matcher = variable_matcher_for_type(type)
+        path = env['PATH_INFO'].dup
+        vals = []
+        var_index = 0
+        variable_matching_loop(count) do
+          path.start_with?(prefix) ? path.slice!(0, prefix.size) : break if prefix
+          if match = matcher[path]
+            path.slice!(0, match.first.size)
+            vals << match.last
+          end
+        end
+        return unless count.nil? || count === vals.size
+        with_path_part(env['PATH_INFO'][0, env['PATH_INFO'].size - path.size]) do
+          if count == 1
+            yield(vals.first)
+          else
+            yield(vals)
+          end
+        end
+      end
+
+      def variable_matching_loop(count)
+        case count
+        when Range then count.max.times { break unless yield }
+        when nil   then loop { break unless yield }
+        else            count.times { break unless yield }
+        end
+      end
+
+      def variable_matcher_for_type(type)
+        if self.class.variable_types.key?(type)
+          self.class.variable_types[type]
+        else
+          regexp = case type
+          when nil, String
+            detected_extension ?
+              /(([^\/](?!#{Regexp.quote(detected_extension)}$))+)(?=$|\/|\.#{Regexp.quote(detected_extension)})/ :
+              /([^\/]+)(?=$|\/)/
+          when Regexp
+            type
+          else
+            raise "Unexpected variable type #{type.inspect}"
+          end
+          proc do |path|
+            if match = /^#{regexp.to_s}/.match(path)
+              [match[0]]
+            end
+          end
+        end
+      end
+
+      def with_path_part(part)
+        script_part = env['PATH_INFO'][0, part.size]
+        env['PATH_INFO'] = env['PATH_INFO'].slice(part.size, env['PATH_INFO'].size)
+        env['SCRIPT_NAME'] += script_part
+        yield script_part
+        raise NotMatchedError
+      end
+
+      def request_method(method)
+        if env['REQUEST_METHOD'] == method && complete?
+          yield
+          raise NotMatchedError
+        end
+      end
+    end
+  end
+end

data/lib/renee/core/transform.rb

@@ -0,0 +1,18 @@
+module Renee
+  class Core
+    # Module used for transforming arbitrary values using the registerd variable types.
+    # @see #register_variable_name.
+    #
+    module Transform
+      # Transforms a value according to the rules specified by #register_variable_name.
+      # @param [Symbol] name The name of the variable type.
+      # @param [String] value The value to transform.
+      # @return The transformed value or nil.
+      def transform(type, value)
+        if self.class.variable_types.key?(type) and m = self.class.variable_types[type][value]
+          m.first == value ? m.last : nil
+        end
+      end
+    end
+  end
+end

data/lib/renee/core.rb

@@ -0,0 +1,98 @@
+require 'rack'
+
+require 'renee/version'
+require 'renee/core/matcher'
+require 'renee/core/chaining'
+require 'renee/core/response'
+require 'renee/core/exceptions'
+require 'renee/core/rack_interaction'
+require 'renee/core/request_context'
+require 'renee/core/transform'
+require 'renee/core/routing'
+require 'renee/core/responding'
+require 'renee/core/env_accessors'
+require 'renee/core/plugins'
+
+# Top-level Renee constant
+module Renee
+  # @example
+  #     Renee.core { path('/hello') { halt :ok } }
+  def self.core(&blk)
+    cls = Class.new(Renee::Core)
+    cls.app(&blk) if blk
+    cls
+  end
+
+  # The top-level class for creating core application.
+  # For convience you can also used a method named #Renee
+  # for decalaring new instances.
+  class Core
+    # Current version of Renee::Core
+    VERSION = Renee::VERSION
+
+    # Error raised if routing fails. Use #continue_routing to continue routing.
+    NotMatchedError = Class.new(RuntimeError)
+
+    # Class methods that are included in new instances of {Core} 
+    module ClassMethods
+      include Plugins
+
+      # The application block used to create your application.
+      attr_reader :application_block
+
+      # Provides a rack interface compliant call method. This method creates a new instance of your class and calls
+      # #call on it.
+      def call(env)
+        new.call(env)
+      end
+
+      # Allows you to set the #application_block on your class.
+      # @yield The application block
+      def app(&app)
+        @application_block = app
+        setup do
+          register_variable_type :integer, IntegerMatcher
+          register_variable_type :int, :integer
+        end
+      end
+
+      # Runs class methods on your application.
+      def setup(&blk)
+        instance_eval(&blk)
+        self
+      end
+
+      # The currently available variable types you've defined.
+      def variable_types
+        @variable_types ||= {}
+      end
+
+      # Registers a new variable type for use within {Renee::Core::Routing#variable} and others.
+      # @param [Symbol] name The name of the variable.
+      # @param [Regexp] matcher A regexp describing what part of an arbitrary string to capture.
+      # @return [Renee::Core::Matcher] A matcher
+      def register_variable_type(name, matcher)
+        matcher = case matcher
+        when Matcher then matcher
+        when Array   then Matcher.new(matcher.map{|m| variable_types[m]})
+        when Symbol  then variable_types[matcher]
+        else              Matcher.new(matcher)
+        end
+        matcher.name = name
+        variable_types[name] = matcher
+      end
+    end
+
+    include Chaining
+    include RequestContext
+    include Routing
+    include Responding
+    include RackInteraction
+    include Transform
+    include EnvAccessors
+
+    class << self
+      include ClassMethods
+    end
+  end
+end

data/test/renee-core/chaining_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Route chaining" do
+
+  it "should chaining" do
+    type = { 'Content-Type' => 'text/plain' }
+    mock_app do
+      path('/').get { halt [200,type,['foo']] }
+      continue_routing.path('bar').put { halt [200,type,['bar']] }
+      continue_routing.path('bar').var.put { |id| halt [200,type,[id]] }
+      continue_routing.path('bar').var.get.halt { |id| "wow, nice to meet you " }
+    end
+    get '/'
+    assert_equal 200,   response.status
+    assert_equal 'foo', response.body
+    put '/bar'
+    assert_equal 200,   response.status
+    assert_equal 'bar', response.body
+    put '/bar/asd'
+    assert_equal 200,   response.status
+    assert_equal 'asd', response.body
+  end
+
+  it "should chain and halt with a non-routing method" do
+    type = { 'Content-Type' => 'text/plain' }
+    mock_app do
+      path('/').get.halt "hi"
+    end
+    get '/'
+    assert_equal 200,   response.status
+    assert_equal 'hi', response.body
+  end
+end

data/test/renee-core/env_accessors_test.rb

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+
+require File.expand_path('../test_helper', __FILE__)
+
+describe Renee::Core::EnvAccessors do
+  it "should allow accessing the env" do
+    @app = Renee.core {
+      self.test = 'hello'
+      path('test').get do
+        halt "test is #{test}"
+      end
+    }.setup {
+      env_accessor :test
+    }
+    get '/test'
+    assert_equal 200,   response.status
+    assert_equal 'test is hello', response.body
+  end
+
+  it "should raise when you try to access weird env keys" do
+    assert_raises(Renee::Core::EnvAccessors::InvalidEnvNameError) {
+      @app = Renee.core {
+        self.test_test = 'hello'
+      }.setup {
+        env_accessor "test.test"
+      }
+    }
+  end
+
+  it "should allow weird env keys if you map them" do
+    @app = Renee.core {
+      self.test_test = 'hello'
+      path('test').get do
+        halt "test is #{test_test}"
+      end
+    }.setup {
+      env_accessor "test.test" => :test_test
+    }
+    get '/test'
+    assert_equal 200,   response.status
+    assert_equal 'test is hello', response.body
+  end
+end

data/test/renee-core/include_test.rb

@@ -0,0 +1,14 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "Route::Settings#include" do
+  it "should allow the inclusion of arbitrary modules" do
+    type = { 'Content-Type' => 'text/plain' }
+    @app = Renee.core {
+      halt :ok if respond_to?(:hi)
+    }.setup {
+      include Module.new { def hi; end }
+    }
+    get '/'
+    assert_equal 200,   response.status
+  end
+end

data/test/renee-core/request_context_test.rb

@@ -0,0 +1,70 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class AddHelloThereMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    if env['hello']
+      env['hello'] << "there"
+    else
+      env['hello'] = 'hello'
+    end
+    @app.call(env)
+  end
+end
+
+class AddWhatsThatMiddleware
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    if env['hello']
+      env['hello'] << "that"
+    else
+      env['hello'] = 'whats'
+    end
+    @app.call(env)
+  end
+end
+
+describe "Route::Core::RequestContext#use" do
+  it "should allow the inclusion of arbitrary middlewares" do
+    type = { 'Content-Type' => 'text/plain' }
+    @app = Renee.core {
+      halt env['hello']
+    }.setup {
+      use AddHelloThereMiddleware
+    }
+    get '/'
+    assert_equal 200,     response.status
+    assert_equal 'hello', response.body
+  end
+
+  it "should call middlewares in sequence (1)" do
+    type = { 'Content-Type' => 'text/plain' }
+    @app = Renee.core {
+      halt env['hello']
+    }.setup {
+      use AddHelloThereMiddleware
+      use AddWhatsThatMiddleware
+    }
+    get '/'
+    assert_equal 200,     response.status
+    assert_equal 'hellothat', response.body
+  end
+
+  it "should call middlewares in sequence (2)" do
+    @app = Renee.core {
+      halt env['hello']
+    }.setup {
+      use AddWhatsThatMiddleware
+      use AddHelloThereMiddleware
+    }
+    get '/'
+    assert_equal 200,     response.status
+    assert_equal 'whatsthere', response.body
+  end
+end