middleman-core 3.0.0.beta.1 → 3.0.0.beta.2

data/lib/middleman-core/vendor/{padrino-core-0.10.5 → padrino-core-0.10.6}/lib/padrino-core/logger.rb

@@ -1,10 +1,10 @@
 # Defines the log level for a Padrino project.
 PADRINO_LOG_LEVEL = ENV['PADRINO_LOG_LEVEL'] unless defined?(PADRINO_LOG_LEVEL)
+
 # Defines the logger used for a Padrino project.
-PADRINO_LOGGER    = ENV['PADRINO_LOGGER'] unless defined?(PADRINO_LOGGER)
+PADRINO_LOGGER = ENV['PADRINO_LOGGER'] unless defined?(PADRINO_LOGGER)
 
 module Padrino
-
   ##
   # @return [Padrino::Logger]
   #
@@ -35,21 +35,14 @@ module Padrino
   #   Padrino.logger = Buffered.new(STDOUT)
   #
   def self.logger=(value)
+    value.extend(Padrino::Logger::Extensions) unless (Padrino::Logger::Extensions === value)
     Thread.current[:padrino_logger] = value
   end
 
   ##
-  # Extensions to the built in Ruby logger.
+  # Padrinos internal logger, using all of Padrino log extensions.
   #
   class Logger
-
-    attr_accessor :level
-    attr_accessor :auto_flush
-    attr_reader   :buffer
-    attr_reader   :log
-    attr_reader   :init_args
-    attr_accessor :log_static
-
     ##
     # Ruby (standard) logger levels:
     #
@@ -58,6 +51,7 @@ module Padrino
     # :warn:: A warning
     # :info:: generic (useful) information about system operation
     # :debug:: low-level information for developers
+    # :devel:: Development-related information that is unnecessary in debug mode
     #
     Levels = {
       :fatal =>  7,
@@ -68,6 +62,161 @@ module Padrino
       :devel => -1,
     } unless const_defined?(:Levels)
 
+    module Extensions
+      ##
+      # Generate the logging methods for {Padrino.logger} for each log level.
+      #
+      Padrino::Logger::Levels.each_pair do |name, number|
+        define_method(name) do |*args|
+          return if number < level
+          if args.size > 1
+            bench(args[0], args[1], args[2], name)
+          else
+            push(args * '', name)
+          end
+        end
+
+        define_method(:"#{name}?") do
+          number >= level
+        end
+      end
+
+      ##
+      # Append a to development logger a given action with time
+      #
+      # @param [string] action
+      #   The action
+      #
+      # @param [float] time
+      #   Time duration for the given action
+      #
+      # @param [message] string
+      #   The message that you want to log
+      #
+      # @example
+      #   logger.bench 'GET', started_at, '/blog/categories'
+      #   # => DEBUG - GET (0.056ms) - /blog/categories
+      #
+      def bench(action, began_at, message, level=:debug, color=:yellow)
+        @_pad  ||= 8
+        @_pad    = action.to_s.size if action.to_s.size > @_pad
+        duration = Time.now - began_at
+        color    = :red if duration > 1
+        action   = colorize(action.to_s.upcase.rjust(@_pad), color)
+        duration = colorize('%0.4fms' % duration, :bold, color)
+        push "#{action} (#{duration}) #{message}", level
+      end
+
+      ##
+      # Appends a message to the log. The methods yield to an optional block and
+      # the output of this block will be appended to the message.
+      #
+      # @param [String] message
+      #   The message that you want write to your stream
+      #
+      # @param [String] level
+      #   The level one of :debug, :warn etc...
+      #
+      #
+      def push(message = nil, level = nil)
+        add(Padrino::Logger::Levels[level], format(message, level))
+      end
+
+      ##
+      # Formats the log message. This method is a noop and should be implemented by other
+      # logger components such as {Padrino::Logger}.
+      #
+      # @param [String] message
+      #   The message to format
+      #
+      # @param [String,Symbol] level
+      #   The log level, one of :debug, :warn...
+      def format(message, level)
+        message
+      end
+
+      ##
+      # The debug level, with some style added. May be reimplemented.
+      #
+      # @example
+      #   stylized_level(:debug) => DEBUG
+      #
+      # @param [String,Symbol] level
+      #   The log level
+      #
+      def stylized_level(level)
+        level.to_s.upcase.rjust(7)
+      end
+
+      ##
+      # Colorizes a string for colored console output. This is a noop and can be reimplemented
+      # to colorize the string as needed.
+      #
+      # @see
+      #   ColorizedLogger
+      #
+      # @param [string]
+      #   The string to be colorized.
+      #
+      # @param [Array<Symbol>]
+      #   The colors to use. Should be applied in the order given.
+      def colorize(string, *colors)
+        string
+      end
+
+      ##
+      # Turns a logger with LoggingExtensions into a logger with colorized output.
+      #
+      # @example
+      #   Padrino.logger = Logger.new($stdout)
+      #   Padrino.logger.colorize!
+      #   Padrino.logger.debug("Fancy Padrino debug string")
+      def colorize!
+        self.extend(Colorize)
+      end
+    end
+
+    module Colorize
+      # Colors for levels
+      ColoredLevels = {
+        :fatal => [:bold, :red],
+        :error => [:red],
+        :warn  => [:yellow],
+        :info  => [:green],
+        :debug => [:cyan],
+        :devel => [:magenta]
+      } unless defined?(ColoredLevels)
+
+      ##
+      # Colorize our level
+      #
+      # @param [String, Symbol] level
+      #
+      # @see Padrino::Logging::ColorizedLogger::ColoredLevels
+      #
+      def colorize(string, *colors)
+        colors.each do |c|
+          string = string.send(c)
+        end
+        string
+      end
+
+      def stylized_level(level)
+        style = ColoredLevels[level].map { |c| "\e[%dm" % String.colors[c] } * ''
+        [style, super, "\e[0m"] * ''
+      end
+    end
+
+    include Extensions
+    include Colorize
+
+    attr_accessor :level
+    attr_accessor :auto_flush
+    attr_reader   :buffer
+    attr_reader   :log
+    attr_reader   :init_args
+    attr_accessor :log_static
+
     @@mutex = {}
 
     ##
