middleman 2.0.4 → 2.0.5

data/lib/middleman/vendor/padrino-core-0.10.0/lib/padrino-core/mounter.rb

@@ -0,0 +1,192 @@
+module Padrino
+  ##
+  # Represents a particular mounted padrino application
+  # Stores the name of the application (app folder name) and url mount path
+  #
+  # ==== Examples
+  #
+  #   Mounter.new("blog_app", :app_class => "Blog").to("/blog")
+  #   Mounter.new("blog_app", :app_file => "/path/to/blog/app.rb").to("/blog")
+  #
+  class Mounter
+    class MounterException < RuntimeError #:nodoc:
+    end
+
+    attr_accessor :name, :uri_root, :app_file, :app_class, :app_root, :app_obj, :app_host
+
+    def initialize(name, options={})
+      @name      = name.to_s
+      @app_class = options[:app_class] || @name.camelize
+      @app_file  = options[:app_file]  || locate_app_file
+      @app_obj   = options[:app_obj]   || app_constant || locate_app_object
+      ensure_app_file! || ensure_app_object!
+      @app_root  = options[:app_root]  || File.dirname(@app_file)
+      @uri_root  = "/"
+      Padrino::Reloader.exclude_constants << @app_class
+    end
+
+    ##
+    # Registers the mounted application onto Padrino
+    #
+    # ==== Examples
+    #
+    #   Mounter.new("blog_app").to("/blog")
+    #
+    def to(mount_url)
+      @uri_root  = mount_url
+      Padrino.insert_mounted_app(self)
+      self
+    end
+
+    ##
+    # Registers the mounted application onto Padrino for the given host
+    #
+    # ==== Examples
+    #
+    #   Mounter.new("blog_app").to("/blog").host("blog.padrino.org")
+    #   Mounter.new("blog_app").host("blog.padrino.org")
+    #   Mounter.new("catch_all").host(/.*\.padrino.org/)
+    #
+    def host(mount_host)
+      @app_host = mount_host
+      Padrino.insert_mounted_app(self)
+      self
+    end
+
+    ##
+    # Maps Padrino application onto a Padrino::Router
+    # For use in constructing a Rack application
+    #
+    #   @app.map_onto(router)
+    #
+    def map_onto(router)
+      app_data, app_obj = self, @app_obj
+      app_obj.set :uri_root, app_data.uri_root
+      app_obj.set :app_name, app_data.name
+      app_obj.set :app_file, app_data.app_file unless ::File.exist?(app_obj.app_file)
+      app_obj.set :root,     app_data.app_root unless app_data.app_root.blank?
+      app_obj.set :public,   Padrino.root('public', app_data.uri_root) unless File.exists?(app_obj.public)
+      app_obj.set :static,   File.exist?(app_obj.public) if app_obj.nil?
+      app_obj.setup_application! # We need to initialize here the app.
+      router.map(:to => app_obj, :path => app_data.uri_root, :host => app_data.app_host)
+    end
+
+    ###
+    # Returns the route objects for the mounted application
+    #
+    def routes
+      app_obj.routes
+    end
+
+    ###
+    # Returns the basic route information for each named route
+    #
+    #
+    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)
+      }.compact
+    end
+
+    ##
+    # Makes two Mounters equal if they have the same name and uri_root
+    #
+    def ==(other)
+      other.is_a?(Mounter) && self.app_class == other.app_class && self.uri_root == other.uri_root
+    end
+
+    ##
+    # Returns the class object for the app if defined, nil otherwise
+    #
+    def app_constant
+      klass = Object
+      for piece in app_class.split("::")
+        piece = piece.to_sym
+        if klass.const_defined?(piece)
+          klass = klass.const_get(piece)
+        else
+          return
+        end
+      end
+      klass
+    end
+
+    protected
+      ##
+      # Locates and requires the file to load the app constant
+      #
+      def locate_app_object
+        @_app_object ||= begin
+          ensure_app_file!
+          Padrino.require_dependencies(app_file)
+          app_constant
+        end
+      end
+
+      ##
+      # Returns the determined location of the mounted application main file
+      #
+      def locate_app_file
+        candidates  = []
+        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")
+        candidates << Padrino.root("app", "app.rb")
+        candidates.find { |candidate| File.exist?(candidate) }
+      end
+
+      ###
+      # Raises an exception unless app_file is located properly
+      #
+      def ensure_app_file!
+        message = "Unable to locate source file for app '#{app_class}', try with :app_file => '/path/app.rb'"
+        raise MounterException, message unless @app_file
+      end
+
+      ###
+      # Raises an exception unless app_obj is defined properly
+      #
+      def ensure_app_object!
+        message = "Unable to locate app for '#{app_class}', try with :app_class => 'MyAppClass'"
+        raise MounterException, message unless @app_obj
+      end
+  end
+
+  class << self
+    attr_writer :mounted_root # Set root directory where padrino searches mounted apps
+
+    ##
+    # Returns the root to the mounted apps base directory
+    #
+    def mounted_root(*args)
+      Padrino.root(@mounted_root ||= "", *args)
+    end
+
+    ##
+    # Returns the mounted padrino applications (MountedApp objects)
+    #
+    def mounted_apps
+      @mounted_apps ||= []
+    end
+
+    ##
+    # Inserts a Mounter object into the mounted applications (avoids duplicates)
+    #
+    def insert_mounted_app(mounter)
+      Padrino.mounted_apps.push(mounter) unless Padrino.mounted_apps.include?(mounter)
+    end
+
+    ##
+    # Mounts a new sub-application onto Padrino project
+    #
+    #   Padrino.mount("blog_app").to("/blog")
+    #
+    def mount(name, options={})
+      Mounter.new(name, options)
+    end
+  end # Mounter
+end # Padrino

