middleman-core-with-external-sources-watch-fix 4.1.0

data/lib/middleman-core/meta_pages/config_setting.rb

@@ -0,0 +1,37 @@
+require 'pp'
+
+module Middleman
+  module MetaPages
+    # View class for a config entry
+    class ConfigSetting
+      include Padrino::Helpers::OutputHelpers
+      include Padrino::Helpers::TagHelpers
+
+      def initialize(setting)
+        @setting = setting
+      end
+
+      def render
+        content = ''
+        key_classes = ['key']
+        key_classes << 'modified' if @setting.value_set?
+        content << content_tag(:span, @setting.key.pretty_inspect.strip, class: key_classes.join(' '))
+        content << ' = '
+        content << content_tag(:span, @setting.value.pretty_inspect.strip, class: 'value')
+        if @setting.default && @setting.value_set? && @setting.default != @setting.value
+          content << content_tag(:span, class: 'default') do
+            "(Default: #{@setting.default.inspect})"
+          end
+        end
+
+        if @setting.description
+          content << content_tag(:p, class: 'description') do
+            @setting.description
+          end
+        end
+
+        content
+      end
+    end
+  end
+end

data/lib/middleman-core/meta_pages/sitemap_resource.rb

@@ -0,0 +1,65 @@
+require 'padrino-helpers'
+
+module Middleman
+  module MetaPages
+    # View class for a sitemap resource
+    class SitemapResource
+      include Padrino::Helpers::OutputHelpers
+      include Padrino::Helpers::TagHelpers
+
+      def initialize(resource)
+        @resource = resource
+      end
+
+      def render
+        classes = 'resource-details'
+        classes << ' ignored' if @resource.ignored?
+        content_tag :div, class: classes do
+          content_tag :table do
+            content = ''
+            resource_properties.each do |label, value|
+              content << content_tag(:tr) do
+                row_content = ''
+                row_content << content_tag(:th, label)
+                row_content << content_tag(:td, value)
+                row_content.html_safe
+              end
+            end
+            content.html_safe
+          end
+        end
+      end
+
+      # A hash of label to value for all the properties we want to display
+      def resource_properties
+        props = {}
+        props['Path'] = @resource.path
+
+        build_path = @resource.destination_path
+        build_path = 'Not built' if ignored?
+        props['Build Path'] = build_path if @resource.path != build_path
+        props['URL'] = content_tag(:a, @resource.url, href: @resource.url) unless ignored?
+        props['Source File'] = @resource.file_descriptor ? @resource.file_descriptor[:full_path].to_s.sub(/^#{Regexp.escape(ENV['MM_ROOT'] + '/')}/, '') : 'Dynamic'
+
+        data = @resource.data
+        props['Data'] = data.to_hash(symbolize_keys: true).inspect unless data.empty?
+
+        options = @resource.options
+        props['Options'] = options.inspect unless options.empty?
+
+        locals = @resource.locals.keys
+        props['Locals'] = locals.join(', ') unless locals.empty?
+
+        props
+      end
+
+      def ignored?
+        @resource.ignored?
+      end
+
+      def css_classes
+        ['resource'].concat(ignored? ? ['ignored'] : [])
+      end
+    end
+  end
+end

data/lib/middleman-core/meta_pages/sitemap_tree.rb

@@ -0,0 +1,77 @@
+require 'middleman-core/meta_pages/sitemap_resource'
+
+module Middleman
+  module MetaPages
+    # View class for a sitemap tree
+    class SitemapTree
+      def initialize
+        @children = {}
+      end
+
+      def add_resource(resource)
+        add_path(resource.path.split('/'), resource)
+      end
+
+      def render
+        sorted_children_keys = @children.keys.sort do |a, b|
+          a_subtree = @children[a]
+          b_subtree = @children[b]
+          if a_subtree.is_a? SitemapResource
+            if b_subtree.is_a? SitemapResource
+              a.downcase <=> b.downcase
+            else
+              1
+            end
+          elsif b_subtree.is_a? SitemapResource
+            if a_subtree.is_a? SitemapResource
+              b.downcase <=> a.downcase
+            else
+              -1
+            end
+          else
+            a.downcase <=> b.downcase
+          end
+        end
+
+        sorted_children_keys.reduce('') do |content, path_part|
+          subtree = @children[path_part]
+          content << "<details class='#{subtree.css_classes.join(' ')}'>"
+          content << '<summary>'
+          content << "<i class='icon-folder-open'></i>" unless subtree.is_a? SitemapResource
+          content << "#{path_part}</summary>"
+          content << subtree.render
+          content << '</details>'
+        end
+      end
+
+      def css_classes
+        ['tree'].concat(ignored? ? ['ignored'] : [])
+      end
+
+      def ignored?
+        @children.values.all?(&:ignored?)
+      end
+
+      protected
+
+      def add_path(path_parts, resource)
+        first_part = path_parts.first
+
+        if path_parts.size == 1
+          sitemap_class = SitemapResource
+          # Allow special sitemap resources to use custom metadata view calsses
+          sitemap_class = resource.meta_pages_class if resource.respond_to? :meta_pages_class
+
+          @children[first_part] = sitemap_class.new(resource)
+        else
+          @children[first_part] ||= SitemapTree.new
+          @children[first_part].add_path(path_parts[1..-1], resource)
+        end
+      end
+
+      def to_s
+        'Sitemap Tree'
+      end
+    end
+  end
+end

data/lib/middleman-core/meta_pages/templates/config.html.erb

@@ -0,0 +1,57 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Middleman Configuration</title>
+    <link type="text/css" rel="stylesheet" href="/__middleman/assets/meta.css">
+    <link type="text/css" rel="stylesheet" href="/__middleman/assets/config.css">
+  </head>
+
+  <body>
+    <div class="container">
+      <article id="main">
+    <a href="/__middleman/">&laquo; back</a>
+    <h1>Middleman Configuration</h1>
+
+    <p>This page shows the current configuration of your Middleman application. <a href="http://middlemanapp.com/advanced/configuration/">Read more about configuring Middleman.</a></p>
+
+    <p>
+      <a href="#core">Core configuration</a>
+      | <a href="#extensions">Extensions</a>
+    </p>
+
+    <h2 id="core">Core Configuration</h2>
+    <ul class="settings">
+    <% global_config.each do |setting| %>
+      <li class="setting"><%= setting.render %></li>
+    <% end %>
+    </ul>
+
+    <h2 id="extensions">Extensions</h2>
+    <ul class="extensions">
+      <% [extension_config, auto_activated_config].each do |extensions| %>
+        <% extensions.each do |ext_name, configs| %>
+        <li>
+          <% registered_extensions.delete(ext_name) %>
+
+          <span class="extension active">:<%= ext_name %></span>
+
+          <% if configs && !configs.empty? %>
+          <ul class="settings">
+            <% configs.each do |setting| %>
+            <li class="setting"><%= setting.render %></li>
+            <% end %>
+          </ul>
+          <% end %>
+        </li>
+        <% end %>
+      <% end %>
+
+      <% registered_extensions.keys.each do |ext_name| %>
+      <li><span class="extension inactive"><%= ext_name.inspect %></span></li>
+      <% end %>
+    </ul>
+    </article>
+    </div>
+  </body>
+</html>

data/lib/middleman-core/meta_pages/templates/index.html.erb

@@ -0,0 +1,31 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>Middleman Info</title>
+    <link type="text/css" rel="stylesheet" href="/__middleman/assets/meta.css">
+  </head>
+
+  <body>
+    <div class="container">
+      <article id="main">
+        <h1>Middleman Information</h1>
+
+        <ul class="nav-list">
+          <li>
+            <a href="/__middleman/sitemap/">Sitemap</a>
+            <p>The structure of your site as understood by Middleman.</p>
+          </li>
+          <li>
+            <a href="/__middleman/config/">Configuration</a>
+            <p>All available configuration options and their current values.</p>
+          </li>
+          <li>
+            <a href="http://middlemanapp.com">Middleman Guides</a>
+            <p>Documentation about Middleman's features.</p>
+          </li>
+        </ul>
+      </article>
+    </div>
+  </body>
+</html>

data/lib/middleman-core/meta_pages/templates/sitemap.html.erb

@@ -0,0 +1,30 @@
+<!doctype html>
+<html>
+  <head>
+    <meta charset="utf-8">
+
+    <title>Middleman Sitemap</title>
+
+
+    <link type="text/css" rel="stylesheet" href="/__middleman/assets/meta.css">
+    <link type="text/css" rel="stylesheet" href="/__middleman/assets/sitemap.css">
+    <script src="/__middleman/assets/jquery-1.8.2.min.js"></script>
+    <script src="/__middleman/assets/jquery.details-1.6.min.js"></script>
+    <script src="/__middleman/assets/sitemap.js"></script>
+  </head>
+
+  <body>
+    <div class="container">
+      <article id="main">
+        <a href="/__middleman/">&laquo; back</a>
+        <h1>Middleman Sitemap</h1>
+
+        <p>This page shows all of the pages in
+        <a href="http://middlemanapp.com/advanced/sitemap/">the sitemap</a>,
+        Middleman's view of your site.</p>
+
+        <%= sitemap_tree.render %>
+      </article>
+    </div>
+  </body>
+</html>

data/lib/middleman-core/preview_server.rb

@@ -0,0 +1,328 @@
+require 'webrick'
+require 'webrick/https'
+require 'openssl'
+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
+  class PreviewServer
+    class << self
+      extend Forwardable
+
+      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)
+
+        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
+        @initialized = true
+
+        register_signal_handlers
+
+        # Save the last-used @options so it may be re-used when
+        # 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
+
+          # $mm_shutdown is set by the signal handler
+          if $mm_shutdown
+            shutdown
+            exit
+          elsif $mm_reload
+            $mm_reload = false
+            reload
+          end
+        end
+      end
+
+      # Detach the current Middleman::Application instance
+      # @return [void]
+      def stop
+        begin
+          app.logger.info '== The Middleman is shutting down'
+        rescue
+          # if the user closed their terminal STDOUT/STDERR won't exist
+        end
+
+        unmount_instance
+      end
+
+      # Simply stop, then start the server
+      # @return [void]
+      def reload
+        app.logger.info '== The Middleman is reloading'
+
+        begin
+          app = initialize_new_app
+        rescue => e
+          $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)
+
+        app.logger.info '== The Middleman has reloaded'
+      end
+
+      # Stop the current instance, exit Webrick
+      # @return [void]
+      def shutdown
+        stop
+        @webrick.shutdown
+      end
+
+      private
+
+      def initialize_new_app
+        opts = @options.dup
+
+        ::Middleman::Logger.singleton(
+          opts[:debug] ? 0 : 1,
+          opts[:instrumenting] || false
+        )
+
+        app = ::Middleman::Application.new do
+          config[:environment] = opts[:environment].to_sym if opts[:environment]
+          config[:watcher_disable] = opts[:disable_watcher]
+          config[:watcher_force_polling] = opts[:force_polling]
+          config[:watcher_latency] = opts[:latency]
+
+          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]
+
+          ready do
+            unless config[:watcher_disable]
+              match_against = [
+                %r{^config\.rb$},
+                %r{^environments/[^\.](.*)\.rb$},
+                %r{^lib/[^\.](.*)\.rb$},
+                %r{^#{config[:helpers_dir]}/[^\.](.*)\.rb$}
+              ]
+
+              # config.rb
+              watcher = files.watch :reload,
+                                    path: root,
+                                    only: match_against
+
+              # Hack around node_modules in root.
+              watcher.listener.ignore(/^node_modules/)
+
+              # Hack around sass cache in root.
+              watcher.listener.ignore(/^\.sass-cache/)
+
+              # Hack around bundler cache in root.
+              watcher.listener.ignore(/^vendor\/bundle/)
+            end
+          end
+        end
+
+        # 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]
+
+        app.files.on_change :reload do
+          $mm_reload = true
+          @webrick.stop
+        end
+
+        # Add in the meta pages application
+        meta_app = Middleman::MetaPages::Application.new(app)
+        app.map '/__middleman' do
+          run meta_app
+        end
+
+        app
+      end
+
+      # Trap some interupt signals and shut down smoothly
+      # @return [void]
+      def register_signal_handlers
+        %w(INT HUP TERM QUIT).each do |sig|
+          next unless Signal.list[sig]
+
+          Signal.trap(sig) do
+            # Do as little work as possible in the signal context
+            $mm_shutdown = true
+
+            @webrick.stop
+          end
+        end
+      end
+
+      # Initialize webrick
+      # @return [void]
+      def setup_webrick(is_logging)
+        http_opts = {
+          Port: server_information.port,
+          AccessLog: [],
+          ServerName: server_information.server_name,
+          BindAddress: server_information.bind_address.to_s,
+          DoNotReverseLookup: true
+        }
+
+        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
+          else
+            # use a generated self-signed cert
+            http_opts[:SSLCertName] = [
+              %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
+
+        http_opts[:Logger] = if is_logging
+          FilteredWebrickLog.new
+        else
+          ::WEBrick::Log.new(nil, 0)
+        end
+
+        begin
+          ::WEBrick::HTTPServer.new(http_opts)
+        rescue Errno::EADDRINUSE
+          $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]
+      def mount_instance(app)
+        @app = app
+
+        @webrick ||= setup_webrick(@options[:debug] || false)
+
+        rack_app = ::Middleman::Rack.new(@app).to_app
+        @webrick.mount '/', ::Rack::Handler::WEBrick, rack_app
+      end
+
+      # Detach the current Middleman::Application instance
+      # @return [void]
+      def unmount_instance
+        @webrick.unmount '/'
+
+        @app.shutdown!
+
+        @app = nil
+      end
+    end
+
+    class FilteredWebrickLog < ::WEBrick::Log
+      def log(level, data)
+        super(level, data) unless data =~ %r{Could not determine content-length of response body.}
+      end
+    end
+  end
+end