@@ -110,16 +259,6 @@ module Padrino
     }
     Config.merge!(PADRINO_LOGGER) if PADRINO_LOGGER
 
-    # Colors for levels
-    ColoredLevels = {
-      :fatal => [:bold, :red],
-      :error => [:red],
-      :warn  => [:yellow],
-      :info  => [:green],
-      :debug => [:cyan],
-      :devel => [:magenta]
-    } unless defined?(ColoredLevels)
-
     ##
     # Setup a new logger
     #
@@ -137,13 +276,14 @@ module Padrino
 
       stream = case config[:stream]
         when :to_file
-          FileUtils.mkdir_p(Padrino.root("log")) unless File.exists?(Padrino.root("log"))
-          File.new(Padrino.root("log", "#{Padrino.env}.log"), "a+")
+          FileUtils.mkdir_p(Padrino.root('log')) unless File.exists?(Padrino.root('log'))
+          File.new(Padrino.root('log', "#{Padrino.env}.log"), 'a+')
         when :null   then StringIO.new
         when :stdout then $stdout
         when :stderr then $stderr
         else config[:stream] # return itself, probabilly is a custom stream.
       end
+
       Thread.current[:padrino_logger] = Padrino::Logger.new(config.merge(:stream => stream))
     end
 
@@ -174,7 +314,7 @@ module Padrino
     def initialize(options={})
       @buffer          = []
       @auto_flush      = options.has_key?(:auto_flush) ? options[:auto_flush] : true
-      @level           = options[:log_level] ? Levels[options[:log_level]] : Levels[:debug]
+      @level           = options[:log_level] ? Padrino::Logger::Levels[options[:log_level]] : Padrino::Logger::Levels[:debug]
       @log             = options[:stream]  || $stdout
       @log.sync        = true
       @mutex           = @@mutex[@log] ||= Mutex.new
@@ -183,18 +323,6 @@ module Padrino
       @log_static      = options.has_key?(:log_static) ? options[:log_static] : false
     end
 
-    ##
-    # Colorize our level
-    #
-    # @param [String, Symbol] level
-    #
-    # @see Padrino::Logger::ColoredLevels
-    #
-    def colored_level(level)
-      style = ColoredLevels[level].map { |c| "\e[%dm" % String.colors[c] } * ''
-      [style, level.to_s.upcase.rjust(7), "\e[0m"] * ''
-    end
-
     ##
     # Flush the entire buffer to the log object.
     #
