padrino-core 0.9.28 → 0.9.29

data/lib/padrino-core.rb

@@ -37,9 +37,9 @@ module Padrino
     # Returns the resulting rack builder mapping each 'mounted' application
     #
     def application
-      raise ApplicationLoadError, "At least one app must be mounted!" unless self.mounted_apps && self.mounted_apps.any?
+      raise ApplicationLoadError, "At least one app must be mounted!" unless Padrino.mounted_apps && Padrino.mounted_apps.any?
       router = Padrino::Router.new
-      self.mounted_apps.each { |app| app.map_onto(router) }
+      Padrino.mounted_apps.each { |app| app.map_onto(router) }
 
       unless middleware.empty?
         builder = Rack::Builder.new
@@ -85,23 +85,12 @@ module Padrino
       nil
     end
 
-    ##
-    # Returns the used $LOAD_PATHS from padrino
-    #
-    def load_paths
-      %w(
-        lib
-        models
-        shared
-      ).map { |dir| root(dir) }
-    end
-
     ##
     # Return bundle status :+:locked+ if .bundle/environment.rb exist :+:unlocked if Gemfile exist
     # otherwise return nil
     #
     def bundle
-      return :locked   if File.exist?(root('.bundle/environment.rb'))
+      return :locked   if File.exist?(root('Gemfile.lock'))
       return :unlocked if File.exist?(root("Gemfile"))
     end
 

data/lib/padrino-core/application.rb

@@ -8,17 +8,21 @@ module Padrino
   #
   class Application < Sinatra::Base
     register Padrino::Routing   # Support for advanced routing, controllers, url_for
-    register Padrino::Rendering # Support for enhanced rendering with template detection
+    unless defined?(SKIP_PADRINO_RENDERING) && SKIP_PADRINO_RENDERING
+      register Padrino::Rendering # Support for enhanced rendering with template detection
+    end
 
     class << self
 
-      def inherited(subclass) #:nodoc:
+      def inherited(base) #:nodoc:
+        logger.devel "Setup #{base}"
         CALLERS_TO_IGNORE.concat(PADRINO_IGNORE_CALLERS)
-        subclass.default_configuration!
-        Padrino.set_load_paths File.join(subclass.root, "/models")
-        Padrino.require_dependencies File.join(subclass.root, "/models.rb")
-        Padrino.require_dependencies File.join(subclass.root, "/models/**/*.rb")
-        super(subclass) # Loading the subclass inherited method
+        base.default_configuration!
+        Padrino.require_dependencies File.join(base.root, "/models.rb")
+        Padrino.require_dependencies File.join(base.root, "/models/**/*.rb")
+        Padrino.require_dependencies File.join(base.root, "/lib.rb")
+        Padrino.require_dependencies File.join(base.root, "/lib/**/*.rb")
+        super(base) # Loading the subclass inherited method
       end
 
       ##
@@ -47,13 +51,13 @@ module Padrino
       #   MyApp.reload!
       #
       def reload!
+        logger.devel "Reloading #{self}"
+        @_dependencies = nil # Reset dependencies
         reset! # Reset sinatra app
         reset_routes! # Remove all existing user-defined application routes
-        Padrino.require_dependencies(File.join(self.root, "/models.rb")) # Reload models class
-        Padrino.require_dependencies(File.join(self.root, "/models/**/*.rb")) # Reload all models
-        Padrino.require_dependencies(self.app_file) # Reload the app file
+        Padrino.require_dependencies(self.app_file, :force => true) # Reload the app file
+        require_dependencies # Reload dependencies
         register_initializers # Reload our middlewares
-        require_load_paths # Reload dependencies
         default_filters! # Reload filters
         default_errors!  # Reload our errors
         I18n.reload! if defined?(I18n) # Reload also our translations
@@ -89,7 +93,7 @@ module Padrino
       def setup_application!
         return if @_configured
         self.register_initializers
-        self.require_load_paths
+        self.require_dependencies
         self.disable :logging # We need do that as default because Sinatra use commonlogger.
         self.default_filters!
         self.default_routes!
