pendragon 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 96b558eec1e2524045fcd153be5bca8bb159ffdd
-  data.tar.gz: b2411809a3ccb47d6d9a46c162c9611b9bddffbf
+  metadata.gz: 50f2cc54ef1c804fa05b8de3a47d6bf731e86f8f
+  data.tar.gz: 90c08c4129ae507b429d35487ff7824a37ad424e
 SHA512:
-  metadata.gz: 7152a62fffeb920032d0ee6699183c662e18aa138567e638506fd8d6158d53aa47884b9b971c3ceadaa693380204c5b9f8c3d037891be37cdf01c5a4801f47bb
-  data.tar.gz: 8a7dcf1502c0b4b9febec24efd7f96aff8f0f644d492a44f0883cd7b0da562014ccf6c089f07d5f351c67b98dc4cb1267d9f96c37d672801a66ce5df5f9c7158
+  metadata.gz: cf8e88346a526a08c48e63db31f861d4b401754bcaea842e0ac0ce6446e241a0cf51b87d2c61ff6f1dcbf29c4e10d975a078fa31f9413881b578c60845a53a41
+  data.tar.gz: 070bc4ce928f628ba6f22260e42f05087ee96caccba81c0084a3ccf5fe7491cfa94aebaf7f695a539ef26c9a86944313e0674dd23c9240e255fa23b05bc5e922

data/Gemfile.lock

@@ -1,14 +1,14 @@
 PATH
   remote: .
   specs:
-    pendragon (0.4.0)
+    pendragon (0.5.1)
       mustermann (= 0.2.0)
       rack (>= 1.3.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (4.1.1)
+    activesupport (4.1.4)
       i18n (~> 0.6, >= 0.6.9)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
@@ -19,20 +19,53 @@ GEM
     http_router (0.11.1)
       rack (>= 1.0.0)
       url_mount (~> 0.2.1)
-    i18n (0.6.9)
+    i18n (0.6.11)
     json (1.8.1)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
     metaclass (0.0.4)
-    minitest (5.3.4)
+    mime-types (1.25.1)
+    minitest (5.4.0)
     mocha (1.1.0)
       metaclass (~> 0.0.1)
+    moneta (0.7.20)
     mustermann (0.2.0)
-    padrino-core (0.12.0.rc3)
+    padrino (0.12.2)
+      padrino-admin (= 0.12.2)
+      padrino-cache (= 0.12.2)
+      padrino-core (= 0.12.2)
+      padrino-gen (= 0.12.2)
+      padrino-helpers (= 0.12.2)
+      padrino-mailer (= 0.12.2)
+      padrino-support (= 0.12.2)
+    padrino-admin (0.12.2)
+      padrino-core (= 0.12.2)
+      padrino-helpers (= 0.12.2)
+    padrino-cache (0.12.2)
+      moneta (~> 0.7.0)
+      padrino-core (= 0.12.2)
+      padrino-helpers (= 0.12.2)
+    padrino-core (0.12.2)
       activesupport (>= 3.1)
       http_router (~> 0.11.0)
+      padrino-support (= 0.12.2)
       rack-protection (>= 1.5.0)
       sinatra (~> 1.4.2)
-      thor (~> 0.17.0)
+      thor (~> 0.18.0)
+    padrino-gen (0.12.2)
+      bundler (~> 1.0)
+      padrino-core (= 0.12.2)
+    padrino-helpers (0.12.2)
+      i18n (~> 0.6, >= 0.6.7)
+      padrino-support (= 0.12.2)
       tilt (~> 1.4.1)
+    padrino-mailer (0.12.2)
+      mail (~> 2.5.3)
+      padrino-core (= 0.12.2)
+    padrino-support (0.12.2)
+      activesupport (>= 3.1)
+    polyglot (0.3.5)
     rack (1.5.2)
     rack-protection (1.5.3)
       rack
@@ -43,10 +76,13 @@ GEM
       rack (~> 1.4)
       rack-protection (~> 1.4)
       tilt (~> 1.3, >= 1.3.4)
-    thor (0.17.0)
-    thread_safe (0.3.3)
+    thor (0.18.1)
+    thread_safe (0.3.4)
     tilt (1.4.1)
-    tzinfo (1.1.0)
+    treetop (1.4.15)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (1.2.1)
       thread_safe (~> 0.1)
     url_mount (0.2.1)
       rack
@@ -57,7 +93,7 @@ PLATFORMS
 DEPENDENCIES
   haml
   mocha (>= 0.10.0)
-  padrino-core (= 0.12.0.rc3)
+  padrino (~> 0.12.2)
   pendragon!
   rack-test (>= 0.5.0)
   rake (>= 0.8.7)

data/README.md

@@ -73,7 +73,7 @@ pendragon = Pendragon.new do |config|
 end
 ```
 
-### Register the route
+### Register a route
 
 It has some methods to register a route. For example, `#get`, `#post` and `#delete` are so.
 This section introduces all those methods.

data/lib/pendragon/configuration.rb

@@ -1,7 +1,10 @@
 module Pendragon
+  # A class for configuration of Pendragon
+  # @!visibility private
   class Configuration
-
-    # Define the accessor as boolean method
+    # Defines an accessor as boolean method
+    # @example
+    #   attr_boolean_accessor :accessor_name
     def self.attr_boolean_accessor(*keys)
       keys.each do |key|
         attr_accessor key
@@ -15,8 +18,9 @@ module Pendragon
     # @see Pendragon::Router#compile
     attr_boolean_accessor :enable_compiler
 
-    # Automatically convert response into Rack format.
+    # Automatically converts response into Rack format.
     # Default value is `true`.
+    # @see Pendragon::Router#invoke
     attr_boolean_accessor :auto_rack_format
 
     # Constructs an instance of Pendragon::Configuration

data/lib/pendragon/engine/compiler.rb

@@ -1,11 +1,23 @@
 require 'pendragon/engine/recognizer'
 
 module Pendragon
+  # One of the engine classes for recognizing routes
+  # This engine will perform better than the recognizer engine
+  #
+  # @example
+  #   Pendragon.new do |config|
+  #     config.enable_compiler = true
+  #   end
+  #
+  # @!visibility private
   class Compiler < Recognizer
-    def initialize(routes)
-      @routes = routes
-    end
-
+    # Concatenates all routes, recognizes routes matched with pattern, and returns them
+    # @overload call
+    #   @param [Rack::Request] request
+    #   @raise [Pendragon::BadRequest] raised if request is bad request
+    #   @raise [Pendragon::NotFound] raised if cannot find routes that match with pattern
+    #   @raise [Pendragon::MethodNotAllowed] raised if routes can be find and do not match with verb
+    #   @return [Array] The return value will be something like [Pendragon::Route, Hash]
     def call(request)
       compile! unless compiled?
       pattern, verb, params = parse_request(request)
@@ -17,8 +29,7 @@ module Pendragon
       candidacies.map{|route| [route, params_for(route, pattern, params)]}
     end
 
-    private
-
+    # @!visibility private
     def compile!
       return if compiled?
       @regexps = @routes.map.with_index do |route, index|
@@ -30,6 +41,7 @@ module Pendragon
       @regexps = compile(@regexps)
     end
 
+    # @!visibility private
     def compile(regexps, paths = [])
       return paths if regexps.length.zero?
       paths << Regexp.union(regexps)
@@ -37,14 +49,16 @@ module Pendragon
       compile(regexps, paths)
     end
 
+    # @!visibility private
     def compiled?
       !!@regexps
     end
 
+    # @!visibility private
     def match_with(pattern)
       offset = 0
       conditions = [pattern]
-      conditions << pattern[0..-2] if pattern != "/" && pattern.end_with?("/")
+      conditions << pattern[0..-2] if pattern != Matcher::PATH_DELIMITER && pattern.end_with?(Matcher::PATH_DELIMITER)
       loop.with_object([]) do |_, candidacies|
         return candidacies unless conditions.any?{|x| @regexps[offset] === x }
         route = @routes[offset..-1].detect{|route| Regexp.last_match("_#{route.index}") }
@@ -52,5 +66,7 @@ module Pendragon
         offset = route.index + 1
       end
     end
+
+    private :compile!, :compile, :compiled?, :match_with
   end
 end

data/lib/pendragon/engine/recognizer.rb

@@ -1,17 +1,29 @@
 module Pendragon
+  # One of the engine classes for recognizing routes
+  # @!visibility private
   class Recognizer
+    # The keys for rack headers
+    PATH_INFO      = "PATH_INFO".freeze
+    REQUEST_METHOD = "REQUEST_METHOD".freeze
+
+    # Constructs an instance of Pendragon::Recognizer
+    # @param [Array<Pendragon::Route>] routes
     def initialize(routes)
       @routes = routes
     end
 
+    # Recognized routes, and returns them
+    # @param [Rack::Request] request
+    # @raise [Pendragon::BadRequest] raised if request is bad request
+    # @raise [Pendragon::NotFound] raised if cannot find routes that match with pattern
+    # @raise [Pendragon::MethodNotAllowed] raised if routes can be find and do not match with verb
+    # @return [Array] The return value will be something like [Pendragon::Route, Hash]
     def call(request)
       pattern, verb, params = parse_request(request)
       raise_exception(400) unless valid_verb?(verb)
       fetch(pattern, verb){|route| [route, params_for(route, pattern, params)] }
     end
 
-    private
-
     # @!visibility private
     def params_for(route, pattern, params)
       route.params(pattern, params)
@@ -19,7 +31,7 @@ module Pendragon
 
     # @!visibility private
     def valid_verb?(verb)
-      Pendragon::HTTP_VERBS.include?(verb.downcase.to_sym)
+      Pendragon::HTTP_VERBS.include?(verb)
     end
 
     # @!visibility private
@@ -34,17 +46,9 @@ module Pendragon
     # @!visibility private
     def parse_request(request)
       if request.is_a?(Hash)
-        [request['PATH_INFO'], request['REQUEST_METHOD'].downcase.to_sym, {}]
+        [request[PATH_INFO], request[REQUEST_METHOD].upcase, {}]
       else
-        [request.path_info, request.request_method.downcase.to_sym, parse_request_params(request.params)]
-      end
-    end
-
-    # @!visibility private
-    def parse_request_params(params)
-      params.inject({}) do |result, entry|
-        result[entry[0].to_sym] = entry[1]
-        result
+        [request.path_info, request.request_method.upcase, request.params]
       end
     end
 
@@ -61,5 +65,7 @@ module Pendragon
         end
       }.(error_code)
     end