@@ -217,42 +345,11 @@ module Padrino
     end
 
     ##
-    # Appends a message to the log. The methods yield to an optional block and
-    # the output of this block will be appended to the message.
-    #
-    # @param [String] message
-    #   The message that you want write to your stream
+    # Adds a message to the log - for compatibility with other loggers.
     #
-    # @param [String] level
-    #   The level one of :debug, :warn etc...
-    #
-    #
-    def push(message = nil, level = nil)
-      write @format_message % [colored_level(level), Time.now.strftime(@format_datetime).yellow, message.to_s.strip]
-    end
-
-    ##
-    # Append a to development logger a given action with time
-    #
-    # @param [string] action
-    #   The action
-    #
-    # @param [float] time
-    #   Time duration for the given action
-    #
-    # @param [message] string
-    #   The message that you want to log
-    #
-    # @example
-    #   logger.bench 'GET', started_at, '/blog/categories'
-    #   # => DEBUG - GET (0.056ms) - /blog/categories
-    #
-    def bench(action, began_at, message, level=:debug, color=:yellow)
-      @_pad  ||= 8
-      @_pad    = action.to_s.size if action.to_s.size > @_pad
-      duration = Time.now - began_at
-      color    = :red if duration > 1
-      push "%s (" % action.to_s.upcase.rjust(@_pad).send(color) + "%0.4fms".bold.send(color) % duration + ") %s" % message.to_s, level
+    # @private
+    def add(level, message = nil)
+      write(message)
     end
 
     ##
@@ -269,22 +366,8 @@ module Padrino
     end
     alias :write :<<
 
-    ##
-    # Generate the logging methods for {Padrino.logger} for each log level.
-    #
-    Levels.each_pair do |name, number|
-      define_method(name) do |*args|
-        return if number < level
-        if args.size > 1
-          bench(*args)
-        else
-          push(args * '', name)
-        end
-      end
-
-      define_method(:"#{name}?") do
-        number >= level
-      end
+    def format(message, level)
+      @format_message % [stylized_level(level), colorize(Time.now.strftime(@format_datetime), :yellow), message.to_s.strip]
     end
 
     ##
@@ -301,7 +384,6 @@ module Padrino
 
       def call(env) # @private
         env['rack.logger'] = Padrino.logger
-        env['rack.errors'] = Padrino.logger.log
         began_at = Time.now
         status, header, body = @app.call(env)
         log(env, status, header, began_at)
@@ -309,28 +391,28 @@ module Padrino
       end
 
       private
-        def log(env, status, header, began_at)
-          return if env['sinatra.static_file'] and !logger.log_static
-          logger.bench(
-            env["REQUEST_METHOD"],
-            began_at,
-            [
-              @uri_root.to_s,
-              env["PATH_INFO"],
-              env["QUERY_STRING"].empty? ? "" : "?" + env["QUERY_STRING"],
-              ' - ',
-              status.to_s[0..3].bold,
-              ' ',
-              code_to_name(status)
-            ] * '',
-            :debug,
-            :magenta
-          )
-        end
+      def log(env, status, header, began_at)
+        return if env['sinatra.static_file'] && (!logger.respond_to?(:log_static) || !logger.log_static)
+        logger.bench(
+          env["REQUEST_METHOD"],
+          began_at,
+          [
+            @uri_root.to_s,
+            env["PATH_INFO"],
+            env["QUERY_STRING"].empty? ? "" : "?" + env["QUERY_STRING"],
+            ' - ',
+            logger.colorize(status.to_s[0..3], :bold),
+            ' ',
+            code_to_name(status)
+          ] * '',
+          :debug,
+          :magenta
+        )
+      end
 
-        def code_to_name(status)
-          ::Rack::Utils::HTTP_STATUS_CODES[status.to_i] || ''
-        end
+      def code_to_name(status)
+        ::Rack::Utils::HTTP_STATUS_CODES[status.to_i] || ''
+      end
     end # Rack
   end # Logger
 end # Padrino
@@ -343,3 +425,4 @@ module Kernel # @private
     Padrino.logger
   end
 end # Kernel
