howl-router 0.1

data/lib/howl-router/padrino/ext/class_methods.rb

@@ -0,0 +1,179 @@
+
+class Howl
+  module Padrino
+    module ClassMethods
+      CONTENT_TYPE_ALIASES = { :htm => :html } unless defined?(CONTENT_TYPE_ALIASES)
+      ROUTE_PRIORITY       = {:high => 0, :normal => 1, :low => 2} unless defined?(ROUTE_PRIORITY)
+
+      def router
+        @router ||= ::Howl::Padrino::Core.new
+        block_given? ? yield(@router) : @router
+      end
+
+      def compiled_router
+        if @deferred_routes
+          deferred_routes.each { |routes| routes.each { |(route, dest)| route.to(&dest) } }
+          @deferred_routes = nil
+        end
+        router
+      end
+
+      def deferred_routes
+        @deferred_routes ||= ROUTE_PRIORITY.map{[]}
+      end
+
+      def url(*args)
+        params = args.extract_options!
+        names, params_array = args.partition{|a| a.is_a?(Symbol)}
+        name = names.join("_").to_sym
+        if params.is_a?(Hash)
+          params[:format] = params[:format].to_s unless params[:format].nil?
+          params = value_to_param(params)
+        end
+        url = if params_array.empty?
+                compiled_router.path(name, params)
+              else
+                compiled_router.path(name, *(params_array << params))
+              end
+        url[0,0] = conform_uri(uri_root) if defined?(uri_root)
+        url[0,0] = conform_uri(ENV['RACK_BASE_URI']) if ENV['RACK_BASE_URI']
+        url = "/" if url.blank?
+        url
+      rescue Howl::InvalidRouteException
+        route_error = "route mapping for url(#{name.inspect}) could not be found!"
+        raise ::Padrino::Routing::UnrecognizedException.new(route_error)
+      end
+      alias :url_for :url
+
+      def recognize_path(path)
+        responses = @router.recognize_path(path)
+        [responses[0], responses[1]]
+      end
+
+      private
+        def route(verb, path, *args, &block)
+          options = case args.size
+            when 2
+              args.last.merge(:map => args.first)
+            when 1
+              map = args.shift if args.first.is_a?(String)
+              if args.first.is_a?(Hash)
+                map ? args.first.merge(:map => map) : args.first
+              else
+                {:map => map || args.first}
+              end
+            when 0
+              {}
+            else raise
+          end
+
+          route_options = options.dup
+          route_options[:provides] = @_provides if @_provides
+
+          if allow_disabled_csrf
+            unless route_options[:csrf_protection] == false
+              route_options[:csrf_protection] = true
+            end
+          end
+
+          path, *route_options[:with] = path if path.is_a?(Array)
+          action = path
+          path, name, route_parents, options, route_options = *parse_route(path, route_options, verb)
+          options.reverse_merge!(@_conditions) if @_conditions
+
+          method_name = "#{verb} #{path}"
+          unbound_method = generate_method(method_name, &block)
+
+          block = block.arity != 0 ?
+            proc {|a,p| unbound_method.bind(a).call(*p) } :
+            proc {|a,p| unbound_method.bind(a).call }
+
+          invoke_hook(:route_added, verb, path, block)
+
+          # Howl route construction
+          path[0, 0] = "/" if path == "(.:format)"
+          route = router.add(verb.downcase.to_sym, path, route_options)
+          route.name = name if name
+          route.action = action
+          priority_name = options.delete(:priority) || :normal
+          priority = ROUTE_PRIORITY[priority_name] or raise("Priority #{priority_name} not recognized, try #{ROUTE_PRIORITY.keys.join(', ')}")
+          route.cache = options.key?(:cache) ? options.delete(:cache) : @_cache
+          route.parent = route_parents ? (route_parents.count == 1 ? route_parents.first : route_parents) : route_parents
+          route.host = options.delete(:host) if options.key?(:host)
+          route.user_agent = options.delete(:agent) if options.key?(:agent)
+          if options.key?(:default_values)
+            defaults = options.delete(:default_values)
+            route.default_values = defaults if defaults
+          end
+          options.delete_if do |option, captures|
+            if route.significant_variable_names.include?(option)
+              route.capture[option] = Array(captures).first
+              true
+            end
+          end
+
+          # Add Sinatra conditions
+          options.each {|o, a| route.respond_to?("#{o}=") ? route.send("#{o}=", a) : send(o, *a) }
+          conditions, @conditions = @conditions, []
+          route.custom_conditions.concat(conditions)
+
+          invoke_hook(:padrino_route_added, route, verb, path, args, options, block)
+
+          # Add Application defaults
+          route.before_filters.concat(@filters[:before])
+          route.after_filters.concat(@filters[:after])
+          if @_controller
+            route.use_layout = @layout
+            route.controller = Array(@_controller)[0].to_s
+          end
+
+          deferred_routes[priority] << [route, block]
+
+          route
+        end
+
+        def provides(*types)
+          @_use_format = true
+          condition do
+            mime_types = types.map {|t| mime_type(t) }.compact
+            url_format = params[:format].to_sym if params[:format]
+            accepts = request.accept.map {|a| a.to_str }
+
+            # per rfc2616-sec14:
+            # Assume */* if no ACCEPT header is given.
+            catch_all = (accepts.delete "*/*" || accepts.empty?)
+            matching_types = accepts.empty? ? mime_types.slice(0,1) : (accepts & mime_types)
+            if matching_types.empty? && types.include?(:any)
+              matching_types = accepts
+            end
+
+            if !url_format && matching_types.first
+              type = ::Rack::Mime::MIME_TYPES.find {|k, v| v == matching_types.first }[0].sub(/\./,'').to_sym
+              accept_format = CONTENT_TYPE_ALIASES[type] || type
+            elsif catch_all && !types.include?(:any)
+              type = types.first
+              accept_format = CONTENT_TYPE_ALIASES[type] || type
+            end
+
+            matched_format = types.include?(:any) ||
+                             types.include?(accept_format) ||
+                             types.include?(url_format) ||
+                             ((!url_format) && request.accept.empty? && types.include?(:html))
+            # per rfc2616-sec14:
+            # answer with 406 if accept is given but types to not match any
+            # provided type
+            halt 406 if
+              (!url_format && !accepts.empty? && !matched_format) ||
+              (settings.respond_to?(:treat_format_as_accept) && settings.treat_format_as_accept && url_format && !matched_format)
+
+            if matched_format
+              @_content_type = url_format || accept_format || :html
+              content_type(@_content_type, :charset => 'utf-8')
+            end
+
+            matched_format
+          end
+        end
+    end
+  end
+end

