padrino-core 0.12.2 → 0.12.3

data/lib/padrino-core/application.rb

@@ -26,14 +26,16 @@ module Padrino
       Padrino.logger
     end
 
-    # TODO: Remove this hack after getting rid of thread-unsafe http_router:
-    alias_method :original_call, :call
-    def call(*args)
-      settings.init_mutex.synchronize do
-        instance_eval{ undef :call }
-        class_eval{ alias_method :call, :original_call }
-        instance_eval{ undef :original_call }
-        super(*args)
+    # TODO: Remove this hack (issue #863) after getting rid of thread-unsafe http_router:
+    if RUBY_PLATFORM == "java"
+      alias_method :original_call, :call
+      def call(*args)
+        settings.init_mutex.synchronize do
+          instance_eval{ undef :call }
+          class_eval{ alias_method :call, :original_call }
+          instance_eval{ undef :original_call }
+          super(*args)
+        end
       end
     end
 
@@ -126,20 +128,6 @@ module Padrino
         Padrino.run!(options)
       end
 
-      ##
-      # @return [Array]
-      #   directory that need to be added to +$LOAD_PATHS+ from this application
-      #
-      def load_paths
-        @_load_paths ||= [
-          'models',
-          'lib',
-          'mailers',
-          'controllers',
-          'helpers',
-        ].map { |path| File.join(settings.root, path) }
-      end
-
       ##
       # Returns default list of path globs to load as dependencies.
       # Appends custom dependency patterns to the be loaded for your Application.
@@ -161,7 +149,7 @@ module Padrino
           'controllers.rb',
           'helpers/**/*.rb',
           'helpers.rb',
-        ].map { |file| Dir[File.join(settings.root, file)] }.flatten
+        ].map { |file| Dir.glob(File.join(settings.root, file)) }.flatten
       end
 
       ##
@@ -187,13 +175,18 @@ module Padrino
         set(option, *args, &block) unless respond_to?(option)
       end
 
+      # Deprecated
+      def load_paths
+        warn 'Padrino::Application#load_paths is deprecated. Please, use #prerequisites'
+        []
+      end
+
       protected
 
       ##
       # Requires all files within the application load paths.
       #
       def require_dependencies
-        Padrino.set_load_paths(*load_paths)
         Padrino.require_dependencies(dependencies, :force => true)
       end
     end

data/lib/padrino-core/cli/base.rb

@@ -1,47 +1,8 @@
-require 'thor'
+require 'padrino-core/cli/launcher'
 
 module Padrino
   module Cli
-
-    class Base < Thor
-      include Thor::Actions
-
-      class_option :chdir, :type => :string, :aliases => "-c", :desc => "Change to dir before starting."
-      class_option :environment, :type => :string,  :aliases => "-e", :required => true, :default => :development, :desc => "Padrino Environment."
-      class_option :help, :type => :boolean, :desc => "Show help usage"
-
-      desc "start", "Starts the Padrino application (alternatively use 's')."
-      map "s" => :start
-      method_option :server,    :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
-      method_option :host,      :type => :string,  :aliases => "-h", :desc => "Bind to HOST address (default: 127.0.0.1)"
-      method_option :port,      :type => :numeric, :aliases => "-p", :desc => "Use PORT (default: 3000)"
-      method_option :daemonize, :type => :boolean, :aliases => "-d", :desc => "Run daemonized in the background."
-      method_option :pid,       :type => :string,  :aliases => "-i", :desc => "File to store pid."
-      method_option :debug,     :type => :boolean,                   :desc => "Set debugging flags."
-      method_option :options,   :type => :array,  :aliases => "-O", :desc => "--options NAME=VALUE NAME2=VALUE2'. pass VALUE to the server as option NAME. If no VALUE, sets it to true. Run '#{$0} --server_options"
-      method_option :server_options,   :type => :boolean, :desc => "Tells the current server handler's options that can be used with --options"
-
-      def start(*args)
-        prepare :start
-        require File.expand_path("../adapter", __FILE__)
-        require File.expand_path('config/boot.rb')
-
-        if options[:server_options]
-          puts server_options(options)
-        else
-          Padrino::Cli::Adapter.start(args.last ? options.merge(:config => args.last).freeze : options)
-        end
-      end
-
-      desc "stop", "Stops the Padrino application (alternatively use 'st')."
-      map "st" => :stop
-      method_option :pid, :type => :string,  :aliases => "-p", :desc => "File to store pid", :default => 'tmp/pids/server.pid'
-      def stop
-        prepare :stop
-        require File.expand_path("../adapter", __FILE__)
-        Padrino::Cli::Adapter.stop(options)
-      end
-
+    class Base < Launcher
       desc "rake", "Execute rake tasks."
       method_option :environment, :type => :string,  :aliases => "-e", :required => true, :default => :development
       method_option :list,        :type => :string,  :aliases => "-T", :desc => "Display the tasks (matching optional PATTERN) with descriptions, then exit."