+

data/lib/middleman-core/vendor/{padrino-core-0.10.5 → padrino-core-0.10.6}/lib/padrino-core/reloader.rb

@@ -92,7 +92,7 @@ module Padrino
         changed = false
         rotation do |file, mtime|
           new_file = MTIMES[file].nil?
-          previous_mtime = MTIMES[file] ||= mtime
+          previous_mtime = MTIMES[file]
           changed = true if new_file || mtime > previous_mtime
         end
         changed
@@ -103,7 +103,7 @@ module Padrino
       # We lock dependencies sets to prevent reloading of protected constants
       #
       def lock!
-        klasses = ObjectSpace.classes.map { |klass| klass.name.to_s.split("::")[0] }.uniq
+        klasses = ObjectSpace.classes.map { |klass| klass.name.split('::')[0] }.uniq
         klasses = klasses | Padrino.mounted_apps.map { |app| app.app_class }
         Padrino::Reloader.exclude_constants.concat(klasses)
       end
@@ -183,50 +183,50 @@ module Padrino
       # Removes the specified class and constant.
       #
       def remove_constant(const)
-        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)}}) }
+        return if exclude_constants.compact.uniq.any? { |c| const.name.index(c) == 0 } &&
+                 !include_constants.compact.uniq.any? { |c| const.name.index(c) == 0 }
         begin
-          parts  = const.to_s.split("::")
-          base   = parts.size == 1 ? Object : parts[0..-2].join("::").constantize
-          object = parts[-1].to_s
-          base.send(:remove_const, object)
-          logger.devel "Removed constant: #{const}"
+          parts  = const.to_s.sub(/^::(Object)?/, 'Object::').split('::')
+          object = parts.pop
+          base   = parts.empty? ? Object : Inflector.constantize(parts * '::')
+          base.send :remove_const, object
+          logger.devel "Removed constant: #{const} from #{base}"
         rescue NameError; end
       end
 
       private
-        ##
-        # Return the mounted_apps providing the app location
-        # Can be an array because in one app.rb we can define multiple Padrino::Appplications
-        #
-        def mounted_apps_of(file)
-          file = figure_path(file)
-          Padrino.mounted_apps.find_all { |app| File.identical?(file, app.app_file) }
-        end
+      ##
+      # Return the mounted_apps providing the app location
+      # Can be an array because in one app.rb we can define multiple Padrino::Appplications
+      #
+      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
+      ##
+      # 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).index(Padrino.root) == 0
+      end
 
