pendragon 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 47c14505bf8ecd94fbdfff0f4bd88ef93ae869d6
+  data.tar.gz: db2b7552746a423ce69adf38a727d1fe3a963c0c
+SHA512:
+  metadata.gz: c65a69814973dec2ff98523b6a090ad7e552403e349789ce5af6e28014b4d98d3d45c36498f9836887e6e143884e6539f6f45dc71b6be5021776f06aba3b9337
+  data.tar.gz: 62145cf3f8f5e16c26cbc56412be3bb29da00562abc3e10413da142365e7fcfb3c3c463c4677acd0fb0c4d1e65f9caa15c4a3820c60990f57dde24219f61695f

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/Gemfile.lock

@@ -0,0 +1,64 @@
+PATH
+  remote: .
+  specs:
+    pendragon (0.3.0)
+      mustermann (= 0.2.0)
+      rack (>= 1.3.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (4.0.2)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    atomic (1.1.14)
+    haml (4.0.5)
+      tilt
+    http_router (0.11.0)
+      rack (>= 1.0.0)
+      url_mount (~> 0.2.1)
+    i18n (0.6.9)
+    metaclass (0.0.2)
+    minitest (4.7.5)
+    mocha (1.0.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.8.4)
+    mustermann (0.2.0)
+    padrino-core (0.12.0.rc3)
+      activesupport (>= 3.1)
+      http_router (~> 0.11.0)
+      rack-protection (>= 1.5.0)
+      sinatra (~> 1.4.2)
+      thor (~> 0.17.0)
+      tilt (~> 1.4.1)
+    rack (1.5.2)
+    rack-protection (1.5.2)
+      rack
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rake (10.1.1)
+    sinatra (1.4.4)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    thor (0.17.0)
+    thread_safe (0.1.3)
+      atomic
+    tilt (1.4.1)
+    tzinfo (0.3.38)
+    url_mount (0.2.1)
+      rack
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  haml
+  mocha (>= 0.10.0)
+  padrino-core (= 0.12.0.rc3)
+  pendragon!
+  rack-test (>= 0.5.0)
+  rake (>= 0.8.7)

data/README.md

@@ -0,0 +1,159 @@
+# Pendragon
+
+[![Build Status](https://travis-ci.org/namusyaka/pendragon.png)](https://travis-ci.org/namusyaka/pendragon)
+
+Provides an HTTP router for use in Rack and Padrino.
+
+Pendragon works only in Ruby2.0.
+
+If you want to use in Ruby1.9, you can do it by using [mustermann/1.9-support branch](https://github.com/rkh/mustermann/tree/1.9-support).
+
+## Installation
+
+add this line to your Gemfile.
+
+`gem 'pendragon'`
+
+or
+
+`$ gem install pendragon`
+
+## Configuration
+
+If you enable compiler, performance will be improved at the expense of some features as below.
+
+* Route priority will not work (Might support in the future).
+* Duplicated routes will not work correctly.
+* MethodNotAllowed will not work.
+
+This implementation was inspired by [rack-multiplexer](https://github.com/r7kamura/rack-multiplexer).
+
+```ruby
+Pendragon.configure do |config|
+  config.enable_compiler = true # default value is false
+end
+```
+
+## Example
+
+Write this code to your config.ru.
+
+```ruby
+require 'pendragon'
+
+pendragon = Pendragon.new
+pendragon.add(:get, "/") do
+  "get"
+end
+
+pendragon.get("/hey") do
+  "hey"
+end
+
+pendragon.post("/hey") do
+  "hey, postman!"
+end
+
+
+pendragon.get("/users/:user_id") do |params|
+  params.inspect
+end
+
+run pendragon
+```
+
+## Normal path
+
+### Base
+
+```ruby
+pendragon = Pendragon.new
+
+pendragon.add(:get, "/") do
+  "hello"
+end
+```
+
+### Regexp
+
+```ruby
+pendragon = Pendragon.new
+
+pendragon.add(:get, /(\d+)/) do
+  "hello"
+end
+```
+
+### Params
+
+```ruby
+pendragon = Pendragon.new
+
+pendragon.add(:get, "/users/:name") do |params|
+  "hello #{params[:name]}"
+end
+
+pendragon.add(:get, /\/page\/(.+?)/) do |params|
+  "show #{params[:captures]}"
+end
+```
+
+### Captures
+
+```ruby
+pendragon = Pendragon.new
+
+users = pendragon.add(:get, "/users/:name") do |params|
+  "hello #{params[:name]}"
+end
+users.captures[:name] = /\d+/
+```
+
+### Name and Path
+
+```ruby
+pendragon = Pendragon.new
+
+users = pendragon.add(:get, "/users/:name") do |params|
+  "hello #{params[:name]}"
+end
+users.name = :users
+
+pendragon.path(:users, :name => "howl") #=> "/users/howl"
+```
+
+## with Padrino
+
+If you use Pendragon, your application does not use http_router.
+
+```ruby
+require 'pendragon/padrino'
+
+class App < Padrino::Application
+  register Pendragon::Padrino
+
+  get :index do
+    "hello pendragon!"
+  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,19 @@
+require 'rake'
+require 'rake/testtask'
+require 'pendragon'
+
+Rake::TestTask.new(:test_without_compiler) do |test|
+  test.libs << 'test'
+  test.test_files = Dir['test/**/*_test.rb']
+  test.verbose = true
+end
+
+Rake::TestTask.new(:test_with_compiler) do |test|
+  test.libs << 'test'
+  test.ruby_opts = ["-r compile_helper.rb"]
+  test.test_files = Dir['test/**/*_test.rb']
+  test.verbose = true
+end
+
+task :test => [:test_without_compiler, :test_with_compiler]
+task :default => :test

data/config.ru

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

data/lib/pendragon.rb

@@ -0,0 +1,36 @@
+require 'pendragon/router'
+
+module Pendragon
+
+  # Allow the verbs of these.
+  HTTP_VERBS = [:get, :post, :delete, :put, :head]
+
+  class << self
+    # A new instance of Pendragon::Router
+    # @see Pendragon::Router#initialize
+    def new(&block)
+      Router.new(&block)
+    end
+  
+    # Yields Pendragon configuration block
+    # @example
+    #   Pendragon.configure do |config|
+    #     config.enable_compiler = true
+    #   end
+    # @see Pendragon::Configuration
+    def configure(&block)
+      block.call(configuration) if block_given?
+      configuration
+    end
+  
+    # Returns Pendragon configuration
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Resets Pendragon configuration
+    def reset_configuration!
+      @configuration = nil
+    end
+  end
+end

data/lib/pendragon/compile_helpers.rb

@@ -0,0 +1,41 @@
+
+module Pendragon
+  module CompileHelpers
+    def compile!
+      @compiled_regexps = Pendragon::HTTP_VERBS.inject({}){|all, verb| all[verb] = []; all }
+      @routes.each_with_index do |route, index|
+        regexp = route.matcher.handler
+        regexp = regexp.to_regexp if route.matcher.mustermann?
+        @compiled_regexps[route.verb] << /(?<_#{index}>#{regexp})/
+        route.index = "_#{index}"
+      end
+      @compiled_regexps.each_pair{|verb, regexps| @compiled_regexps[verb] = /\A#{Regexp.union(regexps)}\Z/ }
+    end
+
+    def compiled?
+      !!@compiled_regexps
+    end
+
+    def recognize_by_compiling_regexp(request)
+      path_info, verb, request_params = parse_request(request)
+
+      unless @compiled_regexps[verb] === path_info
+        old_path_info = path_info
+        path_info = path_info[0..-2] if path_info != "/" and path_info[-1] == "/"
+        raise NotFound if old_path_info == path_info || !(@compiled_regexps[verb] === path_info)
+      end
+
+      route = @routes.select{|route| route.verb == verb }.detect{|route| Regexp.last_match(route.index) }
+      params, match_data = {}, route.match(path_info)
+      if match_data.names.empty?
+        params[:captures] = match_data.captures
+      else
+        params.merge!(match_data.names.inject({}){|result, name|
+          result[name.to_sym] = match_data[name] ? Rack::Utils.unescape(match_data[name]) : nil
+          result
+        }).merge!(request_params){|key, self_val, new_val| self_val || new_val }
+      end
+      [[route, params]]
+    end
+  end
+end

data/lib/pendragon/configuration.rb

@@ -0,0 +1,25 @@
+module Pendragon
+  class Configuration
+
+    # Enables to compile the routes
+    # Improve the performance by using this option,
+    # but some features will not work correctly.
+    # @see Pendragon::Router#compile
+    attr_accessor :enable_compiler
+
+    # Constructs an instance of Pendragon::Configuration
+    def initialize
+      @enable_compiler = false
+    end
+
+    # Returns an instance variable
+    def [](variable_name)
+      instance_variable_get("@#{variable_name}")
+    end
+
+    # Returns a boolean of @enable_compiler
+    def enable_compiler?
+      !!@enable_compiler
+    end
+  end
+end

data/lib/pendragon/error_handler.rb

@@ -0,0 +1,43 @@
+module Pendragon
+  class ErrorHandler < StandardError
+    def call
+      response = []
+      response << (settings[:status] || default_response[0])
+      response << (settings[:headers] || default_response[1])
+      response << Array(settings[:body] || default_response[2])
+    end
+
+    def settings
+      self.class.settings
+    end
+
+    class << self
+      def set(key, value)
+        settings[key] = value
+      end
+
+      def settings
+        @settings ||= {}
+      end
+    end
+
+    private
+
+    def default_response
+      @default_response ||= [404, {'Content-Type' => 'text/html'}, ["Not Found"]]
+    end
+  end
+
+  NotFound = Class.new(ErrorHandler)
+  InvalidRouteException = Class.new(ArgumentError)
+
+  class MethodNotAllowed < ErrorHandler
+    set :status, 405
+    set :body,   "Method Not Allowed"
+  end
+
+  class BadRequest < ErrorHandler
+    set :status, 400
+    set :body,   "Bad Request"
+  end
+end

data/lib/pendragon/matcher.rb

@@ -0,0 +1,78 @@
+require 'mustermann'
+
+module Pendragon
+  class Matcher
+    # @param [String] path The path is string or regexp.
+    # @option options [Hash] :capture Set capture for path pattern.
+    # @option options [Hash] :default_values Set default_values for path pattern.
+    #
+    # @return [Pendragon::Matcher]
+    #
+    def initialize(path, options = {})
+      @path = path.is_a?(String) && path.empty? ? "/" : path
+      @capture = options.delete(:capture)
+      @default_values = options.delete(:default_values)
+    end
+
+    # Do the matching.
+    #
+    # @param [String] pattern The pattern is actual path (path_info etc).
+    #
+    # @return [MatchData] If the pattern matched this route, return a MatchData.
+    # @return [Nil] If the pattern doesn't matched this route, return a nil.
+    #
+    def match(pattern)
+      pattern = pattern[0..-2] if mustermann? and pattern != "/" and pattern[-1] == "/"
+      handler.match(pattern)
+    end
+
+    # Expands the path with params.
+    #
+    # @param [Hash] params The params for path pattern.
+    #
+    # @example
+    # matcher = Pendragon::Matcher.new("/foo/:bar")
+    # matcher.expand(:bar => 123) #=> "/foo/123"
+    # matcher.expand(:bar => "bar", :baz => "test") #=> "/foo/bar?baz=test"
+    #
+    # @return [String] A expaneded path.
+    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
+
+    # @return [Boolean] This matcher's handler is mustermann ?
+    def mustermann?
+      handler.instance_of?(Mustermann::Sinatra)
+    end
+
+    # @return [Mustermann::Sinatra] Returns a Mustermann::Sinatra when @path is string.
+    # @return [Regexp] Returns a regexp when @path is regexp.
+    def handler
+      @handler ||=
+        case @path
+        when String
+          Mustermann.new(@path, :capture => @capture)
+        when Regexp
+          /^(?:#{@path})$/
+        end
+    end
+
+    # @return [String] Returns a converted handler.
+    def to_s
+      handler.to_s
+    end
+
+    # @return [Array] Returns a named captures.
+    def names
+      handler.names.map(&:to_sym)
+    end
+  end
+end