middleman-core 3.3.12 → 4.4.2

data/lib/middleman-core/preview_server.rb

@@ -1,29 +1,51 @@
 require 'webrick'
 require 'webrick/https'
 require 'openssl'
-require 'socket'
 require 'middleman-core/meta_pages'
 require 'middleman-core/logger'
+require 'middleman-core/rack'
+require 'middleman-core/preview_server/server_information'
+require 'middleman-core/preview_server/server_url'
+require 'middleman-core/preview_server/server_information_callback_proxy'
 
 # rubocop:disable GlobalVars
 module Middleman
-  module PreviewServer
+  class PreviewServer
     class << self
-      attr_reader :app, :host, :port, :ssl_certificate, :ssl_private_key
-      delegate :logger, to: :app
+      extend Forwardable
 
-      def https?
-        @https
-      end
+      attr_reader :app, :ssl_certificate, :ssl_private_key, :environment, :server_information
 
       # Start an instance of Middleman::Application
       # @return [void]
-      def start(opts={})
+      def start(opts={}, cli_options={})
+        # Do not buffer output, otherwise testing of output does not work
+        $stdout.sync = true
+        $stderr.sync = true
+
         @options = opts
+        @cli_options = cli_options
+        @server_information = ServerInformation.new
+        @server_information.https = (@options[:https] == true)
+
+        # New app evaluates the middleman configuration. Since this can be
+        # invalid as well, we need to evaluate the configuration BEFORE
+        # checking for validity
+        the_app = initialize_new_app
+
+        # And now comes the check
+        unless server_information.valid?
+          $stderr.puts %(== Running Middleman failed: #{server_information.reason}. Please fix that and try again.)
+          exit 1
+        end
+
+        mount_instance(the_app)
 
-        mount_instance(new_app)
-        logger.info "== The Middleman is standing watch at #{uri} (#{uri(public_ip)})"
-        logger.info "== Inspect your site configuration at #{uri + '__middleman'}"
+        app.logger.debug %(== Server information is provided by #{server_information.handler})
+        app.logger.debug %(== The Middleman is running in "#{environment}" environment)
+        app.logger.debug format('== The Middleman preview server is bound to %s', ServerUrl.new(hosts: server_information.listeners, port: server_information.port, https: server_information.https?).to_bind_addresses.join(', '))
+        app.logger.info format('== View your site at %s', ServerUrl.new(hosts: server_information.site_addresses, port: server_information.port, https: server_information.https?).to_urls.join(', '))
+        app.logger.info format('== Inspect your site configuration at %s', ServerUrl.new(hosts: server_information.site_addresses, port: server_information.port, https: server_information.https?).to_config_urls.join(', '))
 
         @initialized ||= false
         return if @initialized
@@ -35,6 +57,21 @@ module Middleman
         # reloading later on.
         ::Middleman::Profiling.report('server_start')
 
+        app.execute_callbacks(:before_server, [ServerInformationCallbackProxy.new(server_information)])
+
+        if @options[:daemon]
+          # To output the child PID, let's make preview server a daemon by hand
+          if child_pid = fork
+            app.logger.info "== Middleman preview server is running in background with PID #{child_pid}"
+            Process.detach child_pid
+            exit 0
+          else
+            $stdout.reopen('/dev/null', 'w')
+            $stderr.reopen('/dev/null', 'w')
+            $stdin.reopen('/dev/null', 'r')
+          end
+        end
+
         loop do
           @webrick.start
 
@@ -53,35 +90,37 @@ module Middleman
       # @return [void]
       def stop
         begin
-          logger.info '== The Middleman is shutting down'
+          app.logger.info '== The Middleman is shutting down'
         rescue
           # if the user closed their terminal STDOUT/STDERR won't exist
         end
 
-        if @listener
-          @listener.stop
-          @listener = nil
-        end
         unmount_instance
       end
 
       # Simply stop, then start the server
       # @return [void]
       def reload
-        logger.info '== The Middleman is reloading'
+        app.logger.info '== The Middleman is reloading'
+
+        app.execute_callbacks(:reload)
 
         begin
-          app = new_app
+          app = initialize_new_app
         rescue => e
-          logger.error "Error reloading Middleman: #{e}\n#{e.backtrace.join("\n")}"
-          logger.info '== The Middleman is still running the application from before the error'
+          $stderr.puts "Error reloading Middleman: #{e}\n#{e.backtrace.join("\n")}"
+          app.logger.info '== The Middleman is still running the application from before the error'
           return
         end
 
         unmount_instance
+
+        @webrick.shutdown
+        @webrick = nil
+
         mount_instance(app)
 
-        logger.info '== The Middleman has reloaded'
+        app.logger.info '== The Middleman has reloaded'
       end
 
       # Stop the current instance, exit Webrick
@@ -93,72 +132,86 @@ module Middleman
 
       private
 
-      def new_app
+      def initialize_new_app
         opts = @options.dup
+        cli_options = @cli_options.dup
 
-        server = ::Middleman::Application.server
+        ::Middleman::Logger.singleton(
+          opts[:debug] ? 0 : 1,
+          opts[:instrumenting] || false
+        )
 
-        # Add in the meta pages application
-        meta_app = Middleman::MetaPages::Application.new(server)
-        server.map '/__middleman' do
-          run meta_app
-        end
+        app = ::Middleman::Application.new do
+          config[:cli_options] = cli_options.each_with_object({}) do |(k, v), sum|
+            sum[k] = v
+          end
 
-        @app = server.inst do
-          ::Middleman::Logger.singleton(
-            opts[:debug] ? 0 : 1,
-            opts[:instrumenting] || false
-          )
-
-          config[:environment] = opts[:environment].to_sym if opts[:environment]
-          config[:port] = opts[:port] if opts[:port]
-          config[:https] = opts[:https] unless opts[:https].nil?
-          config[:ssl_certificate] = opts[:ssl_certificate] if opts[:ssl_certificate]
-          config[:ssl_private_key] = opts[:ssl_private_key] if opts[:ssl_private_key]
-        end
+          ready do
+            unless config[:watcher_disable]
+              match_against = [
+                %r{^config\.rb$},
+                %r{^environments/[^\.](.*)\.rb$},
+                %r{^lib/[^\.](.*)\.rb$},
+                %r{^#{config[:helpers_dir]}/[^\.](.*)\.rb$}
+              ]
 
-        @port = @app.config[:port]
-        @https = @app.config[:https]
+              # config.rb
+              watcher = files.watch :reload,
+                                    path: root,
+                                    only: match_against
 
-        @ssl_certificate = @app.config[:ssl_certificate]
-        @ssl_private_key = @app.config[:ssl_private_key]
+              # Hack around bower_components in root.
+              watcher.listener.ignore(/^bower_components/)
 
-        @app
-      end
+              # Hack around node_modules in root.
+              watcher.listener.ignore(/^node_modules/)
 
-      def start_file_watcher
-        return if @listener || @options[:disable_watcher]
+              # Hack around sass cache in root.
+              watcher.listener.ignore(/^\.sass-cache/)
 
-        # Watcher Library
-        require 'listen'
+              # Hack around bundler cache in root.
+              watcher.listener.ignore(/^vendor\/bundle/)
+            end
+          end
+        end
 
-        options = { force_polling: @options[:force_polling] }
-        options[:latency] = @options[:latency] if @options[:latency]
+        # store configured port to make a check later on possible
+        configured_port = possible_from_cli(:port, app.config)
 
-        @listener = Listen.to(Dir.pwd, options) do |modified, added, removed|
-          added_and_modified = (modified + added)
+        # Use configuration values to set `bind_address` etc. in
+        # `server_information`
+        server_information.use(bind_address: possible_from_cli(:bind_address, app.config),
+                               port: possible_from_cli(:port, app.config),
+                               server_name: possible_from_cli(:server_name, app.config),
+                               https: possible_from_cli(:https, app.config))
 
-          # See if the changed file is config.rb or lib/*.rb
-          if needs_to_reload?(added_and_modified + removed)
-            $mm_reload = true
-            @webrick.stop
-          else
-            added_and_modified.each do |path|
-              relative_path = Pathname(path).relative_path_from(Pathname(Dir.pwd)).to_s
-              next if app.files.ignored?(relative_path)
-              app.files.did_change(relative_path)
-            end
+        app.logger.warn format('== The Middleman uses a different port "%s" then the configured one "%s" because some other server is listening on that port.', server_information.port, configured_port) unless server_information.port == configured_port
 
-            removed.each do |path|
-              relative_path = Pathname(path).relative_path_from(Pathname(Dir.pwd)).to_s
-              next if app.files.ignored?(relative_path)
-              app.files.did_delete(relative_path)
-            end
-          end
+        @environment = possible_from_cli(:environment, app.config)
+
+        @ssl_certificate = possible_from_cli(:ssl_certificate, app.config)
+        @ssl_private_key = possible_from_cli(:ssl_private_key, app.config)
+
+        app.files.on_change :reload do
+          $mm_reload = true
+          @webrick.stop
         end
 
-        # Don't block this thread
-        @listener.start
+        # Add in the meta pages application
+        meta_app = Middleman::MetaPages::Application.new(app)
+        app.map '/__middleman' do
+          run meta_app
+        end
+
+        app
+      end
+
+      def possible_from_cli(key, config)
+        if @cli_options[key]
+          @cli_options[key]
+        else
+          config[key]
+        end
       end
 
       # Trap some interupt signals and shut down smoothly
@@ -170,6 +223,7 @@ module Middleman
           Signal.trap(sig) do
             # Do as little work as possible in the signal context
             $mm_shutdown = true
+
             @webrick.stop
           end
         end
@@ -179,41 +233,79 @@ module Middleman
       # @return [void]
       def setup_webrick(is_logging)
         http_opts = {
-          Port: port,
+          Port: server_information.port,
           AccessLog: [],
+          ServerName: server_information.server_name,
+          BindAddress: server_information.bind_address.to_s,
           DoNotReverseLookup: true
         }
 
-        if https?
+        if server_information.https?
           http_opts[:SSLEnable] = true
 
           if ssl_certificate || ssl_private_key
-            raise "You must provide both :ssl_certificate and :ssl_private_key" unless ssl_private_key && ssl_certificate
-            http_opts[:SSLCertificate] = OpenSSL::X509::Certificate.new File.read ssl_certificate
-            http_opts[:SSLPrivateKey] = OpenSSL::PKey::RSA.new File.read ssl_private_key
+            raise 'You must provide both :ssl_certificate and :ssl_private_key' unless ssl_private_key && ssl_certificate
+            http_opts[:SSLCertificate] = OpenSSL::X509::Certificate.new ::File.read ssl_certificate
+            http_opts[:SSLPrivateKey] = OpenSSL::PKey::RSA.new ::File.read ssl_private_key
           else
             # use a generated self-signed cert
             http_opts[:SSLCertName] = [
-                                       %w(CN localhost),
-                                       %w(CN #{Socket.gethostname})
-                                      ].uniq
+              %w(CN localhost),
+              %w(CN #{host})
+            ].uniq
+            cert, key = create_self_signed_cert(1024, [['CN', server_information.server_name]], server_information.site_addresses, 'Middleman Preview Server')
+            http_opts[:SSLCertificate] = cert
+            http_opts[:SSLPrivateKey] = key
           end
         end
 
-        if is_logging
-          http_opts[:Logger] = FilteredWebrickLog.new
+        http_opts[:Logger] = if is_logging
+          FilteredWebrickLog.new
         else
-          http_opts[:Logger] = ::WEBrick::Log.new(nil, 0)
+          ::WEBrick::Log.new(nil, 0)
         end
 
         begin
           ::WEBrick::HTTPServer.new(http_opts)
         rescue Errno::EADDRINUSE
-          logger.error "== Port #{port} is unavailable. Either close the instance of Middleman already running on #{port} or start this Middleman on a new port with: --port=#{port.to_i + 1}"
-          exit(1)
+          $stderr.puts %(== Port "#{http_opts[:Port]}" is in use. This should not have happened. Please start "middleman server" again.)
         end
       end
 
+      # Copy of https://github.com/nahi/ruby/blob/webrick_trunk/lib/webrick/ssl.rb#L39
+      # that uses a different serial number each time the cert is generated in order to
+      # avoid errors in Firefox. Also doesn't print out stuff to $stderr unnecessarily.
+      def create_self_signed_cert(bits, cn, aliases, comment)
+        rsa = OpenSSL::PKey::RSA.new(bits)
+        cert = OpenSSL::X509::Certificate.new
+        cert.version = 2
+        cert.serial = Time.now.to_i % (1 << 20)
+        name = OpenSSL::X509::Name.new(cn)
+        cert.subject = name
+        cert.issuer = name
+        cert.not_before = Time.now
+        cert.not_after = Time.now + (365 * 24 * 60 * 60)
+        cert.public_key = rsa.public_key
+
+        ef = OpenSSL::X509::ExtensionFactory.new(nil, cert)
+        ef.issuer_certificate = cert
+        cert.extensions = [
+          ef.create_extension('basicConstraints', 'CA:FALSE'),
+          ef.create_extension('keyUsage', 'keyEncipherment'),
+          ef.create_extension('subjectKeyIdentifier', 'hash'),
+          ef.create_extension('extendedKeyUsage', 'serverAuth'),
+          ef.create_extension('nsComment', comment)
+        ]
+        aki = ef.create_extension('authorityKeyIdentifier',
+                                  'keyid:always,issuer:always')
+        cert.add_extension(aki)
+        cert.add_extension ef.create_extension('subjectAltName', aliases.map { |d| "DNS: #{d}" }.join(','))
+
+        cert.sign(rsa, OpenSSL::Digest::SHA1.new)
+
+        [cert, rsa]
+      end
+
       # Attach a new Middleman::Application instance
       # @param [Middleman::Application] app
       # @return [void]
@@ -222,9 +314,7 @@ module Middleman
 
         @webrick ||= setup_webrick(@options[:debug] || false)
 
-        start_file_watcher
-
-        rack_app = app.class.to_rack_app
+        rack_app = ::Middleman::Rack.new(@app).to_app
         @webrick.mount '/', ::Rack::Handler::WEBrick, rack_app
       end
 
@@ -232,50 +322,11 @@ module Middleman
       # @return [void]
       def unmount_instance
         @webrick.unmount '/'
-        @app = nil
-      end
-
-      # Whether the passed files are config.rb, lib/*.rb or helpers
-      # @param [Array<String>] paths Array of paths to check
-      # @return [Boolean] Whether the server needs to reload
-      def needs_to_reload?(paths)
-        relative_paths = paths.map do |p|
-          Pathname(p).relative_path_from(Pathname(app.root)).to_s
-        end
-
-        match_against = [
-          %r{^config\.rb$},
-          %r{^lib/[^\.](.*)\.rb$},
-          %r{^helpers/[^\.](.*)\.rb$}
-        ]
 
-        if @options[:reload_paths]
-          @options[:reload_paths].split(',').each do |part|
-            match_against << %r{^#{part}}
-          end
-        end
+        @app.shutdown!
 
-        relative_paths.any? do |path|
-          match_against.any? do |matcher|
-            path =~ matcher
-          end
-        end
-      end
-
-      # Returns the URI the preview server will run on
-      # @return [URI]
-      def uri(host = Socket.gethostname)
-        scheme = https? ? 'https' : 'http'
-        URI("#{scheme}://#{host}:#{@port}/")
-      end
-
-      # An IPv4 address on this machine which should be externally addressable.
-      # @return [String]
-      def public_ip
-        ip = Socket.ip_address_list.find { |ai| ai.ipv4? && !ai.ipv4_loopback? }
-        ip ? ip.ip_address : '127.0.0.1'
+        @app = nil
       end
-
     end
 
     class FilteredWebrickLog < ::WEBrick::Log

data/lib/middleman-core/profiling.rb

@@ -1,31 +1,28 @@
 module Middleman
   module Profiling
-    # The profiler instance. There can only be one!
-    # rubocop:disable TrivialAccessors
-    def self.profiler=(prof)
-      @profiler = prof
-    end
-    def self.profiler
-      @profiler ||= NullProfiler.new
-    end
+    class << self
+      # The profiler instance. There can only be one!
+      attr_writer :profiler
+      def profiler
+        @profiler ||= NullProfiler.new
+      end
 
-    # Start the profiler
-    def self.start
-      profiler.start
-    end
+      # Start the profiler
+      def start
+        profiler.start
+      end
 
-    # Stop the profiler and generate a report. Make sure to call start first
-    def self.report(report_name)
-      profiler.report(report_name)
+      # Stop the profiler and generate a report. Make sure to call start first
+      def report(report_name)
+        profiler.report(report_name)
+      end
     end
 
     # A profiler that does nothing. The default.
     class NullProfiler
-      def start
-      end
+      def start; end
 
-      def report(_)
-      end
+      def report(_); end
     end
 
     # A profiler that uses ruby-prof

data/lib/middleman-core/rack.rb

@@ -0,0 +1,156 @@
+require 'rack'
+require 'rack/file'
+require 'rack/lint'
+require 'rack/head'
+require 'rack/utils'
+require 'webrick'
+
+require 'middleman-core/util'
+require 'middleman-core/logger'
+require 'middleman-core/template_renderer'
+
+# CSSPIE HTC File
+::Rack::Mime::MIME_TYPES['.htc'] = 'text/x-component'
+
+# Let's serve all HTML as UTF-8
+::Rack::Mime::MIME_TYPES['.html'] = 'text/html; charset=utf-8'
+::Rack::Mime::MIME_TYPES['.htm'] = 'text/html; charset=utf-8'
+
+# Sourcemap format
+::Rack::Mime::MIME_TYPES['.map'] = 'application/json; charset=utf-8'
+
+# Create a MIME type for PHP files (for detection by extensions)
+::Rack::Mime::MIME_TYPES['.php'] = 'text/php'
+
+module Middleman
+  class Rack
+    extend Forwardable
+
+    def to_app
+      app = ::Rack::Builder.new
+
+      app.use ::Rack::Lint
+      app.use ::Rack::Head
+
+      @middleman.middleware.each do |middleware|
+        app.use(middleware[:class], *middleware[:options], &middleware[:block])
+      end
+
+      inner_app = self
+      app.map('/') { run inner_app }
+
+      @middleman.mappings.each do |mapping|
+        app.map(mapping[:path], &mapping[:block])
+      end
+
+      app
+    end
+
+    def_delegator :"::Middleman::Logger", :singleton, :logger
+
+    def initialize(middleman)
+      @middleman = middleman
+    end
+
+    # Rack Interface
+    #
+    # @param env Rack environment
+    def call(env)
+      # Store environment, request and response for later
+      req = ::Rack::Request.new(env)
+      res = ::Rack::Response.new
+
+      logger.debug "== Request: #{env['PATH_INFO']}"
+
+      # Catch :halt exceptions and use that response if given
+      catch(:halt) do
+        process_request(env, req, res)
+        res.status = 404
+        res.finish
+      end
+    end
+
+    # Halt the current request and return a response
+    #
+    # @param [String] response Response value
+    def halt(response)
+      throw :halt, response
+    end
+
+    # Core response method. We process the request, check with
+    # the sitemap, and return the correct file, response or status
+    # message.
+    #
+    # @param env
+    # @param [Rack::Request] req
+    # @param [Rack::Response] res
+    def process_request(env, req, res)
+      start_time = Time.now
+
+      request_path = WEBrick::HTTPUtils.unescape(env['PATH_INFO'].dup)
+      if request_path.respond_to? :force_encoding
+        request_path.force_encoding('UTF-8')
+      end
+      request_path = ::Middleman::Util.full_path(request_path, @middleman)
+      full_request_path = File.join(env['SCRIPT_NAME'], request_path) # Path including rack mount
+
+      # Run before callbacks
+      @middleman.execute_callbacks(:before)
+
+      # Get the resource object for this path
+      resource = @middleman.sitemap.find_resource_by_destination_path(request_path.gsub(' ', '%20'))
+
+      # Return 404 if not in sitemap
+      return not_found(res, full_request_path) unless resource && !resource.ignored?
+
+      # If this path is a binary file, send it immediately
+      return send_file(resource, env) if resource.binary?
+
+      res['Content-Type'] = resource.content_type || 'text/plain'
+
+      begin
+        # Write out the contents of the page
+        res.write resource.render({}, rack: { request: req })
+
+        # Valid content is a 200 status
+        res.status = 200
+      rescue Middleman::TemplateRenderer::TemplateNotFound => e
+        res.write "Error: #{e.message}"
+        res.status = 500
+      end
+
+      # End the request
+      logger.debug "== Finishing Request: #{resource.destination_path} (#{(Time.now - start_time).round(2)}s)"
+      halt res.finish
+    end
+
+    # Halt request and return 404
+    def not_found(res, path)
+      path = ::Rack::Utils.escape_html(path)
+      res.status = 404
+      res.write "<html><head></head><body><h1>File Not Found</h1><p>#{path}</p></body></html>"
+      res.finish
+    end
+
+    # Immediately send static file
+    def send_file(resource, env)
+      file     = ::Rack::File.new nil
+      path     = resource.file_descriptor[:full_path]
+      if !file.respond_to?(:path=)
+        request  = ::Rack::Request.new(env)
+        response = file.serving(request, path)
+      else
+        file.path = path
+        response = file.serving(env)
+      end
+      status = response[0]
+      response[1]['Content-Encoding'] = 'gzip' if %w(.svgz .gz).include?(resource.ext)
+      # Do not set Content-Type if status is 1xx, 204, 205 or 304, otherwise
+      # Rack will throw an error (500)
+      if !(100..199).cover?(status) && ![204, 205, 304].include?(status)
+        response[1]['Content-Type'] = resource.content_type || 'application/octet-stream'
+      end
+      halt response
+    end
+  end
+end

data/lib/middleman-core/renderers/coffee_script.rb

@@ -4,21 +4,16 @@ require 'coffee_script'
 module Middleman
   module Renderers
     # CoffeeScript Renderer
-    module CoffeeScript
+    class CoffeeScript < ::Middleman::Extension
       # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          # Tell Tilt to use it as well (for inline scss blocks)
-          ::Tilt.register 'coffee', DebuggingCoffeeScriptTemplate
-          ::Tilt.prefer(DebuggingCoffeeScriptTemplate)
+      def initialize(app, options={}, &block)
+        super
 
-          app.before_configuration do
-            template_extensions coffee: :js
-            DebuggingCoffeeScriptTemplate.middleman_app = self
-          end
-        end
-        alias_method :included, :registered
+        # Tell Tilt to use it as well (for inline scss blocks)
+        ::Tilt.register 'coffee', DebuggingCoffeeScriptTemplate
+        ::Tilt.prefer(DebuggingCoffeeScriptTemplate)
+
+        DebuggingCoffeeScriptTemplate.middleman_app = app
       end
 
       # A Template for Tilt which outputs debug messages
@@ -31,7 +26,7 @@ module Middleman
         # @param [Hash] locals
         # @return [String]
         def evaluate(context, locals, &block)
-          return super if middleman_app.build?
+          return super unless middleman_app.server?
 
           begin
             super