+
+    private :params_for, :valid_verb?, :fetch, :parse_request, :raise_exception
   end
 end

data/lib/pendragon/error.rb

@@ -0,0 +1,71 @@
+module Pendragon
+  # Raises the exception if routes that matches the condition do not exist
+  InvalidRouteException = Class.new(ArgumentError)
+
+  # A base class for error responses
+  # ResponseError#status and ResponseError#body must be implemented by subclass
+  class ResponseError < StandardError
+    def initialize(*args)
+      @args = args
+    end
+
+    def call
+      [status, headers, Array(body)]
+    end
+
+    def status
+      raise NotImplementedError, "`status` must be implemented by subclass"
+    end
+
+    def body
+      raise NotImplementedError, "`body` must be implemented by subclass"
+    end
+
+    def headers
+      @headers ||= { "Content-Type" => "text/plain" }
+    end
+  end
+
+  # A class for BadRequest response
+  class BadRequest < ResponseError
+    def status
+      @status ||= 400
+    end
+
+    def body
+      @body ||= "Bad Request"
+    end
+  end
+
+  # A class for NotFound response
+  class NotFound < ResponseError
+    def status
+      @status ||= 404
+    end
+
+    def body
+      @body ||= "Not Found"
+    end
+  end
+
+  # A class for MethodNotAllowed response
+  class MethodNotAllowed < ResponseError
+    ALLOW = "Allow".freeze
+    COMMA = ", ".freeze
+
+    def status
+      @status ||= 405
+    end
+
+    def body
+      @body ||= "Method Not Allowed"
+    end
+
+    def headers
+      @headers ||= begin
+        super_headers = super
+        super_headers.merge!(ALLOW => @args.shift.map{|verb| verb.upcase } * COMMA)
+      end
+    end
+  end
+end

data/lib/pendragon/matcher.rb

@@ -1,40 +1,49 @@
 require 'mustermann/sinatra'
 
 module Pendragon