data/lib/howl-router/padrino/ext/instance_methods.rb

@@ -0,0 +1,60 @@
+
+class Howl
+  module Padrino
+    module InstanceMethods
+      private
+        def route!(base = settings, pass_block = nil)
+          Thread.current['padrino.instance'] = self
+          code, headers, routes = base.compiled_router.call(@request.env)
+
+          status(code)
+          if code == 200
+            routes.each_with_index do |route_pair, index|
+              route = route_pair[0]
+              next if route.user_agent && !(route.user_agent =~ @request.user_agent)
+              original_params, parent_layout, successful = @params.dup, @layout, false
+
+              howl_params     = route_pair[1]
+              param_names     = route.matcher.names.dup
+              captured_params = howl_params[:captures].is_a?(Array) ? howl_params.delete(:captures) : howl_params.values_at(*param_names)
+
+              @route = request.route_obj = route
+              @params.merge!(howl_params) if howl_params.is_a?(Hash)
+              @params.merge!(:captures => captured_params) unless captured_params.empty?
+              @block_params = howl_params
+
+              filter! :before if index == 0
+
+              catch(:pass) do
+                begin
+                  (route.before_filters - settings.filters[:before]).each{|block| instance_eval(&block) }
+                  @layout = route.use_layout if route.use_layout
+                  route.custom_conditions.each {|block| pass if block.bind(self).call == false } unless route.custom_conditions.empty?
+                  halt_response = catch(:halt){ route_eval{ route.block[self, captured_params] }}
+                  successful    = true
+                  halt(halt_response)
+                ensure
+                   (route.after_filters - settings.filters[:after]).each {|block| instance_eval(&block) } if successful
+                   @layout, @params = parent_layout, original_params
+                end
+              end
+            end
+          else
+            route_eval do
+              headers.each{|k, v| response[k] = v } unless headers.empty?
+              route_missing if code == 404
+              route_missing if allow = response['Allow'] and allow.include?(request.env['REQUEST_METHOD'])
+            end
+          end
+
+          if base.superclass.respond_to?(:router)
+            route!(base.superclass, pass_block)
+            return
+          end
+
+          route_eval(&pass_block) if pass_block
+          route_missing
+        end
+    end
+  end
+end

