middleman-core 3.1.0.rc.2 → 3.1.0.rc.3

data/lib/vendored-middleman-deps/padrino-core-0.11.2/lib/padrino-core/module.rb

@@ -0,0 +1,58 @@
+module Padrino
+  module Module
+    attr_accessor :root
+
+    ##
+    # Register this module as being loaded from a gem. This automatically
+    # sets the root and therefore the dependency paths correctly.
+    #
+    # @param [String] name
+    #   The name of the gem. Has to be the name as stated in the gemspec.
+    #
+    # @returns the gems root.
+    def gem!(name)
+      self.root = Padrino.gem(name, self)
+    end
+
+    ##
+    # Helper method for file references within a Padrino module.
+    #
+    # @param [Array<String>] args
+    #   The directories to join to {Module.root}.
+    #
+    # @return [String]
+    #   The absolute path.
+    #
+    # @example
+    #   module MyModule
+    #     extend Padrino::Module
+    #     gem! 'my_gem'
+    #   end
+    #   Module.root!
+    def root(*args)
+      File.expand_path(File.join(@root, *args))
+    end
+    
+    ##
+    # Returns the list of path globs to load as dependencies
+    # Appends custom dependency patterns to the be loaded for Padrino.
+    #
+    # @return [Array<String>]
+    #   The dependency paths.
+    #
+    # @example
+    #   module MyModule
+    #     extend Padrino::Module
+    #     gem! 'my_gem'
+    #   end
+    #
+    #   Module.dependency_paths << "#{MyModule.root}/uploaders/*.rb"
+    #
+    def dependency_paths
+      [
+        "#{root}/lib/**/*.rb", "#{root}/shared/lib/**/*.rb",
+        "#{root}/models/**/*.rb", "#{root}/shared/models/**/*.rb"
+      ]
+    end
+  end
+end

data/lib/vendored-middleman-deps/{padrino-core-0.10.7 → padrino-core-0.11.2}/lib/padrino-core/mounter.rb

@@ -22,10 +22,12 @@ module Padrino
     # @option options [Symbol] :app_file (Automatically detected)
     # @option options [Symbol] :app_obj (Detected)
     # @option options [Symbol] :app_root (Directory of :app_file)
+    # @option options [Symbol] :gem The gem to load the app from (Detected from name)
     #
     def initialize(name, options={})
       @name      = name.to_s
       @app_class = options[:app_class] || @name.camelize
+      @gem       = options[:gem]       || @app_class.split("::").first.underscore
       @app_file  = options[:app_file]  || locate_app_file
       @app_obj   = options[:app_obj]   || app_constant || locate_app_object
       ensure_app_file! || ensure_app_object!
@@ -104,11 +106,12 @@ 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.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)
+        name_array     = "(#{route.name.to_s.split("_").map { |piece| %Q[:#{piece}] }.join(", ")})"
+        request_method = route.request_methods.first
+        next if route.name.blank? || request_method == 'HEAD'
+        original_path = route.original_path.is_a?(Regexp) ? route.original_path.inspect : route.original_path
+        full_path = File.join(uri_root, original_path)
+        OpenStruct.new(:verb => request_method, :identifier => route.name, :name => name_array, :path => full_path)
       }.compact
     end
 
@@ -158,6 +161,13 @@ module Padrino
         candidates << app_constant.app_file if app_constant.respond_to?(:app_file) && File.exist?(app_constant.app_file.to_s)
         candidates << Padrino.first_caller if File.identical?(Padrino.first_caller.to_s, Padrino.called_from.to_s)
         candidates << Padrino.mounted_root(name.downcase, "app.rb")
+        simple_name = name.split("::").last.downcase
+        mod_name = name.split("::")[0..-2].join("::")
+        Padrino.modules.each do |mod|
+          if mod.name == mod_name
+            candidates << mod.root(simple_name, "app.rb")
+          end
+        end
         candidates << Padrino.root("app", "app.rb")
         candidates.find { |candidate| File.exist?(candidate) }
       end