@@ -107,20 +111,30 @@ module Padrino
       #
       def run!(options={})
         return unless Padrino.load!
-        set options
-        handler      = detect_rack_handler
-        handler_name = handler.name.gsub(/.*::/, '')
-        puts "=> #{self.name}/#{Padrino.version} has taken the stage #{Padrino.env} on #{port}" unless handler_name =~/cgi/i
-        handler.run self, :Host => bind, :Port => port do |server|
-          trap(:INT) do
-            ## Use thins' hard #stop! if available, otherwise just #stop
-            server.respond_to?(:stop!) ? server.stop! : server.stop
-            puts "<= #{self.name} has ended his set (crowd applauds)" unless handler_name =~/cgi/i
-          end
-          set :running, true
-        end
-      rescue Errno::EADDRINUSE => e
-        puts "<= Someone is already performing on port #{port}!"
+        Padrino.mount(self.to_s).to("/")
+        Padrino.run!
+      end
+
+      ##
+      # Returns the used $LOAD_PATHS from this application
+      #
+      def load_paths
+        @_load_paths ||= %w(models lib mailers controllers helpers).map { |path| File.join(self.root, path) }
+      end
+
+      ##
+      # Returns default list of path globs to load as dependencies
+      # Appends custom dependency patterns to the be loaded for your Application
+      #
+      # ==== Examples
+      #   MyApp.dependencies << "#{Padrino.root}/uploaders/**/*.rb"
+      #   MyApp.dependencies << Padrino.root('other_app', 'controllers.rb')
+      #
+      def dependencies
+        @_dependencies ||= [
+          "urls.rb", "config/urls.rb", "mailers/*.rb", "mailers.rb",
+          "controllers/**/*.rb", "controllers.rb", "helpers/**/*.rb", "helpers.rb"
+        ].map { |file| Dir[File.join(self.root, file)] }.flatten
       end
 
       protected
@@ -195,23 +209,16 @@ module Padrino
           use Padrino::ShowExceptions         if show_exceptions?
           use Padrino::Logger::Rack, uri_root if Padrino.logger && logging?
           use Padrino::Reloader::Rack         if reload?
-          use Rack::Flash                     if flash?
-        end
-
-        ##
-        # Returns the load_paths for the application (relative to the application root)
-        #
-        def load_paths
-          @load_paths ||= ["urls.rb", "config/urls.rb", "mailers/*.rb", "mailers.rb",
-                           "controllers/**/*.rb", "controllers.rb", "helpers/**/*.rb", "helpers.rb"]
+          use Rack::Flash, :sweep => true     if flash?
         end
 
         ##
         # Requires all files within the application load paths
         #
-        def require_load_paths
-          load_paths.each { |path| Padrino.require_dependencies(File.join(self.root, path)) }
+        def require_dependencies
+          Padrino.set_load_paths(*load_paths)
+          Padrino.require_dependencies(dependencies, :force => true)
         end
     end # self
   end # Application
-end # Padrino
+end # Padrino

data/lib/padrino-core/application/rendering.rb

@@ -17,12 +17,12 @@ module Padrino
     #
     IGNORE_FILE_PATTERN = [
       /~$/ # This is for Gedit
-    ]
+    ] unless defined?(IGNORE_FILE_PATTERN)
 
     ##
     # Default rendering options used in the #render-method
     #
-    DEFAULT_RENDERING_OPTIONS = { :strict_format => false, :raise_exceptions => true }
+    DEFAULT_RENDERING_OPTIONS = { :strict_format => false, :raise_exceptions => true } unless defined?(DEFAULT_RENDERING_OPTIONS)
 
     ##
     # Main class that register this extension
@@ -73,7 +73,7 @@ module Padrino
       end
 
       ##
-      # Retunrs the cached layout path.
+      # Returns the cached layout path.
       #
       def fetch_layout_path(given_layout=nil)
         layout_name = given_layout || @layout || :application