@@ -120,61 +81,12 @@ module Padrino
         end
       end
 
-      private
-
-      def prepare(task)
-        if options.help?
-          help(task.to_s)
-          raise SystemExit
-        end
-        ENV["RACK_ENV"] ||= options.environment.to_s
-        chdir(options.chdir)
-        unless File.exist?('config/boot.rb')
-          puts "=> Could not find boot file in: #{options.chdir}/config/boot.rb !!!"
-          raise SystemExit
-        end
-      end
-
-      # https://github.com/rack/rack/blob/master/lib/rack/server.rb\#L100
-      def server_options(options)
-        begin
-          info = []
-          server = Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
-          if server && server.respond_to?(:valid_options)
-            info << ""
-            info << "Server-specific options for #{server.name}:"
-
-            has_options = false
-            server.valid_options.each do |name, description|
-              next if name.to_s.match(/^(Host|Port)[^a-zA-Z]/) # ignore handler's host and port options, we do our own.
-              info << "  -O %-21s %s" % [name, description]
-              has_options = true
-            end
-            return "" if !has_options
-          end
-          info.join("\n")
-        rescue NameError
-          return "Warning: Could not find handler specified (#{options[:server] || 'default'}) to determine handler-specific options"
-        end
-      end
-
       protected
 
       def self.banner(task=nil, *args)
         "padrino #{task.name}"
       end
 
-      def chdir(dir)
-        return unless dir
-        begin
-          Dir.chdir(dir.to_s)
-        rescue Errno::ENOENT
-          puts "=> Specified Padrino root '#{dir}' does not appear to exist!"
-        rescue Errno::EACCES
-          puts "=> Specified Padrino root '#{dir}' cannot be accessed by the current user!"
-        end
-      end
-
       def capture(stream)
         begin
           stream = stream.to_s

data/lib/padrino-core/cli/launcher.rb