data/lib/howl-router/padrino/matcher.rb

@@ -0,0 +1,8 @@
+require 'howl-router/matcher'
+
+class Howl
+  module Padrino
+    class Matcher < ::Howl::Matcher
+    end
+  end
+end

data/lib/howl-router/padrino/route.rb

@@ -0,0 +1,45 @@
+require 'howl-router/route'
+
+class Howl
+  module Padrino
+    class Route < ::Howl::Route
+      attr_accessor :action, :cache, :parent, :use_layout, :controller, :user_agent
+  
+      def before_filters(&block)
+        @_before_filters ||= []
+        @_before_filters << block if block_given?
+        @_before_filters
+      end
+  
+      def after_filters(&block)
+        @_after_filters ||= []
+        @_after_filters << block if block_given?
+        @_after_filters
+      end
+  
+      def custom_conditions(&block)
+        @_custom_conditions ||= []
+        @_custom_conditions << block if block_given?
+        @_custom_conditions
+      end
+  
+      def call(app, *args)
+        @block.call(app, *args)
+      end
+  
+      def request_methods
+        [verb.to_s.upcase]
+      end
+
+      def significant_variable_names
+        @significant_variable_names ||= if @path.is_a?(String)
+          @path.scan(/(^|[^\\])[:\*]([a-zA-Z0-9_]+)/).map{|p| p.last.to_sym}
+        elsif @path.is_a?(Regexp) and @path.respond_to?(:named_captures)
+          @path.named_captures.keys.map(&:to_sym)
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/howl-router/padrino/router.rb

@@ -0,0 +1,8 @@
+require 'howl-router/router'
+
+class Howl
+  module Padrino
+    class Router < ::Howl::Router
+    end
+  end
+end

data/lib/howl-router/request.rb

@@ -0,0 +1,7 @@
+require 'rack'
+
+class Howl
+  class Request < Rack::Request
+    attr_accessor :acceptable_methods
+  end
+end

data/lib/howl-router/route.rb

@@ -0,0 +1,40 @@
+class Howl
+  class Route
+    attr_accessor :block, :capture, :router, :params, :name,
+                  :order, :default_values, :path_for_generation, :verb
+
+    def initialize(path, options = {}, &block)
+      @path     = path
+      @params   = {}
+      @capture  = {}
+      @order    = 0
+      @block    = block if block_given?
+    end
+
+    def matcher
+      @matcher ||= Matcher.new(@path, :capture        => @capture,
+                                      :default_values => @default_values)
+    end
+
+    def arity
+      @block.arity
+    end
+
+    def call(*args)
+      @block.call(*args)
+    end
+
+    def to(&block)
+      @block = block if block_given?
+      @order = @router.current_order
+      @router.increment_order
+    end
+
+    def path(*args)
+      return @path if args.empty?
+      params = args[0]
+      params.delete(:captures)
+      matcher.expand(params) if matcher.mustermann?
+    end
+  end
+end

data/lib/howl-router/router.rb