+  # A class for path matching
+  #
+  # @example
+  #   matcher = Pendragon::Matcher.new("/category/:id", capture: {id: /\d+/})
+  #   matcher.match("/category/1234") #=> #<MatchData "/category/1234" id:"1234">
+  #
+  # @!visibility private
   class Matcher
+    # A character of path delimiter
+    PATH_DELIMITER  = "/".freeze
+
+    # A prefix character of query string
+    QUERY_PREFIX    = "?".freeze
+
+    # A character of query string delimiter
+    QUERY_DELIMITER = "&".freeze
+
+    # Constructs a new instance of Pendragon::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
+      @path = path.is_a?(String) && path.empty? ? PATH_DELIMITER : path
       @capture = options.delete(:capture)
       @default_values = options.delete(:default_values)
     end
 
-    # Do the matching.
-    #
+    # Does 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.end_with?("/")
+      pattern = pattern[0..-2] if mustermann? and pattern != PATH_DELIMITER and pattern.end_with?(PATH_DELIMITER)
       handler.match(pattern)
     end
 
-    # Expands the path with params.
-    #
+    # Expands a 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"
-    #
+    #   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
@@ -44,15 +53,17 @@ module Pendragon
       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 = expanded_path + QUERY_PREFIX + query.map{|k,v| "#{k}=#{v}" }.join(QUERY_DELIMITER) unless query.empty?
       expanded_path
     end
 
+    # Returns whether the handler is Mustermann
     # @return [Boolean] This matcher's handler is mustermann ?
     def mustermann?
       handler.instance_of?(Mustermann::Sinatra)
     end
 
+    # Returns the handler
     # @return [Mustermann::Sinatra] Returns a Mustermann::Sinatra when @path is string.
     # @return [Regexp] Returns a regexp when @path is regexp.
     def handler
@@ -65,14 +76,16 @@ module Pendragon
         end
     end
 
+    # Converts the handler into String
     # @return [String] Returns a converted handler.
     def to_s
       handler.to_s
     end
 
+    # Returns all named captures
     # @return [Array] Returns a named captures.
     def names
-      handler.names.map(&:to_sym)
+      handler.names
     end
   end
 end

data/lib/pendragon/padrino/route.rb

@@ -3,7 +3,7 @@ require 'pendragon/route'
 module Pendragon
   module Padrino
     class Route < ::Pendragon::Route
-      attr_accessor :action, :cache, :cache_key, :cache_expires_in, :parent,
+      attr_accessor :action, :cache, :cache_key, :cache_expires, :parent,
                     :use_layout, :controller, :user_agent, :path_for_generation
 
       def before_filters(&block)

data/lib/pendragon/route.rb

@@ -1,4 +1,10 @@
 module Pendragon
+  # A class for defining the route
+  #
+  # @example
+  #   route = Pendragon::Route.new("/:id", "GET", capture: id: /\d+/){|params| params[:id].to_s  }
+  #   route.match("/1234") #=> #<MatchData "/category/1234" id:"1234">
+  #   route.arity
   class Route
 
     # The accessors are useful to access from Pendragon::Router
@@ -14,37 +20,59 @@ module Pendragon
     attr_writer :router
 
     # Constructs a new instance of Pendragon::Route
+    # @param [String, Regexp] path The path of route
+    # @param [String, Symbol] verb The verb of route
+    # @param [Hash] options The options hash
     def initialize(path, verb, options = {}, &block)
       @block = block if block_given?
-      @path, @verb = path, verb
+      @path, @verb = path, verb.to_s.upcase
       @capture = {}
       @order = 0
       merge_with_options!(options)
     end
 
+    # Returns an instance of Pendragon::Matcherthat is associated with the route
+    # @return [Pendragon::Matcher]
     def matcher
       @matcher ||= Matcher.new(@path, :capture        => @capture,
                                       :default_values => options[:default_values])
     end
 
+    # Returns arity of route block
+    # @return [Fixnum]
     def arity
       @block.arity
     end
 
+    # Calls the route block with arguments
+    # @param [Array] args The arguments are passed to the route block
     def call(*args)
       @block.call(*args)
     end
 
+    # Matches a pattern with the route matcher
+    # @param [String] pattern The pattern will be matched with route matcher
+    # @return (see Pendragon::Matcher#match)
     def match(pattern)
       matcher.match(pattern)
     end
 
