middleman-core 4.0.0.rc.1 → 4.0.0.rc.2

data/lib/middleman-core/dns_resolver/network_resolver.rb

@@ -0,0 +1,42 @@
+require 'middleman-core/dns_resolver/basic_network_resolver'
+
+module Middleman
+  class DnsResolver
+    # Use network name server to resolve ips and names
+    class NetworkResolver < BasicNetworkResolver
+      def initialize(opts={})
+        super
+
+        @resolver = opts.fetch(:resolver, Resolv::DNS.new(nameserver_config))
+        self.timeouts = timeouts
+      end
+
+      private
+
+      # Hosts + Ports for MDNS resolver
+      #
+      # This looks for MM_MDNSRC in your environment. If you are going to use
+      # IPv6-addresses: Make sure you do not forget to add the port at the end.
+      #
+      # MM_MDNSRC=ip:port ip:port
+      #
+      # @return [Hash]
+      #   Returns the configuration for the nameserver
+      #
+      # @example
+      #   export MM_MDNSRC="224.0.0.251:5353 ff02::fb:5353"
+      #
+      def nameserver_config
+        return unless ENV.key?('MM_DNSRC') && ENV['MM_DNSRC']
+
+        address, port = ENV['MM_DNSRC'].split(/:/)
+
+        {
+          nameserver_port: [[address, port.to_i]]
+        }
+      rescue StandardError
+        {}
+      end
+    end
+  end
+end

data/lib/middleman-core/extension.rb

@@ -61,7 +61,7 @@ module Middleman
   # * `app.before_render {|body, path, locs, template_class| ... }` - Manipulate template sources before they are rendered.
   # * `app.after_render {|content, path, locs, template_class| ... }` - Manipulate output text after a template has been rendered. It is also common to install a Rack middleware to do this instead.
   # * `app.ready { ... }` - Run code once Middleman is ready to serve or build files (after `after_configuration`).
-  # * `app.compass_config { |compass_config| ... }` - Manipulate the Compass configuration after it has been set up.
+
   #
   # @see http://middlemanapp.com/advanced/custom/ Middleman Custom Extensions Documentation
   class Extension

data/lib/middleman-core/extensions/asset_hash.rb

@@ -3,7 +3,7 @@ require 'middleman-core/util'
 require 'middleman-core/rack'
 
 class Middleman::Extensions::AssetHash < ::Middleman::Extension
-  option :exts, %w(.jpg .jpeg .png .gif .webp .js .css .otf .woff .woff2 .eot .ttf .svg), 'List of extensions that get asset hashes appended to them.'
+  option :exts, %w(.jpg .jpeg .png .gif .webp .js .css .otf .woff .woff2 .eot .ttf .svg .svgz), 'List of extensions that get asset hashes appended to them.'
   option :ignore, [], 'Regexes of filenames to skip adding asset hashes to'
 
   def initialize(app, options_hash={}, &block)
@@ -17,10 +17,10 @@ class Middleman::Extensions::AssetHash < ::Middleman::Extension
   def after_configuration
     # Allow specifying regexes to ignore, plus always ignore apple touch icons
     @ignore = Array(options.ignore) + [/^apple-touch-icon/]
-    
+
     app.use ::Middleman::Middleware::InlineURLRewriter,
             id: :asset_hash,
-            url_extensions: options.exts,
+            url_extensions: options.exts.sort.reverse,
             source_extensions: %w(.htm .html .php .css .js),
             ignore: @ignore,
             middleman_app: app,

data/lib/middleman-core/extensions/automatic_image_sizes.rb

@@ -23,7 +23,15 @@ class Middleman::Extensions::AutomaticImageSizes < ::Middleman::Extension
 
         if file && file[:full_path].exist?
           begin
-            width, height = ::FastImage.size(file[:full_path].to_s, raise_on_failure: true)
+            full_path = file[:full_path].to_s
+            width, height = ::FastImage.size(full_path, raise_on_failure: true)
+            # Check for @2x and @3x image
+            retina = full_path.match(/@(\d)x\.[a-zA-Z]{3,4}$/)
+            if retina
+              factor = retina[1].to_i
+              width /= factor
+              height /= factor
+            end
             params[:width]  = width
             params[:height] = height
           rescue FastImage::UnknownImageType

data/lib/middleman-core/extensions/minify_css.rb

@@ -8,12 +8,16 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
     require 'sass'
     SassCompressor
   }, 'Set the CSS compressor to use.'
+  option :content_types, %w(text/css), 'Content types of resources that contain CSS'
+  option :inline_content_types, %w(text/html text/php), 'Content types of resources that contain inline CSS'
 
   def ready
     # Setup Rack middleware to minify CSS
     app.use Rack, compressor: options[:compressor],
                   ignore: Array(options[:ignore]) + [/\.min\./],