@@ -0,0 +1,70 @@
+class Howl
+  class Router
+    attr_reader :current_order, :routes, :routes_with_verbs
+
+    def initialize
+      reset!
+    end
+
+    def recognize(request)
+      path_info, verb, request_params = request.is_a?(Hash) ? [request['PATH_INFO'], request['REQUEST_METHOD'], {}] :
+                                                              [request.path_info, request.request_method, request.params]
+      verb = verb.downcase.to_sym
+      ignore_slash_path_info = path_info
+      ignore_slash_path_info = path_info[0..-2] if path_info != "/" and path_info[-1] == "/"
+
+      # Convert hash key into symbol.
+      request_params = request_params.inject({}) do |result, entry|
+        result[entry[0].to_sym] = entry[1]
+        result
+      end
+
+      all_matched_routes = @routes.select do |route|
+        matcher = route.matcher
+        matcher.match(matcher.mustermann? ? ignore_slash_path_info : path_info)
+      end
+      raise NotFound if all_matched_routes.empty? 
+
+      raise_method_not_allowed(request, all_matched_routes) unless routes_with_verbs.has_key?(verb)
+      result = all_matched_routes.map{|route|
+        next unless verb == route.verb
+        params, matcher = {}, route.matcher
+        match_data = matcher.match(matcher.mustermann? ? ignore_slash_path_info : path_info)
+        if match_data.names.empty?
+          params[:captures] = match_data.captures
+        else
+          params.merge!(route.params).merge!(match_data.names.inject({}){|result, name|
+            result[name.to_sym] = match_data[name]
+            result
+          }).merge!(request_params){|key, self_value, new_value| self_value || new_value }
+        end
+        [route, params]
+      }.compact
+      raise_method_not_allowed(request, all_matched_routes) if result.empty?
+      result
+    end
+
+    def increment_order
+      @current_order += 1
+    end
+
+    def compile
+      return if @current_order.zero?
+      @routes_with_verbs.each_value{|routes_with_verb|
+        routes_with_verb.sort!{|a, b| a.order <=> b.order }
+      }
+      @routes.sort!{|a, b| a.order <=> b.order }
+    end
+
+    def reset!
+      @routes            = []
+      @routes_with_verbs = {}
+      @current_order     = 0
+    end
+
+    def raise_method_not_allowed(request, matched_routes)
+      request.acceptable_methods = matched_routes.map(&:verb)
+      raise MethodNotAllowed
+    end
+  end
+end

data/lib/howl-router/version.rb

@@ -0,0 +1,3 @@
+class Howl
+  VERSION = '0.1'
+end

data/test/helper.rb

@@ -0,0 +1,83 @@
+require 'bundler/setup'
+ENV['PADRINO_ENV'] = 'test'
+PADRINO_ROOT = File.dirname(__FILE__) unless defined?(PADRINO_ROOT)
+require File.expand_path('../../lib/howl-router', __FILE__)
+
+require 'minitest/unit'
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'mocha/setup'
+require 'padrino-core'
+require 'rack'
+require 'rack/test'
+
+begin
+  require 'ruby-debug'
+rescue LoadError; end
+
+class Sinatra::Base
+  include MiniTest::Assertions
+end
+
+class MiniTest::Spec
+  include Rack::Test::Methods
+
+  def howl
+    @app = Howl.new
+  end
+
+  def mock_app(base = nil, &block)
+    @app = Sinatra.new(base || ::Padrino::Application, &block)
+  end
+
+  def app
+    Rack::Lint.new(@app)
+  end
+
+  def method_missing(name, *args, &block)
+    if response && response.respond_to?(name)
+      response.send(name, *args, &block)
+    else
+      super(name, *args, &block)
+    end
+  rescue Rack::Test::Error # no response yet
+    super(name, *args, &block)
+  end
+  alias response last_response
+
+  class << self
+    alias :setup :before unless defined?(Rails)
+    alias :teardown :after unless defined?(Rails)
+    alias :should :it
+    alias :context :describe
+    def should_eventually(desc)
+      it("should eventually #{desc}") { skip("Should eventually #{desc}") }
+    end
+  end
+  alias :assert_no_match :refute_match
+  alias :assert_not_nil :refute_nil
+  alias :assert_not_equal :refute_equal
+end
+
+
+class ColoredIO
+  def initialize(io)
+    @io = io
+  end
+
+  def print(o)
+    case o
+    when "." then @io.send(:print, o.green)
+    when "E" then @io.send(:print, o.red)
+    when "F" then @io.send(:print, o.yellow)
+    when "S" then @io.send(:print, o.magenta)
+    else @io.send(:print, o)
+    end
+  end
+
+  def puts(*o)
+    super
+  end
+end
+
+MiniTest::Unit.output = ColoredIO.new($stdout)