howl-router 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 81ee1a9fd3fb9b42514e112a63ae5d0da2531553
+  data.tar.gz: 18f0e9a58f174d209feb7857d77918067059b7ff
+SHA512:
+  metadata.gz: 23a2afffa48fabc92fa977bf01de758575dd5bd8bed88345cf6d9c92e12e43584143330262a5afeff6e9a6709718e17c1502c14c2ce6f2467e03e75699c10f23
+  data.tar.gz: a08e7b11b6a41c65fd66e8635662aac4c62fcf7c78580ea45cf9d5305088f8c7eb7515d8a1203f3a06bd6fd0f36a32e765651e8692a01a5e7dc50f9baacb76cb

data/.travis.yml

@@ -0,0 +1,13 @@
+lang: ruby
+before_install: gem install bundler --pre
+install:
+  - gem update --system
+  - bundle update
+rvm:
+  - 2.0.0
+notifications:
+  recipients:
+    - namusyaka@gmail.com
+branches:
+  only:
+    - master

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,132 @@
+# Howl Router
+
+[![Build Status](https://travis-ci.org/namusyaka/howl-router.png)](https://travis-ci.org/namusyaka/howl-router)
+
+A http router for Rack and Padrino.
+
+Howl works only in Ruby2.0.
+
+## Installation
+
+`git clone git@github.com:namusyaka/howl-router.git`
+
+`cd howl-router; bundle install`
+
+## Example
+
+Write this code to your config.ru.
+
+```ruby
+require 'howl-router'
+
+howl = Howl.new
+howl.add(:get, "/") do
+  "get"
+end
+
+howl.add(:post, "/") do
+  "post"
+end
+
+howl.add(:get, "/users/:user_id") do |params|
+  params.inspect
+end
+
+run howl
+```
+
+## Normal path
+
+### Base
+
+```ruby
+howl = Howl.new
+
+howl.add(:get, "/") do
+  "hello"
+end
+```
+
+### Regexp
+
+```ruby
+howl = Howl.new
+
+howl.add(:get, /(\d+)/) do
+  "hello"
+end
+```
+
+### Params
+
+```ruby
+howl = Howl.new
+
+howl.add(:get, "/users/:name") do |params|
+  "hello #{params[:name]}"
+end
+
+howl.add(:get, /\/page\/(.+?)/) do |params|
+  "show #{params[:captures]}"
+end
+```
+
+### Captures
+
+```ruby
+howl = Howl.new
+
+users = howl.add(:get, "/users/:name") do |params|
+  "hello #{params[:name]}"
+end
+users.captures[:name] = /\d+/
+```
+
+### Name and Path
+
+```ruby
+howl = Howl.new
+
+users = howl.add(:get, "/users/:name") do |params|
+  "hello #{params[:name]}"
+end
+users.name = :users
+
+howl.path(:users, :name => "howl") #=> "/users/howl"
+```
+
+## with Padrino
+
+If you use Howl, your application does not use http_router. 
+
+```ruby
+require 'howl-router/padrino'
+
+class App < Padrino::Application
+  register Howl::Padrino
+
+  get :index do
+    "hello howl!"
+  end
+
+  get :users, :map => "/users/:user_id/", :user_id => /\d+/ do |user_id|
+    params.inspect
+  end
+
+  get :user_items, :map => "/users/:user_id/:item_id", :user_id => /\d+/, :item_id => /[1-9]+/ do |user_id, item_id|
+    "Show #{user_id} and #{item_id}"
+  end
+end
+```
+
+## Contributing
+
+1. fork the project.
+2. create your feature branch. (`git checkout -b my-feature`)
+3. commit your changes. (`git commit -am 'commit message'`)
+4. push to the branch. (`git push origin my-feature`)
+5. send pull request.
+
+## License
+
+the MIT License

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = Dir['test/**/*_test.rb']
+  test.verbose = true
+end
+
+task :default => :test

data/config.ru

@@ -0,0 +1,9 @@
+load  File.expand_path('../lib/howl.rb', __FILE__)
+
+howl = Howl.new
+
+howl.add(:get, "/") do
+  "hello world !"
+end
+
+run howl

data/lib/howl-router.rb

@@ -0,0 +1,163 @@
+require 'rack'
+require 'howl-router/route'
+require 'howl-router/router'
+require 'howl-router/matcher'
+require 'howl-router/request'
+
+class Howl
+  class InvalidRouteException < ArgumentError
+  end
+
+  HTTP_VERBS       = [:get, :post, :delete, :put, :head]
+  RESPONSE_HEADERS = {
+    :bad_request        => 400,
+    :not_found          => 404,
+    :method_not_allowed => 405,
+    :server_error       => 500
+  }
+
+  # Generate a route, and add to routes.
+  #
+  # @param [String, Symbol] verb The verb decide a acceptable request method.
+  # @param [String] path The path associate to route.
+  # @option options [String] :path_for_generation Accept path_for_generation.
+  # @yield The block assosiate to route.
+  #
+  # @example
+  #   howl = Howl.new
+  #   howl.add(:get, "/") #=> Howl::Route
+  #
+  # @return [Howl::Route] Return a generated Howl::Route instance.
+  #
+  def add(verb, path, options = {}, &block)
+    verb = verb.downcase.to_sym
+    (router.routes_with_verbs[verb] ||= []) << (route = Route.new(path, &block))
+    route.path_for_generation = options[:path_for_generation] if options[:path_for_generation]
+    route.verb = verb
+    route.router = router
+    router.routes << route
+    route
+  end
+
+  # call method for Rack Application.
+  def call(env)
+    request  = Request.new(env)
+    return bad_request unless HTTP_VERBS.include?(request.request_method.downcase.to_sym)
+    compile unless compiled?
+    begin
+      matched_routes = recognize(request)
+      route, params = matched_routes.first
+      result = route.arity != 0 ? route.call(params) : route.call
+      [200, {'Content-Type' => 'text/html;charset=utf-8;'}, [result]]
+    rescue => evar
+      case evar
+      when NotFound then not_found
+      when MethodNotAllowed then method_not_allowed
+      else server_error
+      end
+    end
+  end
+
+  # Determines whether the compiled.
+  #
+  # @return [Bool]
+  def compiled?
+    @compiled
+  end
+
+  # Compile routes.
+  #
+  # @return [Array] Return a compiled routes.
+  def compile
+    @compiled = true
+    router.compile
+  end
+
+  # Recognize a request, and return a matched routes.
+  #
+  # @param [Rack::Request] request The request is a Rack::Request or instance that inherited it.
+  #
+  # @return [Array] Return a routes that match the path_info.
+  def recognize(request)
+    router.recognize(request)
+  end
+
+  # Recognize a path_info, and return a matched first route's name and params.
+  #
+  # @param [String] path_info
+  #
+  # @return [Array] Return a Array that likes [name, params].
+  def recognize_path(path_info)
+    response      = router.recognize(Rack::MockRequest.env_for(path_info))
+    route, params = response.first
+    [route.name, params]
+  end
+
+  # Reset a router.
+  def reset!
+    @compiled = nil
+    router.reset!
+  end
+
+  # Return a Router instance.
+  #
+  # @return [Howl::Router]
+  def router
+    @router ||= Router.new
+  end
+
+  # Return a added routes.
+  #
+  # @return [Array]
+  def routes
+    router.routes
+  end
+
+  # Find a route, and return a generated path of route.
+  #
+  # @param [Symbol] name The name is route name.
+  # @param [Array] args The args are route params and queries.
+  #
+  # @example
+  #
+  #   howl = Howl.new
+  #   index = howl.add(:get, "/:id"){}
+  #   index.name = :index
+  #   howl.path(:index, :id => 1) #=> "/1"
+  #   howl.path(:index, :id => 2, :foo => "bar") #=> "/1?foo=bar"
+  #
+  # @return [String] return a generated path.
+  #
+  def path(name, *args)
+    params = args.delete_at(args.last.is_a?(Hash) ? -1 : 0) || {}
+    saved_args = args.dup
+    router.routes.each do |route|
+      next unless route.name == name
+      matcher = route.matcher
+      if !args.empty? and matcher.mustermann?
+        matcher_names = matcher.names
+        params_for_expand = Hash[matcher_names.map{|matcher_name|
+          [matcher_name.to_sym, (params[matcher_name.to_sym] || args.shift)]
+        }]
+        params_for_expand.merge!(Hash[params.select{|k, v| !matcher_names.include?(name.to_sym) }])
+        args = saved_args.dup
+      else
+        params_for_expand = params.dup
+      end
+      return matcher.mustermann? ? matcher.expand(params_for_expand) : route.path_for_generation
+    end
+    raise InvalidRouteException
+  end
+
+  RESPONSE_HEADERS.keys.each do |method_name|
+    define_method(method_name){|headers = {}| generate_response(method_name.to_sym, headers) }
+    Object.const_set(method_name.to_s.split('_').map(&:capitalize).join, Class.new(StandardError))
+  end
+
+  private
+
+  def generate_response(key, headers = {})
+    headers['Content-Type'] = 'text/html;charset=utf-8;' if headers.empty?
+    [RESPONSE_HEADERS[key], headers, [key.to_s.split('_').map(&:capitalize).join(" ")]]
+  end
+end

data/lib/howl-router/matcher.rb

@@ -0,0 +1,46 @@
+require 'mustermann'
+
+class Howl
+  class Matcher
+    def initialize(path, options = {})
+      @path           = path.is_a?(String) && path.empty? ? "/" : path
+      @capture        = options.delete(:capture)
+      @default_values = options.delete(:default_values)
+    end
+
+    def match(pattern)
+      handler.match(pattern)
+    end
+
+    def expand(params)
+      params = params.dup
+      query = params.keys.inject({}) do |result, key|
+        result[key] = params.delete(key) if !handler.names.include?(key.to_s)
+        result
+      end
+      params.merge!(@default_values) if @default_values.is_a?(Hash)
+      expanded_path = handler.expand(params)
+      expanded_path = expanded_path + "?" + query.map{|k,v| "#{k}=#{v}" }.join("&") unless query.empty?
+      expanded_path
+    end
+
+    def mustermann?
+      handler.class == Mustermann::Rails
+    end
+
+    def handler
+      @handler ||= case @path
+                   when String then Mustermann.new(@path, :type => :rails, :capture => @capture)
+                   when Regexp then /^(?:#{@path})$/
+                   end
+    end
+
+    def to_s
+      handler.to_s
+    end
+
+    def names
+      mustermann? ? handler.names.map(&:to_sym) : []
+    end
+  end
+end

data/lib/howl-router/padrino.rb

@@ -0,0 +1,17 @@
+require 'howl-router/padrino/core'
+require 'howl-router/padrino/route'
+require 'howl-router/padrino/router'
+require 'howl-router/padrino/matcher'
+require 'howl-router/padrino/ext/instance_methods'
+require 'howl-router/padrino/ext/class_methods'
+
+class Howl
+  module Padrino
+    class << self
+      def registered(app)
+        app.extend(ClassMethods)
+        app.send(:include, InstanceMethods)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+require 'howl-router' unless defined?(Howl)
+
+class Howl
+  module Padrino
+    class Core < ::Howl
+      def add(verb, path, options = {}, &block)
+        verb = verb.downcase.to_sym
+        (router.routes_with_verbs[verb] ||= []) << (route = Route.new(path, &block))
+        route.path_for_generation = options[:path_for_generation] if options[:path_for_generation]
+        route.verb = verb
+        route.router = router
+        router.routes << route
+        route
+      end
+
+      def call(env)
+        request  = Request.new(env)
+        return bad_request unless HTTP_VERBS.include?(request.request_method.downcase.to_sym)
+
+        compile unless compiled?
+
+        begin
+          matched_routes = recognize(request)
+          [200, {}, matched_routes]
+        rescue => evar
+          case evar
+          when NotFound then not_found
+          when MethodNotAllowed then method_not_allowed('Allow' => request.acceptable_methods.sort.join(", "))
+          else server_error
+          end
+        end
+      end
+
+      private
+
+      def generate_response(key, headers = {})
+        [RESPONSE_HEADERS[key], headers, [key.to_s.split('_').map(&:capitalize) * " "]]
+      end
+    end
+  end
+end