-                  inline: options[:inline]
+                  inline: options[:inline],
+                  content_types: options[:content_types],
+                  inline_content_types: options[:inline_content_types]
   end
 
   class SassCompressor
@@ -45,6 +49,8 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
       @compressor = options.fetch(:compressor)
       @compressor = @compressor.to_proc if @compressor.respond_to? :to_proc
       @compressor = @compressor.call if @compressor.is_a? Proc
+      @content_types = options[:content_types]
+      @inline_content_types = options[:inline_content_types]
     end
 
     # Rack interface
@@ -53,19 +59,18 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
     def call(env)
       status, headers, response = @app.call(env)
 
-      if inline_html_content?(env['PATH_INFO'])
-        minified = ::Middleman::Util.extract_response_text(response)
-        minified.gsub!(INLINE_CSS_REGEX) do
-          $1 << @compressor.compress($2) << $3
-        end
+      content_type = headers['Content-Type'].try(:slice, /^[^;]*/)
+      path = env['PATH_INFO']
 
+      minified = if @inline && minifiable_inline?(content_type)
+        minify_inline(::Middleman::Util.extract_response_text(response))
+      elsif minifiable?(content_type) && !ignore?(path)
+        minify(::Middleman::Util.extract_response_text(response))
+      end
+
+      if minified
         headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
         response = [minified]
-      elsif standalone_css_content?(env['PATH_INFO'])
-        minified_css = @compressor.compress(::Middleman::Util.extract_response_text(response))
-
-        headers['Content-Length'] = ::Rack::Utils.bytesize(minified_css).to_s
-        response = [minified_css]
       end
 
       [status, headers, response]
@@ -73,14 +78,41 @@ class Middleman::Extensions::MinifyCss < ::Middleman::Extension
 
     private
 
-    Contract String => Bool
-    def inline_html_content?(path)
-      (path.end_with?('.html') || path.end_with?('.php')) && @inline
+    # Whether the path should be ignored
+    # @param [String] path
+    # @return [Boolean]
+    def ignore?(path)
+      @ignore.any? { |ignore| Middleman::Util.path_match(ignore, path) }
+    end
+
+    # Whether this type of content can be minified
+    # @param [String, nil] content_type
+    # @return [Boolean]
+    def minifiable?(content_type)
+      @content_types.include?(content_type)
     end
 
-    Contract String => Bool
-    def standalone_css_content?(path)
-      path.end_with?('.css') && @ignore.none? { |ignore| Middleman::Util.path_match(ignore, path) }
+    # Whether this type of content contains inline content that can be minified
+    # @param [String, nil] content_type
+    # @return [Boolean]
+    def minifiable_inline?(content_type)
+      @inline_content_types.include?(content_type)
+    end
+
+    # Minify the content
+    # @param [String] content
+    # @return [String]
+    def minify(content)
+      @compressor.compress(content)
+    end
+
+    # Detect and minify inline content
+    # @param [String] content
+    # @return [String]
+    def minify_inline(content)
+      content.gsub(INLINE_CSS_REGEX) do
+        $1 + minify($2) + $3
+      end
     end
   end
 end

data/lib/middleman-core/extensions/minify_javascript.rb

@@ -8,17 +8,22 @@ class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
     require 'uglifier'
     ::Uglifier.new
   }, 'Set the JS compressor to use.'
+  option :content_types, %w(application/javascript), 'Content types of resources that contain JS'
+  option :inline_content_types, %w(text/html text/php), 'Content types of resources that contain inline JS'
 
   def ready
-    # Setup Rack middleware to minify CSS
+    # Setup Rack middleware to minify JS
     app.use Rack, compressor: options[:compressor],
                   ignore: Array(options[:ignore]) + [/\.min\./],
-                  inline: options[:inline]
+                  inline: options[:inline],
+                  content_types: options[:content_types],
+                  inline_content_types: options[:inline_content_types]
   end
 
   # Rack middleware to look for JS and compress it
   class Rack
     include Contracts
+    INLINE_JS_REGEX = /(<script[^>]*>\s*(?:\/\/(?:(?:<!--)|(?:<!\[CDATA\[))\n)?)(.*?)((?:(?:\n\s*)?\/\/(?:(?:-->)|(?:\]\]>)))?\s*<\/script>)/m
 
     # Init
     # @param [Class] app
@@ -36,6 +41,8 @@ class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
       @compressor = options.fetch(:compressor)
       @compressor = @compressor.to_proc if @compressor.respond_to? :to_proc
       @compressor = @compressor.call if @compressor.is_a? Proc