@@ -110,18 +110,25 @@ module Padrino
           # If engine is a hash then render data converted to json
           return engine.to_json if engine.is_a?(Hash)
 
-          # If engine is nil, ignore engine parameter
-          engine, data = data, options if engine.nil? && data
+          # If engine is nil, ignore engine parameter and shift up all arguments
+          # render nil, "index", { :layout => true }, { :localvar => "foo" }
+          engine, data, options = data, options, locals if engine.nil? && data
 
-          # Data can actually be a hash of options in certain render cases
-          options.merge!(data) && data = nil if data.is_a?(Hash)
+          # Data is a hash of options when no engine isn't explicit
+          # render "index", { :layout => true }, { :localvar => "foo" }
+          # Data is options, and options is locals in this case
+          data, options, locals = nil, data, options if data.is_a?(Hash)
 
-          # If an engine is a string then this is a likely a path to be resolved
+          # If data is unassigned then this is a likely a template to be resolved
+          # This means that no engine was explicitly defined
           data, engine = *resolve_template(engine, options) if data.nil?
 
           # Setup root
           root = settings.respond_to?(:root) ? settings.root : ""
 
+          # Use @layout if it exists
+          options[:layout] = @layout if options[:layout].nil?
+
           # Resolve layouts similar to in Rails
           if (options[:layout].nil? || options[:layout] == true) && !settings.templates.has_key?(:layout)
             layout_path, layout_engine = *resolved_layout
@@ -130,7 +137,7 @@ module Padrino
             options[:layout_engine] = layout_engine || engine if options[:layout]
             logger.debug "Resolving layout #{root}/views#{options[:layout]}" if defined?(logger) && options[:layout].present?
           elsif options[:layout].present?
-            options[:layout] = settings.fetch_layout_path(options[:layout])
+            options[:layout] = settings.fetch_layout_path(options[:layout] || @layout)
             logger.debug "Resolving layout #{root}/views#{options[:layout]}" if defined?(logger)
           end
 

data/lib/padrino-core/application/routing.rb

@@ -1,3 +1,5 @@
+$:.unshift '/Users/joshbuddy/Development/http_router/lib'
+
 require 'http_router' unless defined?(HttpRouter)
 require 'padrino-core/support_lite' unless defined?(SupportLite)
 
@@ -18,21 +20,6 @@ class HttpRouter #:nodoc:
     def add_before_filter(filter)
       @before_filters ||= []
       @before_filters << filter
-      arbitrary { |req, params|
-        if req.testing_405?
-          true
-        else
-          old_params = router.runner.params
-          result = catch(:pass) {
-            router.runner.params ||= {}
-            router.runner.params.merge!(params)
-            router.runner.instance_eval(&filter)
-            true
-          } == true
-          router.runner.params = old_params
-          result
-        end
-      }
     end
 
     def add_after_filter(filter)
@@ -64,7 +51,7 @@ module Padrino
   # to the url throughout the application.
   #
   module Routing
-    CONTENT_TYPE_ALIASES = { :htm => :html }
+    CONTENT_TYPE_ALIASES = { :htm => :html } unless defined?(CONTENT_TYPE_ALIASES)
 
     class UnrecognizedException < RuntimeError #:nodoc:
     end
@@ -357,6 +344,7 @@ module Padrino
           # Sinatra defaults
           define_method "#{verb} #{path}", &block
           unbound_method = instance_method("#{verb} #{path}")
+
           block =
             if block.arity != 0
               block_arity = block.arity
@@ -367,6 +355,7 @@ module Padrino
             else
               proc { unbound_method.bind(self).call }
             end
+
           invoke_hook(:route_added, verb, path, block)
 
           # HTTPRouter route construction
@@ -414,44 +403,6 @@ module Padrino
             route.after_filters  = @filters[:after]  || []
           end
 
