padrino-core 0.9.29 → 0.10.0

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

@@ -15,7 +15,7 @@ module Padrino
       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 :pid,         :type => :string,  :aliases => "-i", :desc => "File to store pid"
       method_option :debug,       :type => :boolean,                   :desc => "Set debugging flags"
       def start
         prepare :start
@@ -24,6 +24,11 @@ module Padrino
         Padrino::Cli::Adapter.start(options)
       end
 
+      desc "s", "Starts the Padrino application"
+      def s
+        invoke :start
+      end
+
       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
@@ -80,10 +85,16 @@ module Padrino
           puts "<= You need padrino-gen! Run: gem install padrino-gen"
         end
       end
+
       desc "g", "Executes the Padrino generator with given options."
-      alias :g :generate
+      def g(*args)
+        invoke(:generate, args)
+      end
+
       desc "gen", "Executes the Padrino generator with given options."
-      alias :gen :generate
+      def gen(*args)
+        invoke(:generate, args)
+      end
 
       desc "version", "Show current Padrino Version"
       map "-v" => :version, "--version" => :version
@@ -138,4 +149,4 @@ module Padrino
         alias :silence :capture
     end # Base
   end # Cli
-end # Padrino
+end # Padrino

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

@@ -56,4 +56,4 @@ task :gen do
       PadrinoTasks.init
     RUBY
   end
-end
+end

data/lib/padrino-core/loader.rb

@@ -49,7 +49,7 @@ module Padrino
       @_called_from = first_caller
       Padrino.set_encoding
       Padrino.set_load_paths(*load_paths) # We set the padrino load paths
-      Padrino.logger # Initialize our logger
+      Padrino::Logger.setup! # Initialize our logger
       Padrino.require_dependencies("#{root}/config/database.rb", :nodeps => true) # Be sure to don't remove constants from dbs.
       Padrino::Reloader.lock! # Now we can remove constant from here to down
       Padrino.before_load.each(&:call) # Run before hooks

data/lib/padrino-core/locale/hu.yml

@@ -0,0 +1,30 @@
+hu:
+  date:
+    formats:
+      # Use the strftime parameters for formats.
+      # When no format has been given, it uses default.
+      # You can provide other formats here if you like!
+      default: "%Y-%m-%d"
+      short: "%b. %d."
+      long: "%Y. %B %d."
+
+    day_names: [vasárnap, hétfő, kedd, szerda, csütörtök, péntek, szombat]
+    abbr_day_names: [vas, hét, kedd, sze, csüt, pén, szo]
+    month_names: [~, január, február, március, április, május, június, július, augusztus, szeptember, oktober, november, december]
+    abbr_month_names: [~, jan, febr, márc, ápr, máj, jún, júl, aug, szept, okt, nov, dec]
+    order: [ :year, :month, :day ]
+
+  time:
+    formats:
+      default: "%Y. %B %d. %H:%M:%S %z, %A"
+      short: "%B %d. %H:%M"
+      long: "%Y. %B %d. %H:%M"
+    am: "de"
+    pm: "du"
+
+# Used in array.to_sentence.
+  support:
+    array:
+      words_connector: ", "
+      two_words_connector: " és "
+      last_word_connector: " és "

data/lib/padrino-core/logger.rb

@@ -12,7 +12,8 @@ module Padrino
   #   logger.warn "bar"
   #
   def self.logger
-    Thread.current[:padrino_logger] ||= Padrino::Logger.setup!
+    Padrino::Logger.setup! if Thread.current[:padrino_logger].nil?
+    Thread.current[:padrino_logger]
   end
 
   ##

data/lib/padrino-core/mounter.rb