@@ -0,0 +1,95 @@
+require 'thor'
+
+module Padrino
+  module Cli
+    class Launcher < Thor
+      include Thor::Actions
+
+      class_option :chdir, :type => :string, :aliases => "-c", :desc => "Change to dir before starting."
+      class_option :environment, :type => :string,  :aliases => "-e", :required => true, :default => :development, :desc => "Padrino Environment."
+      class_option :help, :type => :boolean, :desc => "Show help usage"
+
+      desc "start", "Starts the Padrino application (alternatively use 's')."
+      map "s" => :start
+      method_option :server,    :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
+      method_option :host,      :type => :string,  :aliases => "-h", :desc => "Bind to HOST address (default: 127.0.0.1)"
+      method_option :port,      :type => :numeric, :aliases => "-p", :desc => "Use PORT (default: 3000)"
+      method_option :daemonize, :type => :boolean, :aliases => "-d", :desc => "Run daemonized in the background."
+      method_option :pid,       :type => :string,  :aliases => "-i", :desc => "File to store pid."
+      method_option :debug,     :type => :boolean,                   :desc => "Set debugging flags."
+      method_option :options,   :type => :array,  :aliases => "-O", :desc => "--options NAME=VALUE NAME2=VALUE2'. pass VALUE to the server as option NAME. If no VALUE, sets it to true. Run '#{$0} --server_options"
+      method_option :server_options,   :type => :boolean, :desc => "Tells the current server handler's options that can be used with --options"
+      def start(*args)
+        prepare :start
+        require File.expand_path("../adapter", __FILE__)
+        require File.expand_path('config/boot.rb')
+
+        if options[:server_options]
+          puts server_options(options)
+        else
+          Padrino::Cli::Adapter.start(args.last ? options.merge(:config => args.last).freeze : options)
+        end
+      end
+
+      desc "stop", "Stops the Padrino application (alternatively use 'st')."
+      map "st" => :stop
+      method_option :pid, :type => :string,  :aliases => "-p", :desc => "File to store pid", :default => 'tmp/pids/server.pid'
+      def stop
+        prepare :stop
+        require File.expand_path("../adapter", __FILE__)
+        Padrino::Cli::Adapter.stop(options)
+      end
+
+      private
+
+      # https://github.com/rack/rack/blob/master/lib/rack/server.rb\#L100
+      def server_options(options)
+        begin
+          info = []
+          server = Rack::Handler.get(options[:server]) || Rack::Handler.default(options)
+          if server && server.respond_to?(:valid_options)
+            info << ""
+            info << "Server-specific options for #{server.name}:"
+
+            has_options = false
+            server.valid_options.each do |name, description|
+              next if name.to_s.match(/^(Host|Port)[^a-zA-Z]/) # ignore handler's host and port options, we do our own.
+              info << "  -O %-21s %s" % [name, description]
+              has_options = true
+            end
+            return "" if !has_options
+          end
+          info.join("\n")
+        rescue NameError
+          return "Warning: Could not find handler specified (#{options[:server] || 'default'}) to determine handler-specific options"
+        end
+      end
+
+      protected
+
+      def prepare(task)
+        if options.help?
+          help(task.to_s)
+          raise SystemExit
+        end
+        ENV["RACK_ENV"] ||= options.environment.to_s
+        chdir(options.chdir)
+        unless File.exist?('config/boot.rb')
+          puts "=> Could not find boot file in: #{options.chdir}/config/boot.rb !!!"
+          raise SystemExit
+        end
+      end
+
+      def chdir(dir)
+        return unless dir
+        begin
+          Dir.chdir(dir.to_s)
+        rescue Errno::ENOENT
+          puts "=> Specified Padrino root '#{dir}' does not appear to exist!"
+        rescue Errno::EACCES
+          puts "=> Specified Padrino root '#{dir}' cannot be accessed by the current user!"
+        end
+      end
+    end
+  end
+end

data/lib/padrino-core/ext/http_router.rb