-          route.arbitrary_with_continue do |req, params|
-            if req.testing_405?
-              req.continue[true]
-            else
-              base = self
-              processed = false
-              router.runner.instance_eval do
-                request.route_obj = route
-                @_response_buffer = nil
-                if path.is_a?(Regexp)
-                  params_list = req.extra_env['router.regex_match'].to_a
-                  params_list.shift
-                  @block_params = params_list
-                  @params.update({:captures => params_list}.merge(@params || {}))
-                else
-                  @block_params = req.params
-                  @params.update(params.merge(@params || {}))
-                end
-                pass_block = catch(:pass) do
-                  # If present set current controller layout
-                  parent_layout = base.instance_variable_get(:@layout)
-                  base.instance_variable_set(:@layout, route.use_layout) if route.use_layout
-                  # 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.
-                  begin
-                    @route = route
-                    @_response_buffer = catch(:halt) { route_eval(&block) }
-                    processed = true
-                  ensure
-                    base.instance_variable_set(:@layout, parent_layout) if route.use_layout
-                    (@_pending_after_filters ||= []).concat(route.after_filters) if route.after_filters
-                  end
-                end
-              end
-              req.continue[processed]
-            end
-          end
           route.to(block)
           route
         end
@@ -603,7 +554,7 @@ module Padrino
 
             # per rfc2616-sec14:
             # Assume */* if no ACCEPT header is given.
-            accepts.delete "*/*"
+            catch_all = (accepts.delete "*/*" || accepts.empty?)
             if accepts.empty?
               matching_types  = mime_types.slice(0,1)
             else
@@ -615,6 +566,9 @@ module Padrino
             elsif !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
+              type = types.first
+              accept_format = CONTENT_TYPE_ALIASES[type] || type
             end
 
             matched_format = types.include?(:any)            ||
@@ -719,9 +673,39 @@ module Padrino
         #
         def route!(base=self.class, pass_block=nil)
           base.router.runner = self
-          if base.router and match = base.router.recognize(@request.env)
+          if base.router and match = base.router.recognize(@request.env) { |match|
+            request.route_obj = match.path.route
+            @_response_buffer = nil
+            if match.path.route.is_a?(HttpRouter::RegexRoute)
+              params_list = match.request.extra_env['router.regex_match'].to_a
+              params_list.shift
+              @block_params = params_list
+              @params.update({:captures => params_list}.merge(@params || {}))
+            else
+              @block_params = match.param_values
+              @params.update(match.params.merge(@params || {}))
+            end
+            parent_layout = @layout
+            @params ||= {}
+            @layout = match.path.route.use_layout if match.path.route.use_layout
+            # 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.
+            begin
+              old_params = @params
+              match.path.route.before_filters.each { |filter| instance_eval(&filter) } if match.path.route.before_filters
+              # If present set current controller layout
+              @route = match.path.route
+              @block_params = @block_params.slice(0, match.path.route.dest.arity) if match.path.route.dest.arity > 0
+              match.acceptance_response = catch(:halt) { route_eval(&match.path.route.dest) } || ''
+            ensure
+              @layout = parent_layout
+              (@_pending_after_filters ||= []).concat(match.path.route.after_filters) if match.path.route.after_filters
+              @params = old_params
+            end
+          }
             if match.respond_to?(:path)
-              throw :halt, @_response_buffer
+              throw :halt, @_response_buffer = match.acceptance_response
             elsif match.respond_to?(:each)
               route_eval do
                 match[1].each {|k,v| response[k] = v}

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

@@ -4,41 +4,18 @@ module Padrino
       class << self
         # Start for the given options a rackup handler
         def start(options)
-          if options.daemonize?
-            stop # Need to stop a process if it exists
-            fork do
-              Process.setsid
-              exit if fork
-              File.umask 0000
-              puts "=> Padrino server has been daemonized with pid #{Process.pid}"
-              STDIN.reopen "/dev/null"
-              STDOUT.reopen "/dev/null", "a"
-              STDERR.reopen STDOUT
-
-              FileUtils.mkdir_p("tmp/pids") unless File.exist?("tmp/pids")
-              pid = "tmp/pids/server.pid"
-
-              if pid
-                File.open(pid, 'w'){ |f| f.write("#{Process.pid}") }
-              end
-
-              Padrino.run!(options.symbolize_keys)
-              exit
-            end
-          else
-            Padrino.run!(options.symbolize_keys)
-          end
+          Padrino.run!(options.symbolize_keys)
         end
 
         # Method that stop (if exist) a running Padrino.application