+      @content_types = options[:content_types]
+      @inline_content_types = options[:inline_content_types]
     end
 
     # Rack interface
@@ -44,25 +51,18 @@ class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
     def call(env)
       status, headers, response = @app.call(env)
 
-      path = env['PATH_INFO']
+      type = headers['Content-Type'].try(:slice, /^[^;]*/)
+      @path = env['PATH_INFO']
 
-      begin
-        if @inline && (path.end_with?('.html') || path.end_with?('.php'))
-          uncompressed_source = ::Middleman::Util.extract_response_text(response)
-
-          minified = minify_inline_content(uncompressed_source)
-
-          headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
-          response = [minified]
-        elsif path.end_with?('.js') && @ignore.none? { |ignore| Middleman::Util.path_match(ignore, path) }
-          uncompressed_source = ::Middleman::Util.extract_response_text(response)
-          minified = @compressor.compress(uncompressed_source)
+      minified = if @inline && minifiable_inline?(type)
+        minify_inline(::Middleman::Util.extract_response_text(response))
+      elsif minifiable?(type) && !ignore?(@path)
+        minify(::Middleman::Util.extract_response_text(response))
+      end
 
-          headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
-          response = [minified]
-        end
-      rescue ExecJS::ProgramError => e
-        warn "WARNING: Couldn't compress JavaScript in #{path}: #{e.message}"
+      if minified
+        headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
+        response = [minified]
       end
 
       [status, headers, response]
@@ -70,20 +70,50 @@ class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
 
     private
 
-    Contract String => String
-    def minify_inline_content(uncompressed_source)
-      uncompressed_source.gsub(/(<script[^>]*>\s*(?:\/\/(?:(?:<!--)|(?:<!\[CDATA\[))\n)?)(.*?)((?:(?:\n\s*)?\/\/(?:(?:-->)|(?:\]\]>)))?\s*<\/script>)/m) do |match|
+    # Whether the path should be ignored
+    # @param [String] path
+    # @return [Boolean]
+    def ignore?(path)
+      @ignore.any? { |ignore| Middleman::Util.path_match(ignore, path) }
+    end
+
+    # Whether this type of content can be minified
+    # @param [String, nil] content_type
+    # @return [Boolean]
+    def minifiable?(content_type)
+      @content_types.include?(content_type)
+    end
+
+    # Whether this type of content contains inline content that can be minified
+    # @param [String, nil] content_type
+    # @return [Boolean]
+    def minifiable_inline?(content_type)
+      @inline_content_types.include?(content_type)
+    end
+
+    # Minify the content
+    # @param [String] content
+    # @return [String]
+    def minify(content)
+      @compressor.compress(content)
+    rescue ExecJS::ProgramError => e
+      warn "WARNING: Couldn't compress JavaScript in #{@path}: #{e.message}"
+      content
+    end
+
+    # Detect and minify inline content
+    # @param [String] content
+    # @return [String]
+    def minify_inline(content)
+      content.gsub(INLINE_JS_REGEX) do |match|
         first = $1
-        javascript = $2
+        inline_content = $2
         last = $3
 
-        # Only compress script tags that contain JavaScript (as opposed
-        # to something like jQuery templates, identified with a "text/html"
-        # type.
-        if first =~ /<script>/ || first.include?('text/javascript')
-          minified_js = @compressor.compress(javascript)
-
-          first << minified_js << last
+        # Only compress script tags that contain JavaScript (as opposed to
+        # something like jQuery templates, identified with a "text/html" type).
+        if first.include?('<script>') || first.include?('text/javascript')
+          first + minify(inline_content) + last
         else
           match
         end

data/lib/middleman-core/extensions/relative_assets.rb

@@ -22,6 +22,19 @@ class Middleman::Extensions::RelativeAssets < ::Middleman::Extension
             proc: method(:rewrite_url)
   end
 
+  helpers do
+    # asset_url override for relative assets
+    # @param [String] path
+    # @param [String] prefix
+    # @param [Hash] options Additional options.
+    # @return [String]
+    def asset_url(path, prefix='', options={})
+      options[:relative] = true unless options.key?(:relative)
+
+      super(path, prefix, options)
+    end
+  end
+
   Contract String, Or[String, Pathname], Any => Maybe[String]
   def rewrite_url(asset_path, dirpath, request_path)
     uri = ::Addressable::URI.parse(asset_path)

data/lib/middleman-core/file_renderer.rb

@@ -29,7 +29,7 @@ module Middleman
     # @param [Class] context
     # @return [String]
     Contract Hash, Hash, Any, Maybe[Proc] => String
-    def render(locs={}, opts={}, context, &block)
+    def render(locs, opts, context, &block)
       path = @path.dup
 
       # Detect the remdering engine from the extension