data/lib/middleman/vendor/padrino-core-0.10.0/lib/padrino-core/reloader.rb

@@ -0,0 +1,247 @@
+require 'pathname'
+
+module Padrino
+  ##
+  # High performance source code reloader middleware
+  #
+  module Reloader
+    ##
+    # This reloader is suited for use in a many environments because each file
+    # will only be checked once and only one system call to stat(2) is made.
+    #
+    # Please note that this will not reload files in the background, and does so
+    # only when explicitly invoked.
+    #
+    MTIMES          = {}
+    LOADED_FILES    = {}
+    LOADED_CLASSES  = {}
+
+    class << self
+      ##
+      # Specified folders can be excluded from the code reload detection process.
+      # Default excluded directories at Padrino.root are: test, spec, features, tmp, config, db and public
+      #
+      def exclude
+        @_exclude ||= %w(test spec tmp features config public db).map { |path| Padrino.root(path) }
+      end
+
+      ##
+      # Specified constants can be excluded from the code unloading process.
+      #
+      def exclude_constants
+        @_exclude_constants ||= []
+      end
+
+      ##
+      # Specified constants can be configured to be reloaded on every request.
+      # Default included constants are: [none]
+      #
+      def include_constants
+        @_include_constants ||= []
+      end
+      ##
+      # Reload all files with changes detected.
+      #
+      def reload!
+        # Detect changed files
+        rotation do |file, mtime|
+          # Retrive the last modified time
+          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
+          next unless new_file || mtime > previous_mtime
+          # Now we can reload our file
+          apps = mounted_apps_of(file)
+          if apps.present?
+            apps.each { |app| app.app_obj.reload! }
+          else
+            safe_load(file, :force => new_file)
+            # Reload also apps
+            Padrino.mounted_apps.each do |app|
+              app.app_obj.reload! if app.app_obj.dependencies.include?(file)
+            end
+          end
+        end
+      end
+
+      ##
+      # 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
+      end
+
+      ##
+      # Returns true if any file changes are detected and populates the MTIMES cache
+      #
+      def changed?
+        changed = false
+        rotation do |file, mtime|
+          new_file = MTIMES[file].nil?
+          previous_mtime = MTIMES[file] ||= mtime
+          changed = true if new_file || mtime > previous_mtime
+        end
+        changed
+      end
+      alias :run! :changed?
+
+      ##
+      # We lock dependencies sets to prevent reloading of protected constants
+      #
+      def lock!
+        klasses = ObjectSpace.classes.map { |klass| klass.to_s.split("::")[0] }.uniq
+        klasses = klasses | Padrino.mounted_apps.map { |app| app.app_class }
+        Padrino::Reloader.exclude_constants.concat(klasses)
+      end
+
+      ##
+      # A safe Kernel::require which issues the necessary hooks depending on results
+      #
+      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]
+
+        # 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
+
+        # 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 load the specified file
+        begin
+          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 => 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
+
+        end
+      end
+
+      ##
+      # Returns true if the file is defined in our padrino root
+      #
+      def figure_path(file)
+        return file if Pathname.new(file).absolute?
+        $:.each do |path|
+          found = File.join(path, file)
+          return File.expand_path(found) if File.exist?(found)
+        end
+        file
+      end
+
+      ##
+      # 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)}}) }
+        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}"
+        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
+
+        ##
+        # 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.
+        #
+        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
+    end # self
+
+    ##
+    # This class acts as a Rack middleware to be added to the application stack. This middleware performs a
+    # check and reload for source files at the start of each request, but also respects a specified cool down time
+    # during which no further action will be taken.
+    #
+    class Rack
+      def initialize(app, cooldown=1)
+        @app = app
+        @cooldown = cooldown
+        @last = (Time.now - cooldown)
+      end
+
+      def call(env)
+        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
+  end # Reloader
+end # Padrino