-        def stop
-          if File.exist?("tmp/pids/server.pid")
-            pid = File.read("tmp/pids/server.pid").to_i
-            print "=> Sending SIGTERM to process with pid #{pid} wait "
-            Process.kill(15, pid) rescue nil
-            1.step(5) { |i| sleep i; print "."; $stdout.flush }
-            File.delete("tmp/pids/server.pid")
-            puts " done."
+        def stop(options)
+          options.symbolize_keys!
+          if File.exist?(options[:pid])
+            pid = File.read(options[:pid]).to_i
+            print "=> Sending INT to process with pid #{pid} wait "
+            Process.kill(2, pid) rescue nil
+          else
+            puts "=> #{options[:pid]} not found!"
           end
         end
       end # self

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

@@ -5,32 +5,31 @@ module Padrino
 
     class Base < Thor
       include Thor::Actions
-      include Thor::RakeCompat
 
       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"
-      method_option :adapter,     :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
-      method_option :host,        :type => :string,  :aliases => "-h", :required => true, :default => "localhost", :desc => "Bind to HOST address"
+      method_option :server,      :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
+      method_option :host,        :type => :string,  :aliases => "-h", :required => true, :default => "0.0.0.0", :desc => "Bind to HOST address"
       method_option :port,        :type => :numeric, :aliases => "-p", :required => true, :default => 3000, :desc => "Use PORT"
       method_option :daemonize,   :type => :boolean, :aliases => "-d", :desc => "Run daemonized in the background"
+      method_option :pid,         :type => :string,  :aliases => "-p", :desc => "File to store pid"
+      method_option :debug,       :type => :boolean,                   :desc => "Set debugging flags"
       def start
         prepare :start
-        require File.expand_path(File.dirname(__FILE__) + "/adapter")
+        require File.expand_path("../adapter", __FILE__)
         require File.expand_path('config/boot.rb')
         Padrino::Cli::Adapter.start(options)
       end
 
-      desc "s", "Starts the Padrino application"
-      alias :s :start
-
       desc "stop", "Stops the Padrino application"
+      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(File.dirname(__FILE__) + "/adapter")
-        Padrino::Cli::Adapter.stop
+        require File.expand_path("../adapter", __FILE__)
+        Padrino::Cli::Adapter.stop(options)
       end
 
       desc "rake", "Execute rake tasks"
@@ -48,21 +47,21 @@ module Padrino
         ARGV.concat(args)
         puts "=> Executing Rake #{ARGV.join(' ')} ..."
         ENV['PADRINO_LOG_LEVEL'] ||= "test"
-        require File.expand_path(File.dirname(__FILE__) + '/rake')
+        load File.expand_path('../rake.rb', __FILE__)
         silence(:stdout) { require File.expand_path('config/boot.rb') }
-        PadrinoTasks.init
+        PadrinoTasks.init(true)
       end
 
       desc "console", "Boots up the Padrino application irb console"
       def console
         prepare :console
-        require File.expand_path(File.dirname(__FILE__) + "/../version")
+        require File.expand_path("../../version", __FILE__)
         ARGV.clear
         puts "=> Loading #{options.environment} console (Padrino v.#{Padrino.version})"
         require 'irb'
         require "irb/completion"
         require File.expand_path('config/boot.rb')
-        require File.expand_path(File.dirname(__FILE__) + '/console')
+        require File.expand_path('../console', __FILE__)
         IRB.start
       end
 
@@ -139,4 +138,4 @@ module Padrino
         alias :silence :capture
     end # Base
   end # Cli
-end # Padrino
+end # Padrino