data/lib/vendored-middleman-deps/{padrino-core-0.10.7 → padrino-core-0.11.2}/lib/padrino-core/reloader.rb

@@ -33,7 +33,7 @@ module Padrino
       # Specified constants can be excluded from the code unloading process.
       #
       def exclude_constants
-        @_exclude_constants ||= []
+        @_exclude_constants ||= Set.new
       end
 
       ##
@@ -41,7 +41,7 @@ module Padrino
       # Default included constants are: [none]
       #
       def include_constants
-        @_include_constants ||= []
+        @_include_constants ||= Set.new
       end
 
       ##
@@ -51,7 +51,7 @@ module Padrino
         # Detect changed files
         rotation do |file, mtime|
           # Retrive the last modified time
-          new_file = MTIMES[file].nil?
+          new_file       = MTIMES[file].nil?
           previous_mtime = MTIMES[file] ||= mtime
           logger.devel "Detected a new file #{file}" if new_file
           # We skip to next file if it is not new and not modified
@@ -74,15 +74,9 @@ module Padrino
       # Remove files and classes loaded with stat
       #
       def clear!
-        MTIMES.clear
-        LOADED_CLASSES.each do |file, klasses|
-          klasses.each { |klass| remove_constant(klass) }
-          LOADED_CLASSES.delete(file)
-        end
-        LOADED_FILES.each do |file, dependencies|
-          dependencies.each { |dependency| $LOADED_FEATURES.delete(dependency) }
-          $LOADED_FEATURES.delete(file)
-        end
+        clear_modification_times
+        clear_loaded_classes
+        clear_loaded_files_and_features
       end
 
       ##
@@ -103,67 +97,59 @@ module Padrino
       # We lock dependencies sets to prevent reloading of protected constants
       #
       def lock!
-        klasses = ObjectSpace.classes.map { |klass| klass._orig_klass_name.split('::')[0] }.uniq
+        klasses = ObjectSpace.classes do |klass|
+          klass._orig_klass_name.split('::')[0]
+        end
+
         klasses = klasses | Padrino.mounted_apps.map { |app| app.app_class }
-        Padrino::Reloader.exclude_constants.concat(klasses)
+        Padrino::Reloader.exclude_constants.merge(klasses)
       end
 
       ##
       # A safe Kernel::require which issues the necessary hooks depending on results
       #
       def safe_load(file, options={})
-        began_at    = Time.now
-        force, file = options[:force], figure_path(file)
+        began_at = Time.now
+        force    = options[:force]
+        file     = figure_path(file)
+        reload   = should_reload?(file)
+        m_time   = modification_time(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]
+        return if !force && m_time && !reload
 
-        # Removes all classes declared in the specified file
-        if klasses = LOADED_CLASSES.delete(file)
-          klasses.each { |klass| remove_constant(klass) }
-        end
-
-        # Remove all loaded fatures with our file
-        if features = LOADED_FILES[file]
-          features.each { |feature| $LOADED_FEATURES.delete(feature) }
-        end
+        remove_loaded_file_classes(file)
+        remove_loaded_file_features(file)
 
         # Duplicate objects and loaded features before load file
-        klasses = ObjectSpace.classes.dup
-        files   = $LOADED_FEATURES.dup
+        klasses = ObjectSpace.classes
+        files   = Set.new($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
+        reload_deps_of_file(file)
 
         # And finally load the specified file
         begin
           logger.devel :loading, began_at, file if !reload
           logger.debug :reload,  began_at, file if  reload
-          $LOADED_FEATURES.delete(file)
-          verbosity_was, $-v = $-v, nil
+
+          $LOADED_FEATURES.delete(file) if files.include?(file)
+          Padrino::Utils.silence_output
           loaded = false
           require(file)
           loaded = true
-          MTIMES[file] = File.mtime(file)
+          update_modification_time(file)
         rescue SyntaxError => e
           logger.error "Cannot require #{file} due to a syntax error: #{e.message}"
         ensure
-          $-v = verbosity_was
-          new_constants = (ObjectSpace.classes - klasses).uniq
+          Padrino::Utils.unsilence_output
+          new_constants = ObjectSpace.new_classes(klasses)
           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) }
