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

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

@@ -1,224 +0,0 @@
-module Padrino
-  ##
-  # Represents a particular mounted padrino application
-  # Stores the name of the application (app folder name) and url mount path
-  #
-  # @example
-  #   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 # @private
-    end
-
-    attr_accessor :name, :uri_root, :app_file, :app_class, :app_root, :app_obj, :app_host
-
-    ##
-    # @param [String, Padrino::Application] name
-    #   The app name or the {Padrino::Application} class
-    #
-    # @param [Hash] options
-    # @option options [Symbol] :app_class (Detected from name)
-    # @option options [Symbol] :app_file (Automatically detected)
-    # @option options [Symbol] :app_obj (Detected)
-    # @option options [Symbol] :app_root (Directory of :app_file)
-    #
-    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
-    #
-    # @param [String] mount_url
-    #   Path where we mount the app
-    #
-    # @example
-    #   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
-    #
-    # @param [String] mount_host
-    #   Host name
-    #
-    # @example
-    #   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
-    #
-    # @param [Padrino::Router]
-    #
-    # @return [Padrino::Router]
-    #
-    # @example
-    #   @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_folder,  Padrino.root('public', app_data.uri_root) unless File.exists?(app_obj.public_folder)
-      app_obj.set :static,         File.exist?(app_obj.public_folder) if app_obj.nil?
-      app_obj.setup_application! # Initializes the app here with above settings.
-      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
-    #
-    # @return [Array]
-    #   Array of routes
-    #
-    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
-    #
-    # @param [Padrino::Mounter] other
-    #
-    def ==(other)
-      other.is_a?(Mounter) && self.app_class == other.app_class && self.uri_root == other.uri_root
-    end
-
-    ##
-    # @return [Padrino::Application]
-    #  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
-
-    ##
-    # @param [Array] args
-    #
-    # @return [String]
-    #   the root to the mounted apps base directory
-    #
-    def mounted_root(*args)
-      Padrino.root(@mounted_root ||= "", *args)
-    end
-
-    ##
-    # @return [Array]
-    #   the mounted padrino applications (MountedApp objects)
-    #
-    def mounted_apps
-      @mounted_apps ||= []
-    end
-
-    ##
-    # Inserts a Mounter object into the mounted applications (avoids duplicates)
-    #
-    # @param [Padrino::Mounter] mounter
-    #
-    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
-    #
-    # @see Padrino::Mounter#new
-    #
-    # @example
-    #   Padrino.mount("blog_app").to("/blog")
-    #
-    def mount(name, options={})
-      Mounter.new(name, options)
-    end
-  end # Mounter
-end # Padrino

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

@@ -1,254 +0,0 @@
-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.
-    #
-
-    # The modification times for every file in a project.
-    MTIMES          = {}
-    # The list of files loaded as part of a project.
-    LOADED_FILES    = {}
-    # The list of object constants and classes loaded as part of the project.
-    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]
-          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.name.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={})
-        began_at    = Time.now
-        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, began_at, file if !reload
-          logger.debug :reload,  began_at, 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} due to a 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.name.index(c) == 0 } &&
-                 !include_constants.compact.uniq.any? { |c| const.name.index(c) == 0 }
-        begin
-          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
-
-      ##
-      # 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 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
-
-    ##
-    # 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
-
-      # Invoked in order to perform the reload as part of the request stack.
-      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-core/vendor/padrino-core-0.10.6/lib/padrino-core/router.rb

@@ -1,98 +0,0 @@
-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)
-  #
-  # @example
-  #
-  #   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
-  #
-  # @api semipublic
-  class Router
-
-    # Constructs a new route mapper instance
-    def initialize(*mapping, &block)
-      @mapping = []
-      mapping.each { |m| map(m) }
-      instance_eval(&block) if block
-    end
-
-    ##
-    # Map a route path and host to a specified application.
-    #
-    # @param [Hash] options
-    #  The options to map.
-    # @option options [Sinatra::Application] :to
-    #  The class of the application to mount.
-    # @option options [String] :path ("/")
-    #  The path to map the specified application.
-    # @option options [String] :host
-    #  The host to map the specified application.
-    #
-    # @example
-    #  map(:path => "/", :to => PadrinoWeb, :host => "padrino.local")
-    #
-    # @return [Array] The sorted route mappings.
-    # @api semipublic
-    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
-
-    # The call handler setup to route a request given the mappings specified.
-    # @api private
-    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
-
-    private
-
-    # Sorts the mapped routes in consistent order
-    def sort!
-      @mapping = @mapping.sort_by { |h, p, m, a| -p.size }
-    end
-  end # Router
-end # Padrino

data/lib/middleman-core/vendor/padrino-core-0.10.6/lib/padrino-core/server.rb

@@ -1,79 +0,0 @@
-module Padrino
-  ##
-  # Runs the Padrino apps as a self-hosted server using:
-  # 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"
-  #
-  def self.run!(options={})
-    Padrino.load!
-    Server.start(Padrino.application, options)
-  end
-
-  ##
-  # This module builds a Padrino server to run the project based on available handlers.
-  #
-  class Server < Rack::Server
-    # Server Handlers
-    Handlers = [:thin, :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[:Port] = options.delete(:port) || 3000
-      options[:AccessLog] = []
-      if options[:daemonize]
-        options[:pid] = options[:pid].blank? ? File.expand_path('tmp/pids/server.pid') : opts[:pid]
-        FileUtils.mkdir_p(File.dirname(options[:pid]))
-      end
-      options[:server] = detect_rack_handler if options[:server].blank?
-      new(options, app).start
-    end
-
-    def initialize(options, app)
-      @options, @app = options, app
-    end
-
-    # Starts the application on the available server with specified options.
-    def start
-      puts "=> Padrino/#{Padrino.version} has taken the stage #{Padrino.env} at http://#{options[:Host]}:#{options[:Port]}"
-      [:INT, :TERM].each { |sig| trap(sig) { exit } }
-      super
-    ensure
-      puts "<= Padrino leaves the gun, takes the cannoli" unless options[:daemonize]
-    end
-
-    # The application the server will run.
-    def app
-      @app
-    end
-    alias :wrapped_app :app
-
-    # The options specified to the server.
-    def options
-      @options
-    end
-
-    private
-
-      # Detects the supported handler to use.
-      #
-      # @example
-      #   detect_rack_handler => <ThinHandler>
-      #
-      def self.detect_rack_handler
-        Handlers.each do |handler|
-          begin
-            return handler if Rack::Handler.get(handler.to_s.downcase)
-          rescue LoadError
-          rescue NameError
-          end
-        end
-        fail "Server handler (#{Handlers.join(', ')}) not found."
-      end
-  end # Server
-end # Padrino