@@ -0,0 +1,181 @@
+require 'http_router' unless defined?(HttpRouter)
+
+class HttpRouter
+  def rewrite_partial_path_info(env, request); end
+  def rewrite_path_info(env, request); end
+
+  def process_destination_path(path, env)
+    Thread.current['padrino.instance'].instance_eval do
+      request.route_obj = path.route
+      @_response_buffer = nil
+      @route    = path.route
+      @params ||= {}
+      @params.update(env['router.params'])
+      @block_params = if match_data = env['router.request'].extra_env['router.regex_match']
+        params_list = match_data.to_a
+        params_list.shift
+        @params[:captures] = params_list
+        params_list
+      else
+        env['router.request'].params
+      end
+      # Provide access to the current controller to the request
+      # Now we can eval route, but because we have "throw halt" we need to be
+      # (en)sure to reset old layout and run controller after filters.
+      original_params = @params
+      parent_layout   = @layout
+      successful      = false
+      begin
+        filter! :before
+        (@route.before_filters - settings.filters[:before]).each { |block| instance_eval(&block) }
+        @layout = path.route.use_layout if path.route.use_layout
+        @route.custom_conditions.each { |block| pass if block.bind(self).call == false }
+        halt_response     = catch(:halt) { route_eval { @route.dest[self, @block_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 = parent_layout
+        @params = original_params
+      end
+    end
+  end
+
+  class Route
+    VALID_HTTP_VERBS.replace %w[GET POST PUT PATCH DELETE HEAD OPTIONS LINK UNLINK]
+
+    attr_accessor :use_layout, :controller, :action, :cache, :cache_key, :cache_expires, :parent
+
+    def before_filters(&block)
+      @_before_filters ||= []
+      @_before_filters << block if block_given?
+
+      @_before_filters
+    end
+
+    def after_filters(&block)
+      @_after_filters ||= []
+      @_after_filters << block if block_given?
+
+      @_after_filters
+    end
+
+    def custom_conditions(&block)
+      @_custom_conditions ||= []
+      @_custom_conditions << block if block_given?
+
+      @_custom_conditions
+    end
+
+    def significant_variable_names
+      @significant_variable_names ||= if @original_path.is_a?(String)
+        @original_path.scan(/(^|[^\\])[:\*]([a-zA-Z0-9_]+)/).map{|p| p.last.to_sym}
+      elsif @original_path.is_a?(Regexp) and @original_path.respond_to?(:named_captures)
+        @original_path.named_captures.keys.map(&:to_sym)
+      else
+        []
+      end
+    end
+
+    def to(dest = nil, &dest_block)
+      @dest = dest || dest_block || raise("you didn't specify a destination")
+
+      @router.current_order ||= 0
+      @order = @router.current_order
+      @router.current_order += 1
+
+      if @dest.respond_to?(:url_mount=)
+        urlmount = UrlMount.new(@path_for_generation, @default_values || {}) # TODO url mount should accept nil here.
+        urlmount.url_mount = @router.url_mount if @router.url_mount
+        @dest.url_mount = urlmount
+      end
+      self
+    end
+
+    attr_accessor :order
+
+  end
+
+  attr_accessor :current_order
+
+  def sort!
+    @routes.sort!{ |a, b| a.order <=> b.order }
+  end
+
+  class Node::Glob
+    def to_code
+      id = root.next_counter
+      "request.params << (globbed_params#{id} = [])
+       until request.path.empty?
+         globbed_params#{id} << request.path.shift
+         #{super}
+       end
+       request.path[0,0] = globbed_params#{id}
+       request.params.pop"
+    end
+  end
+
+  class Node::SpanningRegex
+    def to_code
+      params_count = @ordered_indicies.size
+      whole_path_var = "whole_path#{root.next_counter}"
+      "#{whole_path_var} = request.joined_path
+      if match = #{@matcher.inspect}.match(#{whole_path_var}) and match.begin(0).zero?
+        _#{whole_path_var} = request.path.dup
+        " << param_capturing_code << "
+        remaining_path = #{whole_path_var}[match[0].size + (#{whole_path_var}[match[0].size] == ?/ ? 1 : 0), #{whole_path_var}.size]
+        request.path = remaining_path.split('/')
+        #{node_to_code}
+        request.path = _#{whole_path_var}
+        request.params.slice!(#{-params_count}, #{params_count})
+      end
+      "
+    end
+  end
+
+  # Monkey patching the Request class. Using Rack::Utils.unescape rather than
+  # URI.unescape which can't handle utf-8 chars
+  class Request
+    def initialize(path, rack_request)
+      @rack_request = rack_request
+      @path = path.split(/\//).map{|part| Rack::Utils.unescape(part) }
+      @path.shift if @path.first == ''
+      @path.push('') if path[-1] == ?/
+      @extra_env = {}
+      @params = []
+      @acceptable_methods = Set.new
+    end
+  end
+
+  class Node::Path
+    def to_code
+      path_ivar = inject_root_ivar(self)
+      "#{"if !callback && request.path.size == 1 && request.path.first == '' && (request.rack_request.head? || request.rack_request.get?) && request.rack_request.path_info[-1] == ?/
+        catch(:pass) do
+          response = ::Rack::Response.new
+          response.redirect(request.rack_request.path_info[0, request.rack_request.path_info.size - 1], 302)
+          return response.finish
+        end
+      end" if router.redirect_trailing_slash?}
+
+      #{"if request.#{router.ignore_trailing_slash? ? 'path_finished?' : 'path.empty?'}" unless route.match_partially}
+        catch(:pass) do
+          if callback
+            request.called = true
+            callback.call(Response.new(request, #{path_ivar}))
+          else
+            env = request.rack_request.dup.env
+            env['router.request'] = request
+            env['router.params'] ||= {}
+            #{"env['router.params'].merge!(Hash[#{param_names.inspect}.zip(request.params)])" if dynamic?}
+            env['router.params'] = env['router.params'].with_indifferent_access
+            @router.rewrite#{"_partial" if route.match_partially}_path_info(env, request)
+            response = @router.process_destination_path(#{path_ivar}, env)
+            return response unless router.pass_on_response(response)
+          end
+        end
+      #{"end" unless route.match_partially}"
+    end
+  end
+end

data/lib/padrino-core/ext/sinatra.rb

@@ -0,0 +1,29 @@
+require 'sinatra/base'
+
+##
+# Adds to Sinatra +controller+ informations
+#
+class Sinatra::Request
+  attr_accessor :route_obj
+
+  def controller
+    route_obj && route_obj.controller
+  end
+  def action
+    route_obj && route_obj.action
+  end
+end
+
+##
+# This patches Sinatra to accept UTF-8 urls on JRuby 1.7.6
+#
+if RUBY_ENGINE == 'jruby' && defined?(JRUBY_VERSION) && JRUBY_VERSION > '1.7.4'
+  class Sinatra::Base
+    class << self
+      alias_method :old_generate_method, :generate_method
+      def generate_method(method_name, &block)
+        old_generate_method(method_name.to_sym, &block)
+      end
+    end
+  end
+end

data/lib/padrino-core/filter.rb

@@ -0,0 +1,47 @@
+module Padrino
+  class Filter
+    attr_reader :block
+
+    def initialize(mode, scoped_controller, options, args, &block)
+      @mode, @scoped_controller, @options, @args, @block = mode, scoped_controller, options, args, block
+    end
+
+    def apply?(request)
+      detect = match_with_arguments?(request) || match_with_options?(request)
+      detect ^ !@mode
+    end
+
+    def to_proc
+      if @args.empty? && @options.empty?
+        block
+      else
+        filter = self
+        proc { instance_eval(&filter.block) if filter.apply?(request) }
+      end
+    end
+
+    private
+
+    def scoped_controller_name
+      @scoped_controller_name ||= Array(@scoped_controller).join("_")
+    end
+
+    def match_with_arguments?(request)
+      route, path = request.route_obj, request.path_info
+      @args.any? do |argument|
+        if argument.instance_of?(Symbol)
+          next unless route
+          name = route.name
+          argument == name || name == [scoped_controller_name, argument].join(" ").to_sym
+        else
+          argument === path
+        end
+      end
+    end
+
+    def match_with_options?(request)
+      user_agent = request.user_agent
+      @options.any?{|name, value| value === (name == :agent ? user_agent : request.send(name)) }
+    end
+  end
+end

data/lib/padrino-core/loader.rb

@@ -52,9 +52,7 @@ module Padrino
       began_at = Time.now
       @_called_from = first_caller
       set_encoding
-      set_load_paths(*load_paths)
-      Logger.setup!
-      require_dependencies("#{root}/config/database.rb")
+      Padrino.logger
       Reloader.lock!
       before_load.each(&:call)
       require_dependencies(*dependency_paths)
@@ -71,9 +69,7 @@ module Padrino
     def clear!
       clear_middleware!
       mounted_apps.clear
-      @_load_paths = nil
       @_dependency_paths = nil
-      @_global_configuration = nil
       before_load.clear
       after_load.clear
       Reloader.clear!
@@ -134,9 +130,9 @@ module Padrino
     #
     def require_dependencies(*paths)
       options = paths.extract_options!.merge( :cyclic => true )
-      files = paths.flatten.map{|path| Dir[path].sort_by{|v| v.count('/') }}.flatten.uniq
+      files = paths.flatten.map{ |path| Dir.glob(path).sort_by{ |filename| filename.count('/') } }.flatten.uniq
 
-      while files.present?
+      until files.empty?
         error, fatal, loaded = nil, nil, nil
 
         files.dup.each do |file|
@@ -144,44 +140,21 @@ module Padrino
             Reloader.safe_load(file, options)
             files.delete(file)
             loaded = true
-          rescue NameError, LoadError => e
-            logger.devel "Cyclic dependency reload for #{e.class}: #{e.message}"
-            error = e
-          rescue Exception => e
-            fatal = e
+          rescue NameError, LoadError => error
+            logger.devel "Cyclic dependency reload for #{error.class}: #{error.message}"
+          rescue Exception => fatal
             break
           end
         end
 
         if fatal || !loaded
-          e = fatal || error
-          logger.exception e, :short
-          raise e
+          exception = fatal || error
+          logger.exception exception, :short
+          raise exception
         end
       end
     end
 
-    ##
-    # Concat to +$LOAD_PATH+ the given paths.
-    #
-    # @param [Array<String>] paths
-    #   The paths to concat.
-    #
-    def set_load_paths(*paths)
-      load_paths.concat(paths).uniq!
-      $LOAD_PATH.concat(paths).uniq!
-    end
-
-    ##
-    # The used +$LOAD_PATHS+ from Padrino.
-    #
-    # @return [Array<String>]
-    #   The load paths used by Padrino.
-    #
-    def load_paths
-      @_load_paths ||= load_paths_was.dup
-    end
-
     ##
     # Returns default list of path globs to load as dependencies.
     # Appends custom dependency patterns to the be loaded for Padrino.
@@ -193,32 +166,36 @@ module Padrino
     #   Padrino.dependency_paths << "#{Padrino.root}/uploaders/*.rb"
     #
     def dependency_paths
-      @_dependency_paths ||= dependency_paths_was + module_paths
+      @_dependency_paths ||= default_dependency_paths + modules_dependency_paths
     end
 
-    private
+    # Deprecated
+    def set_load_paths(*)
+      warn 'Padrino.set_load_paths is deprecated. Please, use $LOAD_PATH.concat(paths)'
+      []
+    end
 
-    def module_paths
-      modules.map(&:dependency_paths).flatten
+    # Deprecated
+    def load_paths
+      warn 'Padrino.load_paths is deprecated. Please, use Padrino::Application#prerequisites'
+      []
     end
 
-    def load_paths_was
-      @_load_paths_was ||= [
-        "#{root}/lib",
-        "#{root}/models",
-        "#{root}/shared",
-      ].freeze
+    private
+
+    def modules_dependency_paths
+      modules.map(&:dependency_paths).flatten
     end
 
-    def dependency_paths_was
-      @_dependency_paths_was ||= [
+    def default_dependency_paths
+      @default_dependency_paths ||= [
         "#{root}/config/database.rb",
         "#{root}/lib/**/*.rb",
         "#{root}/models/**/*.rb",
         "#{root}/shared/lib/**/*.rb",
         "#{root}/shared/models/**/*.rb",
-        "#{root}/config/apps.rb"
-      ].freeze
+        "#{root}/config/apps.rb",
+      ]
     end
   end
 end