padrino-core 0.12.9 → 0.13.0.beta1

data/lib/padrino-core/path_router/matcher.rb

@@ -0,0 +1,123 @@
+require 'mustermann/sinatra'
+
+module Padrino
+  module PathRouter
+    class Matcher
+      # To count group of regexp
+      GROUP_REGEXP = %r{\((?!\?:|\?!|\?<=|\?<!|\?=).+?\)}.freeze
+
+      ##
+      # Constructs an instance of PathRouter::Matcher.
+      #
+      def initialize(path, options = {})
+        @path = path.is_a?(String) && path.empty? ? "/" : path
+        @capture = options[:capture]
+        @default_values = options[:default_values]
+      end
+  
+      ##
+      # Matches a pattern with the route matcher.
+      #
+      def match(pattern)
+        if match_data = handler.match(pattern)
+          match_data
+        elsif mustermann? && pattern != "/" && pattern.end_with?("/")
+          handler.match(pattern[0..-2])
+        end
+      end
+
+      ##
+      # Returns a regexp from handler.
+      #
+      def to_regexp
+        mustermann? ? handler.to_regexp : handler
+      end
+  
+      ##
+      # Expands the path by using parameters.
+      #
+      def expand(params)
+        params = params.merge(@default_values) if @default_values.is_a?(Hash)
+        expanded_path = handler.expand(:append, params)
+        expanded_path
+      end
+  
+      ##
+      # Returns true if handler is an instance of Mustermann.
+      #
+      def mustermann?
+        handler.instance_of?(Mustermann::Sinatra)
+      end
+
+      ##
+      # Builds a parameters, and returns them.
+      #
+      def params_for(pattern, others)
+        data = match(pattern)
+        params = indifferent_hash
+        if data.names.empty?
+          params.merge!(:captures => data.captures) unless data.captures.empty?
+        else
+          if mustermann?
+            new_params = handler.params(pattern, :captures => data)
+            params.merge!(new_params) if new_params
+          elsif data
+            params.merge!(Hash[names.zip(data.captures)])
+          end
+          params.merge!(others){ |_, old, new| old || new }
+        end
+        params
+      end
+  
+      ##
+      # Returns the handler which is an instance of Mustermann or Regexp.
+      #
+      def handler
+        @handler ||=
+          case @path
+          when String
+            Mustermann.new(@path, :capture => @capture)
+          when Regexp
+            /^(?:#{@path})$/
+          else
+            @path
+          end
+      end
+  
+      ##
+      # Converts the handler into string.
+      #
+      def to_s
+        handler.to_s
+      end
+  
+      ##
+      # Returns names of the handler.
+      # @see Regexp#names
+      #
+      def names
+        handler.names
+      end
+
+      ##
+      # Returns captures parameter length.
+      #
+      def capture_length
+        if mustermann?
+          handler.named_captures.inject(0) { |count, (_, capture)| count += capture.length }
+        else
+          handler.inspect.scan(GROUP_REGEXP).length
+        end
+      end
+
+      private
+
+      ##
+      # Creates a hash with indifferent access.
+      #
+      def indifferent_hash
+        Hash.new{ |hash, key| hash[key.to_s] if key.instance_of?(Symbol) }
+      end
+    end
+  end
+end

data/lib/padrino-core/path_router/route.rb

@@ -0,0 +1,169 @@
+module Padrino
+  module PathRouter
+    class Route
+      ##
+      # The accessors are useful to access from PathRouter::Router
+      #
+      attr_accessor :name, :capture, :order, :options, :index
+
+      ##
+      # A reader for compile option
+      #
+      attr_reader :verb, :block
+
+      ##
+      # The router will be treated in this class
+      #
+      attr_writer :router
+
+      ##
+      # The accessors will be used in other classes
+      #
+      attr_accessor :action, :cache, :cache_key, :cache_expires,
+                    :parent, :use_layout, :controller, :user_agent, :path_for_generation, :default_values
+  
+      ##
+      # Constructs an instance of PathRouter::Route.
+      #
+      def initialize(path, verb, options = {}, &block)
+        @path = path
+        @verb = verb
+        @capture = {}
+        @order   = 0
+        @block   = block if block_given?
+        merge_with_options!(options)
+      end
+  
+      ##
+      # Calls the route block with arguments.
+      #
+      def call(app, *args)
+        @block.call(app, *args)
+      end
+  
+      ##
+      # Returns the route's verb as an array.
+      #
+      def request_methods
+        [verb.to_s.upcase]
+      end
+  
+      ##
+      # Returns the original path.
+      #
+      def original_path
+        @path
+      end
+  
+      SIGNIFICANT_VARIABLES_REGEX = /(^|[^\\])[:\*]([a-zA-Z0-9_]+)/.freeze
+
+      ##
+      # Returns signficant variable names.
+      #
+      def significant_variable_names
+        @significant_variable_names ||=
+          if @path.is_a?(String)
+            @path.scan(SIGNIFICANT_VARIABLES_REGEX).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
+  
+      ##
+      # Returns an instance of PathRouter::Matcher that is associated with the route.
+      #
+      def matcher
+        @matcher ||= Matcher.new(@path, :capture => @capture, :default_values => default_values)
+      end
+
+      ##
+      # @see PathRouter::Matcher#match
+      #
+      def match(pattern)
+        matcher.match(pattern)
+      end
+  
+      ##
+      # Associates a block with the route, and increments current order of the router.
+      #
+      def to(&block)
+        @block = block if block_given?
+        @order = @router.current_order
+        @router.increment_order
+      end
+  
+      ##
+      # Expands the path by using parameters.
+      # @see PathRouter::Matcher#expand
+      #
+      def path(*args)
+        return @path if args.empty?
+        params = args[0].dup
+        params.delete(:captures)
+        matcher.expand(params) if matcher.mustermann?
+      end
+
+      ##
+      # Returns parameters which is created by the matcher.
+      #
+      def params_for(pattern, others = {})
+        matcher.params_for(pattern, others)
+      end
+  
+      ##
+      # Returns before_filters as an array.
+      #
+      def before_filters(&block)
+        @_before_filters ||= []
+        @_before_filters << block if block_given?
+        @_before_filters
+      end
+
+      ##
+      # Returns after_filters as an array.
+      #
+      def after_filters(&block)
+        @_after_filters ||= []
+        @_after_filters << block if block_given?
+        @_after_filters
+      end
+  
+      ##
+      # Returns custom_conditions as an array.
+      #
+      def custom_conditions(&block)
+        @_custom_conditions ||= []
+        @_custom_conditions << block if block_given?
+        @_custom_conditions
+      end
+
+      ##
+      # Returns block parameter length.
+      #
+      def block_parameter_length
+        matcher.capture_length
+      end
+
+      private
+  
+      ##
+      # Set value to accessor if option name has been defined as an accessora.
+      #
+      def merge_with_options!(options)
+        @options ||= {}
+        options.each_pair do |key, value|
+          accessor?(key) ? __send__("#{key}=", value) : (@options[key] = value)
+        end
+      end
+  
+      ##
+      # Returns true if name has been defined as an accessor.
+      #
+      def accessor?(key)
+        respond_to?("#{key}=") && respond_to?(key)
+      end
+    end
+  end
+end

data/lib/padrino-core/path_router.rb

@@ -0,0 +1,119 @@
+require 'padrino-core/path_router/error_handler'
+require 'padrino-core/path_router/route'
+require 'padrino-core/path_router/matcher'
+require 'padrino-core/path_router/compiler'
+
+module Padrino
+  ##
+  # Provides an HTTP router for use in path routing.
+  #
+  module PathRouter
+    ##
+    # Constructs an instance of PathRouter::Router.
+    #
+    def self.new
+      Router.new
+    end
+
+    class Router
+      attr_reader :current_order, :routes, :engine
+
+      ##
+      # Constructs an instance of PathRouter::Router.
+      #
+      def initialize
+        reset!
+      end
+
+      ##
+      # Adds a new route to routes.
+      #
+      def add(verb, path, options = {}, &block)
+        route = Route.new(path, verb, options, &block)
+        route.router = self
+        @routes << route
+        route
+      end
+
+      ##
+      # Returns all routes which are matched with the condition
+      #
+      def call(request, &block)
+        prepare! unless prepared?
+        @engine.call_by_request(request, &block)
+      end
+
+      ##
+      # Returns all routes which are matched with the condition without block
+      #
+      def recognize(request_or_env)
+        prepare! unless prepared?
+        @engine.find_by(request_or_env)
+      end
+
+      ##
+      # Finds a path which is matched with conditions from arguments
+      #
+      def path(name, *args)
+        params = args.extract_options!
+        @routes.each do |route|
+          next unless route.name == name
+          matcher = route.matcher
+          params_for_expand = params.dup
+          if !args.empty? && matcher.mustermann?
+            matcher.names.each_with_index do |matcher_name, index|
+              params_for_expand[matcher_name.to_sym] ||= args[index]
+            end
+          end
+          return matcher.mustermann? ? matcher.expand(params_for_expand) : route.path_for_generation
+        end
+        fail InvalidRouteException
+      end
+
+      ##
+      # Recognizes route and expanded params from a path.
+      #
+      def recognize_path(path_info)
+        prepare! unless prepared?
+        route = @engine.find_by_pattern(path_info).first
+        [route.name, route.params_for(path_info, {})]
+      end
+
+      ##
+      # Resets all routes, current order and preparation.
+      #
+      def reset!
+        @routes = []
+        @current_order = 0
+        @prepared = nil
+      end
+
+      ##
+      # Increments the order.
+      #
+      def increment_order
+        @current_order += 1
+      end
+
+      ##
+      # Constructs an instance of PathRouter::Compiler,
+      # and sorts all routes by using the order.
+      #
+      def prepare!
+        @engine = Compiler.new(@routes)
+        @prepared = true
+        return if @current_order.zero?
+        @routes.sort_by!(&:order)
+      end
+
+      private
+
+      ##
+      # Returns true if the router has been prepared.
+      #
+      def prepared?
+        !!@prepared
+      end
+    end
+  end
+end

data/lib/padrino-core/reloader/rack.rb

@@ -11,15 +11,12 @@ module Padrino
         @app = app
         @cooldown = cooldown
         @last = (Time.now - cooldown)
-        @mutex = Mutex.new
       end
 
       # Invoked in order to perform the reload as part of the request stack.
       def call(env)
         if @cooldown && Time.now > @last + @cooldown
-          @mutex.synchronize do
-            Padrino.reload!
-          end
+          Thread.list.size > 1 ? Thread.exclusive { Padrino.reload! } : Padrino.reload!
           @last = Time.now
         end
         @app.call(env)

data/lib/padrino-core/reloader/storage.rb

@@ -22,7 +22,7 @@ module Padrino
         file = remove(name)
         @old_entries ||= {}
         @old_entries[name] = {
-          :constants => object_classes,
+          :constants => ObjectSpace.classes,
           :features  => old_features = Set.new($LOADED_FEATURES.dup)
         }
         features = file && file[:features] || []
@@ -32,7 +32,7 @@ module Padrino
 
       def commit(name)
         entry = {
-          :constants => new_classes(@old_entries[name][:constants]),
+          :constants => ObjectSpace.new_classes(@old_entries[name][:constants]),
           :features  => Set.new($LOADED_FEATURES) - @old_entries[name][:features] - [name]
         }
         files[name] = entry
@@ -40,7 +40,7 @@ module Padrino
       end
 
       def rollback(name)
-        new_constants = new_classes(@old_entries[name][:constants])
+        new_constants = ObjectSpace.new_classes(@old_entries[name][:constants])
         new_constants.each{ |klass| Reloader.remove_constant(klass) }
         @old_entries.delete(name)
       end
@@ -50,34 +50,6 @@ module Padrino
       def files
         @files ||= {}
       end
-
-      ##
-      # Returns all the classes in the object space.
-      #
-      def object_classes
-        klasses = Set.new
-
-        ObjectSpace.each_object(Class).each do |klass|
-          if block_given?
-            if filtered_class = yield(klass)
-              klasses << filtered_class
-            end
-          else
-            klasses << klass
-          end
-        end
-
-        klasses
-      end
-
-      ##
-      # Returns a list of object space classes that are not included in "snapshot".
-      #
-      def new_classes(snapshot)
-        object_classes do |klass|
-          snapshot.include?(klass) ? nil : klass
-        end
-      end
     end
   end
 end