@@ -97,7 +97,7 @@ module Middleman
     Contract String
     def template_data_for_file
       if @app.extensions[:front_matter]
-        @app.extensions[:front_matter].template_data_for_file(@path) || ''
+        @app.extensions[:front_matter].template_data_for_file(@path) || File.read(@path)
       else
         file = @app.files.find(:source, @path)
         file.read if file

data/lib/middleman-core/meta_pages.rb

@@ -95,7 +95,7 @@ module Middleman
       # Render a template with the given name and locals
       def template(template_name, locals={})
         template_path = File.join(File.dirname(__FILE__), 'meta_pages', 'templates', template_name)
-        content = Tilt.new(template_path).render(nil, locals)
+        content = Tilt.new(template_path).render(::Object.new, locals)
         response(content)
       end
 

data/lib/middleman-core/preview_server.rb

@@ -1,32 +1,50 @@
 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
       extend Forwardable
 
-      attr_reader :app, :host, :port, :ssl_certificate, :ssl_private_key
-      def_delegator :app, :logger
-
-      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={})
+        # Do not buffer output, otherwise testing of output does not work
+        $stdout.sync = true
+        $stderr.sync = true
+
         @options = opts
+        @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}"
-        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
@@ -38,6 +56,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
 
@@ -56,7 +89,7 @@ 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
@@ -67,13 +100,13 @@ module Middleman
       # Simply stop, then start the server
       # @return [void]
       def reload
-        logger.info '== The Middleman is reloading'
+        app.logger.info '== The Middleman is reloading'
 
         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
 
@@ -84,7 +117,7 @@ module Middleman
 
         mount_instance(app)
 
-        logger.info '== The Middleman has reloaded'
+        app.logger.info '== The Middleman has reloaded'
       end
 
       # Stop the current instance, exit Webrick
@@ -96,7 +129,7 @@ module Middleman
 
       private
 
-      def new_app
+      def initialize_new_app
         opts = @options.dup
 
         ::Middleman::Logger.singleton(
@@ -110,8 +143,10 @@ module Middleman
           config[:watcher_force_polling] = opts[:force_polling]
           config[:watcher_latency] = opts[:latency]
 
-          config[:host] = opts[:host] if opts[:host]
           config[:port] = opts[:port] if opts[:port]
+          config[:bind_address]    = opts[:bind_address]
+          config[:server_name]     = opts[:server_name]
+          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]
 
@@ -120,13 +155,13 @@ module Middleman
               %r{^config\.rb$},
               %r{^environments/[^\.](.*)\.rb$},
               %r{^lib/[^\.](.*)\.rb$},
-              %r{^#{@app.config[:helpers_dir]}/[^\.](.*)\.rb$}
+              %r{^#{config[:helpers_dir]}/[^\.](.*)\.rb$}
             ]
 
             # config.rb
             watcher = files.watch :reload,
-                        path: root,
-                        only: match_against
+                                  path: root,
+                                  only: match_against
 
             # Hack around node_modules in root.
             watcher.listener.ignore(/^node_modules/)
@@ -139,9 +174,16 @@ module Middleman
           end
         end
 
-        @host = app.config[:host]
-        @port = app.config[:port]
-        @https = app.config[:https]
+        # store configured port to make a check later on possible
+        configured_port = app.config[:port]
+
+        # Use configuration values to set `bind_address` etc. in
+        # `server_information`
+        server_information.use app.config
+
+        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 app.config[:port] == configured_port
+
+        @environment = app.config[:environment]
 
         @ssl_certificate = app.config[:ssl_certificate]
         @ssl_private_key = app.config[:ssl_private_key]
@@ -179,13 +221,14 @@ module Middleman
       # @return [void]
       def setup_webrick(is_logging)
         http_opts = {
-          BindAddress: host,
-          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
@@ -198,6 +241,9 @@ module Middleman
               %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
 
@@ -210,11 +256,44 @@ module Middleman
         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=#{unused_tcp_port}"
-          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]
@@ -236,23 +315,6 @@ module Middleman
 
         @app = nil
       end
-
-      # Returns the URI the preview server will run on
-      # @return [URI]
-      def uri
-        host = (@host == '0.0.0.0') ? 'localhost' : @host
-        scheme = https? ? 'https' : 'http'
-        URI("#{scheme}://#{host}:#{@port}")
-      end
-
-      # Returns unused TCP port
-      # @return [Fixnum]
-      def unused_tcp_port
-        server = TCPServer.open(0)
-        port = server.addr[1]
-        server.close
-        port
-      end
     end
 
     class FilteredWebrickLog < ::WEBrick::Log