data/lib/middleman/vendor/padrino-core-0.10.0/lib/padrino-core/router.rb

@@ -0,0 +1,79 @@
+module Padrino
+  ##
+  # This class is an extended version of Rack::URLMap
+  #
+  # Padrino::Router like Rack::URLMap dispatches in such a way that the
+  # longest paths are tried first, since they are most specific.
+  #
+  # Features:
+  #
+  # * Map a path to the specified App
+  # * Ignore server names (this solve issues with vhost and domain aliases)
+  # * Use hosts instead of server name for mappings (this help us with our vhost and doman aliases)
+  #
+  # ==== Options
+  #
+  # :to:: The class of application that you want mount
+  # :path:: Map the app to the given path
+  # :host:: Map the app to the given host
+  #
+  # ==== Examples
+  #
+  #   routes = Padrino::Router.new do
+  #     map(:path => "/", :to => PadrinoWeb, :host => "padrino.local")
+  #     map(:path => "/", :to => Admin, :host => "admin.padrino.local")
+  #   end
+  #   run routes
+  #
+  #   routes = Padrino::Router.new do
+  #     map(:path => "/", :to => PadrinoWeb, :host => /*.padrino.local/)
+  #   end
+  #   run routes
+  #
+  class Router
+    def initialize(*mapping, &block)
+      @mapping = []
+      mapping.each { |m| map(m) }
+      instance_eval(&block) if block
+    end
+
+    def sort!
+      @mapping = @mapping.sort_by { |h, p, m, a| -p.size }
+    end
+
+    def map(options={})
+      path = options[:path] || "/"
+      host = options[:host]
+      app  = options[:to]
+
+      raise ArgumentError, "paths need to start with /" if path[0] != ?/
+      raise ArgumentError, "app is required" if app.nil?
+
+      path  = path.chomp('/')
+      match = Regexp.new("^#{Regexp.quote(path).gsub('/', '/+')}(.*)", nil, 'n')
+      host  = Regexp.new("^#{Regexp.quote(host)}$", true, 'n') unless host.nil? || host.is_a?(Regexp)
+
+      @mapping << [host, path, match, app]
+      sort!
+    end
+
+    def call(env)
+      rPath = env["PATH_INFO"].to_s
+      script_name = env['SCRIPT_NAME']
+      hHost, sName, sPort = env.values_at('HTTP_HOST','SERVER_NAME','SERVER_PORT')
+      @mapping.each do |host, path, match, app|
+        next unless host.nil? || hHost =~ host
+        next unless rPath =~ match && rest = $1
+        next unless rest.empty? || rest[0] == ?/
+
+        rest = "/" if rest.empty?
+
+        return app.call(
+          env.merge(
+            'SCRIPT_NAME' => (script_name + path),
+            'PATH_INFO'   => rest))
+      end
+      [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{rPath}"]]
+    end
+  end # Router
+end # Padrino