+    # Associates the block with the route, and increments current order of the router
+    # @yield The route block
     def to(&block)
       @block = block if block_given?
       @order = @router.current
       @router.increment_order!
     end
 
+    # Expands a path using parameters
+    # @param [Array] args
+    # @example
+    #   pendragon = Pendragon.new
+    #   route = pendragon.get("/category/:name"){}
+    #   route.path(name: "Doraemon") #=> "/category/Doraemon"
+    #   route.path(name: "Doraemon", hey: "Hey") #=> "/category/Doraemon?hey=Hey"
+    # @return [String] The expanded path
     def path(*args)
       return @path if args.empty?
       params = args[0]
@@ -52,21 +80,28 @@ module Pendragon
       matcher.expand(params) if matcher.mustermann?
     end
 
+    # Matches a pattern with the route matcher, and then returns the route params
+    # @param [String] pattern The pattern will be matched with the matcher
+    # @param [Hash] parameters The parameters are base of the route params
+    # @example
+    #   pendragon = Pendragon.new
+    #   route = pendragon.get("/category/:name"){}
+    #   route.params("/category/Doraemon") #=> {:name=>"Doraemon"}
+    #   route.params("/category/Doraemon", hey: "Hey") #=> {:name=>"Doraemon", :hey=>"Hey"}
+    # @return [Hash] The params for use in routing engines
     def params(pattern, parameters = {})
-      match_data, params = match(pattern), {}
+      match_data, params = match(pattern), indifferent_hash
       if match_data.names.empty?
         params.merge!(:captures => match_data.captures) unless match_data.captures.empty?
         params
       else
-        params = matcher.handler.params(pattern, :captures => match_data) || params
-        symbolize(params).merge(parameters){|key, old, new| old || new }
+        params_from_matcher = matcher.handler.params(pattern, :captures => match_data)
+        params.merge!(params_from_matcher) if params_from_matcher
+        params.merge(parameters){|key, old, new| old || new }
       end
     end
 
-    def symbolize(parameters)
-      parameters.inject({}){|result, (key, val)| result[key.to_sym] = val; result }
-    end
-
+    # @!visibility private
     def merge_with_options!(options)
       @options = {} unless @options
       options.each_pair do |key, value|
@@ -74,10 +109,16 @@ module Pendragon
       end
     end
 
+    # @!visibility private
     def accessor?(key)
       respond_to?("#{key}=") && respond_to?(key)
     end
 
-    private :symbolize, :merge_with_options!, :accessor?
+    # @!visibility private
+    def indifferent_hash
+      Hash.new{|hash, key| hash[key.to_s] if key.instance_of?(Symbol) }
+    end
+
+    private :merge_with_options!, :accessor?, :indifferent_hash
   end
 end

data/lib/pendragon/router.rb

@@ -1,13 +1,23 @@
 require 'pendragon/route'
 require 'pendragon/matcher'
-require 'pendragon/error_handler'
+require 'pendragon/error'
 require 'pendragon/configuration'
 require 'pendragon/engine/compiler'
 require 'rack'
 
 module Pendragon
+  # A class for the router
+  #
+  # @example Construct with a block which has no argument
+  #   router = Pendragon do
+  #     get("/"){ "hello world" }
+  #   end
+  #
+  # @example Construct with a block which has an argument
+  #   router = Pendragon.new do |config|
+  #     config.enable_compiler = true
+  #   end
   class Router
-
     # The accessors are useful to access from Pendragon::Route
     attr_accessor :current, :routes
 
@@ -47,6 +57,10 @@ module Pendragon
       $!.call
     end
 
+    # Calls a route, and build return value of the router
+    # @param [Pendragon::Route] route The route matched with the condition of request
+    # @param [Hash] params The params will be passed with the route
+    # @return [Array<Fixnum, Hash, Array>] The return value of the route block
     def invoke(route, params)
       response = route.arity != 0 ? route.call(params) : route.call
       return response unless configuration.auto_rack_format?
@@ -110,10 +124,10 @@ module Pendragon
     # @return [Array]
     def recognize_path(path_info)
       route, params = recognize(Rack::MockRequest.env_for(path_info)).first
-      [route.name, params]
+      [route.name, params.inject({}){|hash, (key, value)| hash[key.to_sym] = value; hash }]
     end
 
