pendragon 0.6.2 → 1.0.0

data/lib/pendragon/matcher.rb

@@ -1,93 +0,0 @@
-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_DELIMITER : path
-      @capture = options.delete(:capture)
-      @default_values = options.delete(:default_values)
-    end
-
-    # 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)
-      match_data = handler.match(pattern)
-      return match_data if match_data
-      pattern = pattern[0..-2] if mustermann? && pattern != PATH_DELIMITER && pattern.end_with?(PATH_DELIMITER)
-      handler.match(pattern)
-    end
-
-    # 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"
-    # @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_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
-      @handler ||=
-        case @path
-        when String
-          Mustermann::Sinatra.new(@path, :capture => @capture)
-        when Regexp
-          /^(?:#{@path})$/
-        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
-    end
-  end
-end

data/lib/pendragon/padrino.rb

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

data/lib/pendragon/padrino/ext/class_methods.rb

@@ -1,318 +0,0 @@
-module Pendragon
-  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
-        unless @router
-          @router = ::Pendragon::Padrino::Router.new
-          @router.configuration = Pendragon::Configuration.new
-          if settings.respond_to?(:pendragon) && settings.pendragon.instance_of?(Hash)
-            settings.pendragon.each_pair do |key, value|
-              @router.configuration.send("#{key}=", value)
-            end
-          end
-        end
-        block_given? ? yield(@router) : @router
-      end
-
-      def compiled_router
-        if @deferred_routes
-          deferred_routes.each do |routes|
-            routes.each do |(route, dest)|
-              route.to(&dest)
-              route.before_filters.flatten!
-              route.after_filters.flatten!
-            end
-          end
-          @deferred_routes = nil
-        end
-        router
-      end
-
-      def deferred_routes
-        @deferred_routes ||= ROUTE_PRIORITY.map{[]}
-      end
-
-      def url(*args)
-        params = args.extract_options!
-        fragment = params.delete(:fragment) || params.delete(:anchor)
-        path = make_path_with_params(args, value_to_param(params.symbolize_keys))
-        rebase_url(fragment ? path << '#' << fragment : path)
-      end
-      alias :url_for :url
-
-      def make_path_with_params(args, params)
-        names, params_array = args.partition{ |arg| arg.is_a?(Symbol) }
-        name = names[0, 2].join(" ").to_sym
-        compiled_router.path(name, *(params_array << params))
-      rescue Pendragon::InvalidRouteException
-        raise ::Padrino::Routing::UnrecognizedException, "Route mapping for url(#{name.inspect}) could not be found"
-      end
-
-      def recognize_path(path)
-        responses = @router.recognize_path(path)
-        [responses[0], responses[1]]
-      end
-
-      def rebase_url(url)
-        if url.start_with?('/')
-          new_url = ''
-          new_url << conform_uri(ENV['RACK_BASE_URI']) if ENV['RACK_BASE_URI']
-          new_url << conform_uri(uri_root) if defined?(uri_root)
-          new_url << url
-        else
-          url.blank? ? '/' : url
-        end
-      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
-        route_options[:accepts] = @_accepts if @_accepts
-        route_options[:params] = @_params unless @_params.nil? || route_options.include?(:params)
-
-        if protect_from_csrf && (report_csrf_failure || allow_disabled_csrf)
-          unless route_options.has_key?(:csrf_protection)
-            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)
-
-        # Pendragon route construction
-        path[0, 0] = "/" if path == "(.:format)?"
-        route_options.merge!(:name => name) if name
-        route = router.add(verb.downcase.to_sym, path, route_options)
-        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.options[: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 << @filters[:before]
-        route.after_filters << @filters[:after]
-        if @_controller
-          route.use_layout = @layout
-          route.controller = Array(@_controller)[0].to_s
-        end
-
-        deferred_routes[priority] << [route, block]
-
-        route
-      end
-
-      def parse_route(path, options, verb)
-        route_options = {}
-
-        if options[:params] == true
-          options.delete(:params)
-        elsif options.include?(:params)
-          options[:params] ||= []
-          options[:params] += options[:with] if options[:with]
-        end
-
-        # We need check if path is a symbol, if that it's a named route.
-        map = options.delete(:map)
-
-        # path i.e :index or :show
-        if path.kind_of?(Symbol)
-          name = path
-          path = map ? map.dup : (path == :index ? '/' : path.to_s)
-        end
-
-        # Build our controller
-        controller = Array(@_controller).map(&:to_s)
-
-        case path
-        when String # path i.e "/index" or "/show"
-          # Now we need to parse our 'with' params
-          if with_params = options.delete(:with)
-            path = process_path_for_with_params(path, with_params)
-          end
-
-          # Now we need to parse our provides
-          options.delete(:provides) if options[:provides].nil?
-
-          if @_use_format or format_params = options[:provides]
-            process_path_for_provides(path, format_params)
-            # options[:add_match_with] ||= {}
-            # options[:add_match_with][:format] = /[^\.]+/
-          end
-
-          absolute_map = map && map[0] == ?/
-
-          unless controller.empty?
-            # Now we need to add our controller path only if not mapped directly
-            if map.blank? and !absolute_map
-              controller_path = controller.join("/")
-              path.gsub!(%r{^\(/\)|/\?}, "")
-              path = File.join(controller_path, path) unless @_map
-            end
-          end
-
-          # Now we need to parse our 'parent' params and parent scope.
-          if !absolute_map and parent_params = options.delete(:parent) || @_parent
-            parent_params = (Array(@_parent) + Array(parent_params)).uniq
-            path = process_path_for_parent_params(path, parent_params)
-          end
-
-          # Add any controller level map to the front of the path.
-          path = "#{@_map}/#{path}".squeeze('/') unless absolute_map or @_map.blank?
-
-          # Small reformats
-          path.gsub!(%r{/\?$}, '(/)') # Remove index path
-          path.gsub!(%r{//$}, '/') # Remove index path
-          path[0,0] = "/" if path !~ %r{^\(?/} # Paths must start with a /
-          path.sub!(%r{/(\))?$}, '\\1') if path != "/" # Remove latest trailing delimiter
-          path.gsub!(/\/(\(\.|$)/, '\\1') # Remove trailing slashes
-          path.squeeze!('/')
-        when Regexp
-          route_options[:path_for_generation] = options.delete(:generate_with) if options.key?(:generate_with)
-        end
-
-        name = options.delete(:route_name) if name.nil? && options.key?(:route_name)
-        name = options.delete(:name) if name.nil? && options.key?(:name)
-        if name
-          controller_name = controller.join("_")
-          name = "#{controller_name} #{name}".to_sym unless controller_name.blank?
-        end
-
-        # Merge in option defaults.
-        options.reverse_merge!(:default_values => @_defaults)
-
-        [path, name, parent_params, options, route_options]
-      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 }
-          accepts = [] if accepts == ["*/*"]
-
-          # 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
-
-      def process_path_for_parent_params(path, parent_params)
-        parent_prefix = parent_params.flatten.compact.uniq.map do |param|
-          map = (param.respond_to?(:map) && param.map ? param.map : param.to_s)
-          part = "#{map}/:#{param.to_s.singularize}_id/"
-          part = "(#{part})?" if param.respond_to?(:optional) && param.optional?
-          part
-        end
-
-        [parent_prefix, path].flatten.join("")
-      end
-
-      def process_path_for_provides(path, format_params)
-        path << "(.:format)?" unless path[-11, 11] == '(.:format)?'
-      end
-    end
-  end
-end
-
-if defined?(Padrino) && Padrino::VERSION < '0.12.0'
-  module Padrino
-    class Filter
-      def apply?(request)
-        detect = @args.any? do |arg|
-          case arg
-          when Symbol then request.route_obj && (request.route_obj.name == arg or request.route_obj.name == [@scoped_controller, arg].flatten.join(" ").to_sym)
-          else arg === request.path_info
-          end
-        end || @options.any? do |name, val|
-          case name
-          when :agent then val === request.user_agent
-          else val === request.send(name)
-          end
-        end
-        detect ^ !@mode
-      end
-    end
-  end
-end

data/lib/pendragon/padrino/ext/instance_methods.rb

@@ -1,63 +0,0 @@
-module Pendragon
-  module Padrino
-    module InstanceMethods
-      private
-
-      def invoke_route(route, params, options = {})
-        original_params, parent_layout, successful = @params.dup, @layout, false
-        captured_params = params[:captures].is_a?(Array) ? params.delete(:captures) :
-                                                           params.values_at(*route.matcher.names.dup)
-
-        @_response_buffer = nil
-        @route = request.route_obj = route
-        @params.merge!(params) if params.is_a?(Hash)
-        @params.merge!(:captures => captured_params) if !captured_params.empty? && route.path.is_a?(Regexp)
-        @block_params = params
-
-        filter! :before if options[:first]
-
-        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 }
-            halt_response     = catch(:halt){ route_eval{ route.block[self, captured_params] }}
-            @_response_buffer = halt_response.is_a?(Array) ? halt_response.last : halt_response
-            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
-
-      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, pendragon_params), index|
-            next if route.user_agent && !(route.user_agent =~ @request.user_agent)
-            invoke_route(route, pendragon_params, :first => index.zero?)
-          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