@@ -85,8 +85,8 @@ module Padrino
     def named_routes
       app_obj.routes.map { |route|
         name_array     = "(#{route.named.to_s.split("_").map { |piece| %Q[:#{piece}] }.join(", ")})"
-        request_method = route.as_options[:conditions][:request_method][0]
-        full_path = File.join(self.uri_root, route.path)
+        request_method = route.conditions[:request_method][0]
+        full_path = File.join(uri_root, route.original_path)
         next if route.named.blank? || request_method == 'HEAD'
         OpenStruct.new(:verb => request_method, :identifier => route.named, :name => name_array, :path => full_path)
       }.compact

data/lib/padrino-core/reloader.rb

@@ -13,7 +13,7 @@ module Padrino
     # only when explicitly invoked.
     #
     MTIMES          = {}
-    FILES_LOADED    = {}
+    LOADED_FILES    = {}
     LOADED_CLASSES  = {}
 
     class << self
@@ -52,7 +52,7 @@ module Padrino
           # We skip to next file if it is not new and not modified
           next unless new_file || mtime > previous_mtime
           # Now we can reload our file
-          apps = get_apps(file)
+          apps = mounted_apps_of(file)
           if apps.present?
             apps.each { |app| app.app_obj.reload! }
           else
@@ -74,7 +74,7 @@ module Padrino
           klasses.each { |klass| remove_constant(klass) }
           LOADED_CLASSES.delete(file)
         end
-        FILES_LOADED.each do |file, dependencies|
+        LOADED_FILES.each do |file, dependencies|
           dependencies.each { |dependency| $LOADED_FEATURES.delete(dependency) }
           $LOADED_FEATURES.delete(file)
         end
@@ -109,6 +109,7 @@ module Padrino
       def safe_load(file, options={})
         force, file = options[:force], figure_path(file)
 
+        # Check if file was changed or if force a reload
         reload = MTIMES[file] && File.mtime(file) > MTIMES[file]
         return if !force && !reload && MTIMES[file]
 
@@ -117,22 +118,47 @@ module Padrino
           klasses.each { |klass| remove_constant(klass) }
         end
 
-        # Duplicate objects and loaded features in the file
+        # Remove all loaded fatures with our file
+        if features = LOADED_FILES[file]
+          features.each { |feature| $LOADED_FEATURES.delete(feature) }
+        end
+
+        # Duplicate objects and loaded features before load file
         klasses = ObjectSpace.classes.dup
+        files   = $LOADED_FEATURES.dup
+
+        # Now we can reload dependencies of our file
+        if features = LOADED_FILES.delete(file)
+          features.each { |feature| safe_load(feature, :force => true) }
+        end
 
-        # And finally reload the specified file
+        # And finally load the specified file
         begin
-          logger.devel "Loading #{file}#{' with force' if force}" if !reload
-          logger.debug "Reloading #{file}" if reload
+          logger.devel "Loading #{file}"   if !reload
+          logger.debug "Reloading #{file}" if  reload
           $LOADED_FEATURES.delete(file)
+          verbosity_was, $-v = $-v, nil
+          loaded = false
           require(file)
+          loaded = true
           MTIMES[file] = File.mtime(file)
-        rescue SyntaxError => ex
-          logger.error "Cannot require #{file} because of syntax error: #{ex.message}"
-        end
+        rescue SyntaxError => e
+          logger.error "Cannot require #{file} because of syntax error: #{e.message}"
+        ensure
+          $-v = verbosity_was
+          new_constants = (ObjectSpace.classes - klasses).uniq
+          if loaded
+            # Store the file details
+            LOADED_CLASSES[file] = new_constants
+            LOADED_FILES[file]   = ($LOADED_FEATURES - files - [file]).uniq
+            # Track only features in our Padrino.root
+            LOADED_FILES[file].delete_if { |feature| !in_root?(feature) }
+          else
+            logger.devel "Failed to load #{file}; removing partially defined constants"
+            new_constants.each { |klass| remove_constant(klass) }
+          end
 
-        # Store the file details after successful loading
-        LOADED_CLASSES[file] ||= (ObjectSpace.classes - klasses).uniq
+        end
       end
 
       ##
@@ -151,26 +177,36 @@ module Padrino
       # Removes the specified class and constant.
       #
       def remove_constant(const)