+            process_loaded_file(:file      => file, 
+                                :constants => new_constants, 
+                                :files     => files)
           else
             logger.devel "Failed to load #{file}; removing partially defined constants"
-            new_constants.each { |klass| remove_constant(klass) }
+            unload_constants(new_constants)
           end
-
         end
       end
 
@@ -183,8 +169,8 @@ module Padrino
       # Removes the specified class and constant.
       #
       def remove_constant(const)
-        return if exclude_constants.compact.uniq.any? { |c| const._orig_klass_name.index(c) == 0 } &&
-                 !include_constants.compact.uniq.any? { |c| const._orig_klass_name.index(c) == 0 }
+        return if exclude_constants.any? { |c| const._orig_klass_name.index(c) == 0 } &&
+                 !include_constants.any? { |c| const._orig_klass_name.index(c) == 0 }
         begin
           parts  = const.to_s.sub(/^::(Object)?/, 'Object::').split('::')
           object = parts.pop
@@ -195,6 +181,101 @@ module Padrino
       end
 
       private
+
+      ###
+      # Clear instance variables that keep track of 
+      # loaded features/files/mtimes
+      #
+      def clear_modification_times
+        MTIMES.clear
+      end
+      
+      def clear_loaded_classes
+        LOADED_CLASSES.each do |file, klasses|
+          klasses.each { |klass| remove_constant(klass) }
+          LOADED_CLASSES.delete(file)
+        end
+      end
+
+      def clear_loaded_files_and_features
+        LOADED_FILES.each do |file, dependencies|
+          dependencies.each { |dependency| $LOADED_FEATURES.delete(dependency) }
+          $LOADED_FEATURES.delete(file)
+        end
+      end
+
+      ###
+      # Macro for mtime query
+      #
+      def modification_time(file)
+        MTIMES[file]
+      end
+
+      ###
+      # Macro for mtime update
+      #
+      def update_modification_time(file)
+        MTIMES[file] = File.mtime(file)
+      end
+
+      ###
+      # Tracks loaded file features/classes/constants
+      #
+      def process_loaded_file(*args)
+        options       = args.extract_options!
+        new_constants = options[:constants]
+        files         = options[:files]
+        file          = options[:file]
+
+        # Store the file details
+        LOADED_CLASSES[file] = new_constants
+        LOADED_FILES[file]   = Set.new($LOADED_FEATURES) - files - [file]
+
+        # Track only features in our Padrino.root
+        LOADED_FILES[file].delete_if { |feature| !in_root?(feature) }
+      end
+
+      ###
+      # Unloads all constants in new_constants
+      #
+      def unload_constants(new_constants)
+        new_constants.each { |klass| remove_constant(klass) }
+      end
+
+      ###
+      # Safe load dependencies of a file
+      #
+      def reload_deps_of_file(file)
+        if features = LOADED_FILES.delete(file)
+          features.each { |feature| safe_load(feature, :force => true) }
+        end
+      end
+
+      ##
+      # Check if file was changed or if force a reload
+      #
+      def should_reload?(file)
+        MTIMES[file] && File.mtime(file) > MTIMES[file]
+      end
+
+      ##
+      # Removes all classes declared in the specified file
+      #
+      def remove_loaded_file_classes(file)
+        if klasses = LOADED_CLASSES.delete(file)
+          klasses.each { |klass| remove_constant(klass) }
+        end 
+      end
+
+      ##
+      # Remove all loaded fatures with our file
+      #
+      def remove_loaded_file_features(file)
+        if features = LOADED_FILES[file]
+          features.each { |feature| $LOADED_FEATURES.delete(feature) }
+        end
+      end
+
       ##
       # Return the mounted_apps providing the app location
       # Can be an array because in one app.rb we can define multiple Padrino::Appplications
@@ -218,15 +299,21 @@ module Padrino
       # 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|