-        ##
-        # Searches Ruby files in your +Padrino.load_paths+ , Padrino::Application.load_paths
-        # and monitors them for any changes.
-        #
-        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.uniq.map { |file|
-            file = File.expand_path(file)
-            next if Padrino::Reloader.exclude.any? { |base| file =~ %r{^#{Regexp.escape(base)}} } || !File.exist?(file)
-            yield(file, File.mtime(file))
-          }.compact
-        end
+      ##
+      # Searches Ruby files in your +Padrino.load_paths+ , Padrino::Application.load_paths
+      # and monitors them for any changes.
+      #
+      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.uniq.map do |file|
+          file = File.expand_path(file)
+          next if Padrino::Reloader.exclude.any? { |base| file.index(base) == 0 } || !File.exist?(file)
+          yield file, File.mtime(file)
+        end.compact
+      end
     end # self
 
     ##

data/lib/middleman-core/vendor/{padrino-core-0.10.5 → padrino-core-0.10.6}/lib/padrino-core/server.rb

@@ -17,7 +17,7 @@ module Padrino
   #
   class Server < Rack::Server
     # Server Handlers
-    Handlers = [:thin, :mongrel, :webrick]
+    Handlers = [:thin, :mongrel, :trinidad, :webrick]
 
     # Starts the application on the available server with specified options.
     def self.start(app, opts={})
@@ -44,7 +44,7 @@ module Padrino
       [:INT, :TERM].each { |sig| trap(sig) { exit } }
       super
     ensure
-      puts "<= Padrino has ended his set (crowd applauds)" unless options[:daemonize]
+      puts "<= Padrino leaves the gun, takes the cannoli" unless options[:daemonize]
     end
 
     # The application the server will run.

data/lib/middleman-core/vendor/{padrino-core-0.10.5 → padrino-core-0.10.6}/lib/padrino-core/support_lite.rb

@@ -11,7 +11,7 @@ require 'active_support/inflector/methods'                  # constantize
 require 'active_support/inflector/inflections'              # pluralize
 require 'active_support/inflections'                        # load default inflections
 require 'yaml' unless defined?(YAML)                        # load yaml for i18n
-require 'Win32/Console/ANSI' if RUBY_PLATFORM =~ /win32/    # ruby color suppor for win
+require 'win32console' if RUBY_PLATFORM =~ /(win|m)32/      # ruby color support for win
 
 ##
 # This is an adapted version of active_support/core_ext/string/inflections.rb
@@ -113,8 +113,8 @@ module ObjectSpace
     # Returns all the classes in the object space.
     def classes
       ObjectSpace.each_object(Module).select do |klass|
-        # Why this? Ruby when you remove a constant don't clean it from
-        # rb_tables, this mean that here we can found classes that was
+        # Why? Ruby, when you remove a costant dosen't remove it from
+        # rb_tables, this mean that here we can find classes that was
         # removed.
         klass.name rescue false
       end
@@ -191,8 +191,7 @@ end
 ##
 # 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) ### !!! FIXME middleman ###
 
 ##
 # Used to determine if this file has already been required

data/lib/middleman-core/vendor/{padrino-core-0.10.5 → padrino-core-0.10.6}/lib/padrino-core/version.rb

@@ -6,7 +6,7 @@
 #
 module Padrino
   # The version constant for the current version of Padrino.
-  VERSION = '0.10.5' unless defined?(Padrino::VERSION)
+  VERSION = '0.10.6' unless defined?(Padrino::VERSION)
 
   #
   # The current Padrino version.

data/lib/middleman-core/vendor/{padrino-core-0.10.5 → padrino-core-0.10.6}/lib/padrino-core.rb

@@ -112,21 +112,6 @@ module Padrino
       nil
     end
 
-    ##
-    # Determines whether the dependencies are locked by Bundler.
-    # otherwise return nil
-    #
-    # @return [:locked, :unlocked, nil]
-    #   Returns +:locked+ if the +Gemfile.lock+ file exists, or +:unlocked+
-    #   if only the +Gemfile+ exists.
-    #
-    # @deprecated Will be removed in 1.0.0
-    #
-    def bundle
-      return :locked   if File.exist?(root('Gemfile.lock'))
-      return :unlocked if File.exist?(root("Gemfile"))
-    end
-
     ##
     # A Rack::Builder object that allows to add middlewares in front of all
     # Padrino applications.

data/lib/middleman-core/vendor/{padrino-core-0.10.5 → padrino-core-0.10.6}/padrino-core.gemspec

@@ -34,5 +34,5 @@ Gem::Specification.new do |s|
   s.add_dependency("sinatra", "~> 1.3.1")
   s.add_dependency("http_router", "~> 0.10.2")
   s.add_dependency("thor", "~> 0.14.3")
-  s.add_dependency("activesupport", "~> 3.1.0")
+  s.add_dependency("activesupport", "~> 3.2.0")
 end

data/lib/middleman-core/vendor/{padrino-core-0.10.5 → padrino-core-0.10.6}/test/helper.rb

@@ -44,6 +44,8 @@ class MiniTest::Spec
     else
       super(name, *args, &block)
     end
+  rescue Rack::Test::Error # no response yet
+    super(name, *args, &block)
   end
 
   alias :response :last_response

data/lib/middleman-core/vendor/{padrino-core-0.10.5 → padrino-core-0.10.6}/test/test_core.rb

@@ -15,7 +15,6 @@ describe "Core" do
       assert_respond_to Padrino, :load!
       assert_respond_to Padrino, :reload!
       assert_respond_to Padrino, :version
-      assert_respond_to Padrino, :bundle
       assert_respond_to Padrino, :configure_apps
     end
 
@@ -23,7 +22,6 @@ describe "Core" do
     should 'validate global helpers' do
       assert_equal :test, Padrino.env
       assert_match /\/test/, Padrino.root
-      assert_equal nil, Padrino.bundle
       assert_not_nil Padrino.version
     end