-    # Returns a expanded path matched with the conditions as arguments
+    # Returns an expanded path matched with the conditions as arguments
     # @return [String, Regexp]
     # @example
     #   router = Pendragon.new
@@ -126,12 +140,12 @@ module Pendragon
       end
     end
 
+    # Returns Pendragon configuration
+    # @return [Pendragon::Configuration]
     def configuration
       @configuration || Pendragon.configuration
     end
 
-    private
-
     # @!visibility private
     # @example
     #   extract_with_name(:index) do |route, params|
@@ -146,8 +160,8 @@ module Pendragon
         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) }])
+            [matcher_name.to_sym, (params[matcher_name] || args.shift)]}]
+          params_for_expand.merge!(Hash[params.select{|k, v| !matcher_names.include?(name) }])
           args = saved_args.dup
         else
           params_for_expand = params.dup
@@ -156,5 +170,7 @@ module Pendragon
       end
       raise InvalidRouteException
     end
+
+    private :extract_with_name
   end
 end

data/lib/pendragon/version.rb

@@ -1,4 +1,4 @@
 
 module Pendragon
-  VERSION = '0.5.0'
+  VERSION = '0.5.1'
 end

data/lib/pendragon.rb

@@ -3,7 +3,7 @@ require 'pendragon/router'
 module Pendragon
 
   # Allow the verbs of these.
-  HTTP_VERBS = [:get, :post, :delete, :put, :head]
+  HTTP_VERBS = %w[GET POST PUT PATCH DELETE HEAD OPTIONS LINK UNLINK].freeze
 
   class << self
     # A new instance of Pendragon::Router
@@ -38,8 +38,7 @@ module Pendragon
       @configuration = nil
     end
 
-    private
-
+    # @!visibility private
     def configuration_warning(method)
       warn <<-WARN
 Pendragon.#{method} is deprecated because it isn't thread-safe.
@@ -50,5 +49,7 @@ Pendragon.new do |config|
 end
       WARN
     end
+
+    private :configuration_warning
   end
 end

data/pendragon.gemspec

@@ -16,5 +16,5 @@ Gem::Specification.new "pendragon", Pendragon::VERSION do |s|
   s.add_development_dependency "rack-test", ">= 0.5.0"
   s.add_development_dependency "mocha", ">= 0.10.0"
   s.add_development_dependency "haml"
-  s.add_development_dependency "padrino-core", "= 0.12.0.rc3"
+  s.add_development_dependency "padrino", "~> 0.12.2"
 end

data/test/helper.rb

@@ -7,6 +7,7 @@ require 'minitest/autorun'
 require 'minitest/spec'
 require 'mocha/setup'
 require 'padrino-core'
+require 'padrino/rendering'
 require 'rack'
 require 'rack/test'
 

data/test/padrino_test.rb

@@ -6,7 +6,6 @@ class FooError < RuntimeError; end
 
 describe "Pendragon::Padrino" do
   setup do
-    Padrino::Application.send(:register, Padrino::Rendering)
     Padrino::Application.send(:register, Pendragon::Padrino)
     Padrino::Rendering::DEFAULT_RENDERING_OPTIONS[:strict_format] = false
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pendragon
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - namusyaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-26 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -95,19 +95,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: padrino-core
+  name: padrino
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.12.0.rc3
+        version: 0.12.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 0.12.0.rc3
+        version: 0.12.2
 description: Provides an HTTP router for use in Rack and Padrino.
 email: namusyaka@gmail.com
 executables: []
@@ -124,7 +124,7 @@ files:
 - lib/pendragon/configuration.rb
 - lib/pendragon/engine/compiler.rb
 - lib/pendragon/engine/recognizer.rb
-- lib/pendragon/error_handler.rb
+- lib/pendragon/error.rb
 - lib/pendragon/matcher.rb
 - lib/pendragon/padrino.rb
 - lib/pendragon/padrino/ext/class_methods.rb

data/lib/pendragon/error_handler.rb

@@ -1,47 +0,0 @@
-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"
-
-    def initialize(verbs)
-      default_response[1].merge!("Allow" => verbs.map{|verb| verb.upcase } * ", ")
-    end
-  end
-
-  class BadRequest < ErrorHandler
-    set :status, 400
-    set :body,   "Bad Request"
-  end
-end