+        files_for_rotation.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
+
+      ##
+      # Creates an array of paths for use in #rotation
+      #
+      def files_for_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
+      end
     end # self
 
     ##

data/lib/vendored-middleman-deps/{padrino-core-0.10.7 → padrino-core-0.11.2}/lib/padrino-core/server.rb

@@ -4,8 +4,8 @@ module Padrino
   # thin, mongrel, or webrick in that order.
   #
   # @example
-  #   Padrino.run! # with these defaults => host: "localhost", port: "3000", adapter: the first found
-  #   Padrino.run!("localhost", "4000", "mongrel") # use => host: "0.0.0.0", port: "3000", adapter: "mongrel"
+  #   Padrino.run! # with these defaults => host: "127.0.0.1", port: "3000", adapter: the first found
+  #   Padrino.run!("0.0.0.0", "4000", "mongrel") # use => host: "0.0.0.0", port: "4000", adapter: "mongrel"
   #
   def self.run!(options={})
     Padrino.load!
@@ -17,17 +17,17 @@ module Padrino
   #
   class Server < Rack::Server
     # Server Handlers
-    Handlers = [:thin, :mongrel, :trinidad, :webrick]
+    Handlers = [:thin, :puma, :mongrel, :trinidad, :webrick]
 
     # Starts the application on the available server with specified options.
     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) || '0.0.0.0'
+      options[:Host] = options.delete(:host) || '127.0.0.1' 
       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]
+        options[:pid] = File.expand_path(options[:pid].blank? ? 'tmp/pids/server.pid' : opts[:pid])
         FileUtils.mkdir_p(File.dirname(options[:pid]))
       end
       options[:server] = detect_rack_handler if options[:server].blank?

data/lib/vendored-middleman-deps/{padrino-core-0.10.7 → padrino-core-0.11.2}/lib/padrino-core/support_lite.rb

@@ -9,6 +9,7 @@ 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/core_ext/string/output_safety'      # SafeBuffer and html_safe
 require 'active_support/inflections'                        # load default inflections
 require 'yaml' unless defined?(YAML)                        # load yaml for i18n
 require 'win32console' if RUBY_PLATFORM =~ /(win|m)32/      # ruby color support for win
@@ -110,13 +111,49 @@ end
 
 module ObjectSpace
   class << self
+    ##
     # Returns all the classes in the object space.
-    def classes
-      ObjectSpace.each_object(Module).select do |klass|
-        # 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
+    # Optionally, a block can be passed, for example the following code
+    # would return the classes that start with the character "A":
+    #
+    #  ObjectSpace.classes do |klass|
+    #    if klass.to_s[0] == "A"
+    #      klass
+    #    end
+    #  end
+    #
+    def classes(&block)
+      rs = Set.new
+
+      ObjectSpace.each_object(Class).each do |klass|
+        if block
+          if r = block.call(klass)
+            # add the returned value if the block returns something
+            rs << r
+          end
+        else
+          rs << klass
+        end
+      end
+
+      rs
+    end
+
+    ##
+    # Returns a list of existing classes that are not included in "snapshot"
+    # This method is useful to get the list of new classes that were loaded
+    # after an event like requiring a file.
+    # Usage:
+    #
+    #   snapshot = ObjectSpace.classes
+    #   # require a file
+    #   ObjectSpace.new_classes(snapshot)
+    #
+    def new_classes(snapshot)
+      self.classes do |klass|
+        if !snapshot.include?(klass)
+          klass
+        end
       end
     end
   end
@@ -205,3 +242,19 @@ I18n.load_path += Dir["#{File.dirname(__FILE__)}/locale/*.yml"] if defined?(I18n
 # Used to determine if this file has already been required
 #
 module SupportLite; end
+
+module Padrino
+  class Utils
+    ###
+    # Silences output verbosity level so load
+    # errors are not visible when safe_load(file)
+    #
+    def self.silence_output
+      @verbosity_level, $-v = $-v, nil
+    end
+
+    def self.unsilence_output
+      $-v = @verbosity_level
+    end
+  end
+end