-        return if Padrino::Reloader.exclude_constants.any? { |base| (const.to_s =~ %r{^#{base}}) } &&
-                 !Padrino::Reloader.include_constants.any? { |base| (const.to_s =~ %r{^#{base}}) }
+        return if exclude_constants.compact.uniq.any? { |c| (const.to_s =~ %r{^#{Regexp.escape(c)}}) } &&
+                 !include_constants.compact.uniq.any? { |c| (const.to_s =~ %r{^#{Regexp.escape(c)}}) }
         begin
           parts  = const.to_s.split("::")
           base   = parts.size == 1 ? Object : parts[0..-2].join("::").constantize
           object = parts[-1].to_s
-          logger.devel "Remove constant: #{const}"
           base.send(:remove_const, object)
+          logger.devel "Removed constant: #{const}"
         rescue NameError; end
       end
 
       private
         ##
-        # Return the mounted_app providing the app location
+        # Return the mounted_apps providing the app location
+        # Can be an array because in one app.rb we can define multiple Padrino::Appplications
         #
-        def get_apps(file)
+        def mounted_apps_of(file)
           file = figure_path(file)
           Padrino.mounted_apps.find_all { |app| File.identical?(file, app.app_file) }
         end
 
+        ##
+        # Returns true if file is in our Padrino.root
+        #
+        def in_root?(file)
+          # This is better but slow:
+          #   Pathname.new(Padrino.root).find { |f| File.identical?(Padrino.root(f), figure_path(file)) }
+          figure_path(file) =~ %r{^#{Regexp.escape(Padrino.root)}}
+        end
+
         ##
         # Searches Ruby files in your +Padrino.load_paths+ , Padrino::Application.load_paths
         # and monitors them for any changes.
@@ -178,10 +214,10 @@ module Padrino
         def rotation
           files  = Padrino.load_paths.map { |path| Dir["#{path}/**/*.rb"] }.flatten
           files  = files | Padrino.mounted_apps.map { |app| app.app_file }
-          files  = files | Padrino.mounted_apps.map { |app| app.app_obj.dependencies  }.flatten
+          files  = files | Padrino.mounted_apps.map { |app| app.app_obj.dependencies }.flatten
           files.uniq.map { |file|
             file = File.expand_path(file)
-            next if Padrino::Reloader.exclude.any? { |base| file =~ %r{^#{base}} } || !File.exist?(file)
+            next if Padrino::Reloader.exclude.any? { |base| file =~ %r{^#{Regexp.escape(base)}} } || !File.exist?(file)
             yield(file, File.mtime(file))
           }.compact
         end
@@ -193,23 +229,17 @@ module Padrino
     # during which no further action will be taken.
     #
     class Rack
-      def initialize(app, cooldown = 1)
+      def initialize(app, cooldown=1)
         @app = app
         @cooldown = cooldown
         @last = (Time.now - cooldown)
       end
 
       def call(env)
-        if @cooldown and Time.now > @last + @cooldown
-          if Thread.list.size > 1
-            Thread.exclusive { Padrino.reload! }
-          else
-            Padrino.reload!
-          end
-
+        if @cooldown && Time.now > @last + @cooldown
+          Thread.list.size > 1 ? Thread.exclusive { Padrino.reload! } : Padrino.reload!
           @last = Time.now
         end
-
         @app.call(env)
       end
     end

data/lib/padrino-core/server.rb

@@ -6,7 +6,7 @@ module Padrino
   # ==== Examples
   #
   #   Padrino.run! # with these defaults => host: "localhost", port: "3000", adapter: the first found
-  #   Padrino.run!("localhost", "4000", "mongrel") # use => host: "localhost", port: "3000", adapter: "mongrel"
+  #   Padrino.run!("localhost", "4000", "mongrel") # use => host: "0.0.0.0", port: "3000", adapter: "mongrel"
   #
   def self.run!(options={})
     Padrino.load!
@@ -23,8 +23,8 @@ module Padrino
     def self.start(app, opts={})
       options = {}.merge(opts) # We use a standard hash instead of Thor::CoreExt::HashWithIndifferentAccess
       options.symbolize_keys!
-      options[:Host] = options.delete(:host)
-      options[:Port] = options.delete(:port)
+      options[:Host] = options.delete(:host) || '0.0.0.0'
+      options[:Port] = options.delete(:port) || 3000
       options[:AccessLog] = []
       if options[:daemonize]
         options[:pid] = options[:pid].blank? ? File.expand_path('tmp/pids/server.pid') : opts[:pid]

data/lib/padrino-core/support_lite.rb

@@ -1,26 +1,89 @@
 ##
 # This file loads certain extensions required by Padrino from ActiveSupport.
 #
-require 'active_support/core_ext/string/conversions'        unless String.method_defined?(:to_date)
-require 'active_support/core_ext/kernel'                    unless Kernel.method_defined?(:silence_warnings)
-require 'active_support/core_ext/module'                    unless Module.method_defined?(:alias_method_chain)
-require 'active_support/core_ext/class/attribute_accessors' unless Class.method_defined?(:cattr_reader)
-require 'active_support/core_ext/hash/keys'                 unless Hash.method_defined?(:symbolize_keys!)
-require 'active_support/core_ext/hash/deep_merge'           unless Hash.method_defined?(:deep_merge)
-require 'active_support/core_ext/hash/reverse_merge'        unless Hash.method_defined?(:reverse_merge)
-require 'active_support/core_ext/hash/slice'                unless Hash.method_defined?(:slice)
-require 'active_support/core_ext/object/blank'              unless Object.method_defined?(:present?)
-require 'active_support/core_ext/array'                     unless Array.method_defined?(:from)
-require 'active_support/ordered_hash'                       unless defined?(ActiveSupport::OrderedHash)
-require 'active_support/inflector'                          unless String.method_defined?(:humanize)
-require 'active_support/core_ext/float/rounding'            unless Float.method_defined?(:round)
-require 'active_support/option_merger'                      unless defined?(ActiveSupport::OptionMerger)
-require 'active_support/core_ext/object/with_options'       unless Object.method_defined?(:with_options)
+require 'active_support/core_ext/kernel'                    # silence_warnings
+require 'active_support/core_ext/module/aliasing'           # alias_method_chain
+require 'active_support/core_ext/class/attribute_accessors' # cattr_reader
+require 'active_support/core_ext/hash/keys'                 # symbolize_keys
+require 'active_support/core_ext/hash/reverse_merge'        # reverse_merge
+require 'active_support/core_ext/hash/slice'                # slice
+require 'active_support/core_ext/object/blank'              # present?
+require 'active_support/core_ext/array/extract_options'     # extract_options
+require 'active_support/inflector/methods'                  # constantize
+require 'active_support/inflector/inflections'              # pluralize
+require 'active_support/inflections'                        # load default inflections
 
 ##
-# Used to know if this file has already been required
+# This is a small version of active_support/core_ext/string/inflections.rb
+# to prevent to load a lot of dependencies including I18n gem
+#
+# Issue: https://github.com/rails/rails/issues/1526
 #
-module SupportLite; end
+class String
+  # Returns the plural form of the word in the string.
+  #
+  #   "post".pluralize             # => "posts"
+  #   "octopus".pluralize          # => "octopi"
+  #   "sheep".pluralize            # => "sheep"
+  #   "words".pluralize            # => "words"
+  #   "the blue mailman".pluralize # => "the blue mailmen"
+  #   "CamelOctopus".pluralize     # => "CamelOctopi"
+  def pluralize
+    ActiveSupport::Inflector.pluralize(self)
+  end
+
+  # +constantize+ tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize # => Module
+  #   "Class".constantize  # => Class
+  def constantize
+    ActiveSupport::Inflector.constantize(self)
+  end
+
+  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
+  # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
+  #
+  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+  #
+  #   "active_record".camelize                # => "ActiveRecord"
+  #   "active_record".camelize(:lower)        # => "activeRecord"
+  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+  def camelize(first_letter = :upper)
+    case first_letter
+      when :upper then ActiveSupport::Inflector.camelize(self, true)
+      when :lower then ActiveSupport::Inflector.camelize(self, false)
+    end
+  end
+  alias_method :camelcase, :camelize
+
+  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+  #
+  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
+  #
+  #   "ActiveRecord".underscore         # => "active_record"
+  #   "ActiveRecord::Errors".underscore # => active_record/errors
+  def underscore
+    ActiveSupport::Inflector.underscore(self)
+  end
+
+  # Create a class name from a plural table name like Rails does for table names to models.
+  # Note that this returns a string and not a class. (To convert to an actual class
+  # follow +classify+ with +constantize+.)
+  #
+  #   "egg_and_hams".classify # => "EggAndHam"
+  #   "posts".classify        # => "Post"
+  #
+  # Singular names are not handled correctly.
+  #
+  #   "business".classify # => "Busines"
+  def classify
+    ActiveSupport::Inflector.classify(self)
+  end
+end
 
 module ObjectSpace
   class << self
@@ -64,4 +127,9 @@ YAML::ENGINE.yamler = "syck" if defined?(YAML::ENGINE)
 ##
 # Loads our locale configuration files
 #
-I18n.load_path += Dir["#{File.dirname(__FILE__)}/locale/*.yml"] if defined?(I18n)
+I18n.load_path += Dir["#{File.dirname(__FILE__)}/locale/*.yml"] if defined?(I18n)
+
+##
+# Used to know if this file has already been required
+#
+module SupportLite; end

data/lib/padrino-core/version.rb

@@ -5,7 +5,7 @@
 # without include full padrino core.
 #
 module Padrino
-  VERSION = '0.9.29' unless defined?(Padrino::VERSION)
+  VERSION = '0.10.0' unless defined?(Padrino::VERSION)
   ##
   # Return the current Padrino version
   #

data/padrino-core.gemspec

@@ -1,4 +1,6 @@
-# -*- encoding: utf-8 -*-
+#!/usr/bin/env gem build
+# encoding: utf-8
+
 require File.expand_path("../lib/padrino-core/version.rb", __FILE__)
 
 Gem::Specification.new do |s|
@@ -20,14 +22,17 @@ Gem::Specification.new do |s|
   s.require_paths = ["lib"]
   s.rdoc_options  = ["--charset=UTF-8"]
 
-
   # TODO remove after a couple versions
-  s.post_install_message = "\e[32m  When upgrading, please 'enable :sessions' for each application"
-  s.post_install_message << " as shown here:\e[0m http://bit.ly/kODKMx"
+  s.post_install_message = "\e[32m" + ("*" * 20)
+  s.post_install_message << "\n UPGRADE NOTES\n\n\e[31m When upgrading, please 'enable :sessions' for each application"
+  s.post_install_message << " as shown here:\e[0m http://bit.ly/kODKMx\n"
+  s.post_install_message << "\e[31m When upgrading, please 'register Padrino::Rendering' for each application"
+  s.post_install_message << " as shown here:\e[0m https://gist.github.com/1d36a35794dbbd664ea4"
+  s.post_install_message << "\n\e[32m" + ("*" * 20) + "\n\e[0m"
 
   s.add_dependency("tilt", "~> 1.3.0")
   s.add_dependency("sinatra", "~> 1.2.6")
-  s.add_dependency("http_router", "~> 0.7.8")
-  s.add_dependency("thor", ">=0.14.3")
-  s.add_dependency("activesupport", ">= 3.0.0")
+  s.add_dependency("http_router", "~> 0.8.10")
+  s.add_dependency("thor", "~> 0.14.3")
+  s.add_dependency("activesupport", "~> 3.0.0")
 end