middleman-core 3.3.12 → 4.4.2

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

@@ -1,4 +1,6 @@
 require 'padrino-helpers'
+require 'padrino-helpers/output_helpers'
+require 'padrino-helpers/tag_helpers'
 
 module Middleman
   module MetaPages
@@ -39,16 +41,15 @@ module Middleman
         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.source_file ? @resource.source_file.sub(/^#{Regexp.escape(ENV['MM_ROOT'] + '/')}/, '') : 'Dynamic'
+        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.inspect unless data.empty?
+        props['Data'] = data.to_hash(symbolize_keys: true).inspect unless data.empty?
 
-        meta = @resource.metadata
-        options = meta[:options]
+        options = @resource.options
         props['Options'] = options.inspect unless options.empty?
 
-        locals = meta[:locals].keys
+        locals = @resource.locals.keys
         props['Locals'] = locals.join(', ') unless locals.empty?
 
         props

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

@@ -29,22 +29,22 @@
 
     <h2 id="extensions">Extensions</h2>
     <ul class="extensions">
-      <% extension_config.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>
+      <% [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 %>
-        </ul>
+        </li>
         <% end %>
-      </li>
-
       <% end %>
 
       <% registered_extensions.keys.each do |ext_name| %>

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

@@ -10,7 +10,9 @@
     <div class="container">
       <article id="main">
         <h1>Middleman Information</h1>
-
+        <p>
+          Middleman version <%= Middleman::VERSION %>
+        </p>
         <ul class="nav-list">
           <li>
             <a href="/__middleman/sitemap/">Sitemap</a>

data/lib/middleman-core/meta_pages.rb

@@ -17,9 +17,9 @@ module Middleman
         @middleman = middleman
 
         meta_pages = self
-        @rack_app = Rack::Builder.new do
+        @rack_app = ::Rack::Builder.new do
           # Serve assets from metadata/assets
-          use Rack::Static, urls: ['/assets'], root: File.join(File.dirname(__FILE__), 'meta_pages')
+          use ::Rack::Static, urls: ['/assets'], root: File.join(File.dirname(__FILE__), 'meta_pages')
 
           map '/' do
             run meta_pages.method(:index)
@@ -46,7 +46,7 @@ module Middleman
 
       # Inspect the sitemap
       def sitemap(_)
-        resources = @middleman.inst.sitemap.resources(true)
+        resources = @middleman.sitemap.resources(true)
 
         sitemap_tree = SitemapTree.new
 
@@ -59,10 +59,16 @@ module Middleman
 
       # Inspect configuration
       def config(_)
-        global_config = @middleman.inst.config.all_settings.map { |c| ConfigSetting.new(c) }
+        global_config = @middleman.config.all_settings.map { |c| ConfigSetting.new(c) }
         extension_config = {}
+        auto_activated_config = {}
+
+        @middleman.extensions.each do |ext_name, extension|
+          if ::Middleman::Extensions.auto_activated.include? ext_name
+            auto_activated_config[ext_name] = extension_options(extension)
+            next
+          end
 
-        @middleman.inst.extensions.each do |ext_name, extension|
           if extension.is_a?(Hash)
             # Multiple instance extension
             if extension.size == 1
@@ -72,16 +78,15 @@ module Middleman
                 extension_config["#{ext_name} (#{inst})"] = extension_options(ext)
               end
             end
-          elsif extension.is_a?(::Middleman::Extension)
-            extension_config[ext_name] = extension_options(extension)
           else
-            extension_config[ext_name] = nil
+            extension_config[ext_name] = extension_options(extension)
           end
         end
 
         template('config.html.erb',
                  global_config: global_config,
                  extension_config: extension_config,
+                 auto_activated_config: auto_activated_config,
                  registered_extensions: Middleman::Extensions.registered.dup)
       end
 
@@ -90,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/checks.rb

@@ -0,0 +1,81 @@
+require 'ipaddr'
+
+module Middleman
+  class PreviewServer
+    # Checks for input of preview server
+    module Checks
+      # This one will get all default setup
+      class BasicCheck; end
+
+      # This checks if the server name resolves to the bind_address
+      #
+      # If the users enters:
+      #
+      # 1. server_name: www.example.com (10.0.0.1)
+      # 2. bind_address: 127.0.0.01
+      #
+      # This validation will fail
+      class ServerNameResolvesToBindAddress < BasicCheck
+        private
+
+        attr_reader :resolver
+
+        public
+
+        def initialize
+          @resolver = DnsResolver.new
+        end
+
+        # Validate
+        #
+        # @param [Information] information
+        #   The information to be validated
+        def validate(information)
+          return if resolver.ips_for(information.server_name).include? information.bind_address
+
+          information.valid = false
+          information.reason = format('Server name "%s" does not resolve to bind address "%s"', information.server_name, information.bind_address)
+        end
+      end
+
+      # This validation fails if the user chooses to use an ip address which is
+      # not available on his/her system
+      class InterfaceIsAvailableOnSystem < BasicCheck
+        # Validate
+        #
+        # @param [Information] information
+        #   The information to be validated
+        def validate(information)
+          return if information.bind_address.blank? || information.local_network_interfaces.include?(information.bind_address.to_s) || %w(0.0.0.0 ::).any? { |b| information.bind_address == b } || IPAddr.new('127.0.0.0/8').include?(information.bind_address.to_s)
+
+          information.valid = false
+          information.reason = format('Bind address "%s" is not available on your system. Please use one of %s', information.bind_address, information.local_network_interfaces.map { |i| %("#{i}") }.join(', '))
+        end
+      end
+
+      # This one requires a bind address if the user entered a server name
+      #
+      # If the `bind_address` is blank this check will fail
+      class RequiresBindAddressIfServerNameIsGiven < BasicCheck
+        def validate(information)
+          return unless information.bind_address.blank?
+
+          information.valid = false
+          information.reason = format('Server name "%s" does not resolve to an ip address', information.server_name)
+        end
+      end
+
+      # This validation always fails
+      class DenyAnyAny < BasicCheck
+        # Validate
+        #
+        # @param [Information] information
+        #   The information to be validated
+        def validate(information)
+          information.valid = false
+          information.reason = 'Undefined combination of options "--server-name" and "--bind-address". If you think this is wrong, please file a bug at "https://github.com/middleman/middleman"'
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/preview_server/information.rb

@@ -0,0 +1,273 @@
+require 'ipaddr'
+require 'active_support/core_ext/object/blank'
+require 'middleman-core/preview_server/checks'
+require 'middleman-core/preview_server/server_hostname'
+require 'middleman-core/preview_server/server_ip_address'
+
+module Middleman
+  class PreviewServer
+    # Basic information class to wrap common behaviour
+    class BasicInformation
+      private
+
+      attr_reader :checks, :network_interfaces_inventory
+
+      public
+
+      attr_accessor :bind_address, :server_name, :port, :reason, :valid
+      attr_reader :listeners, :site_addresses
+
+      # Create instance
+      #
+      # @param [String] bind_address
+      #   The bind address of the server
+      #
+      # @param [String] server_name
+      #   The name of the server
+      #
+      # @param [Integer] port
+      #   The port to listen on
+      def initialize(opts={})
+        @bind_address = ServerIpAddress.new(opts[:bind_address])
+        @server_name  = ServerHostname.new(opts[:server_name])
+        @port         = opts[:port]
+        @valid        = true
+
+        @site_addresses = []
+        @listeners = []
+        @checks = []
+
+        # This needs to be check for each use case. Otherwise `Webrick` will
+        # complain about that.
+        @checks << Checks::InterfaceIsAvailableOnSystem.new
+      end
+
+      # Is the given information valid?
+      def valid?
+        valid == true
+      end
+
+      # Pass "self" to validator
+      #
+      # @param [#validate] validator
+      #   The validator
+      def validate_me(validator)
+        validator.validate self, checks
+      end
+
+      def resolve_me(*)
+        fail NoMethodError
+      end
+
+      # Get network information
+      #
+      # @param [#network_interfaces] inventory
+      #   Get list of available network interfaces
+      def show_me_network_interfaces(inventory)
+        @network_interfaces_inventory = inventory
+      end
+
+      # Default is to get all network interfaces
+      def local_network_interfaces
+        network_interfaces_inventory.nil? ? [] : network_interfaces_inventory.network_interfaces(:all)
+      end
+    end
+
+    # This only is used if no other parser is available
+    #
+    # The "default" behaviour is to fail because of "Checks::DenyAnyAny"
+    class DefaultInformation < BasicInformation
+      def initialize(*args)
+        super
+
+        # Make this fail
+        @checks << Checks::DenyAnyAny.new
+      end
+
+      def resolve_me(*); end
+
+      # Always true
+      def self.matches?(*)
+        true
+      end
+    end
+
+    # This one is used if no bind address and no server name is given
+    class AllInterfaces < BasicInformation
+      def initialize(*args)
+        super
+
+        after_init
+      end
+
+      def self.matches?(opts={})
+        opts[:bind_address].blank? && opts[:server_name].blank?
+      end
+
+      # Resolve ips
+      def resolve_me(resolver)
+        hostname          = ServerHostname.new(Socket.gethostname)
+        hostname_ips      = resolver.ips_for(hostname)
+        network_interface = ServerIpAddress.new(Array(local_network_interfaces).first)
+        resolved_name     = ServerHostname.new(resolver.names_for(network_interface).first)
+
+        if includes_array? local_network_interfaces, hostname_ips
+          @server_name = hostname
+          @site_addresses << hostname
+
+          network_interface = ServerIpAddress.new((local_network_interfaces & hostname_ips).first)
+        elsif RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+          @server_name = hostname
+          @site_addresses << hostname
+        elsif !resolved_name.blank?
+          @server_name = resolved_name
+          @site_addresses << resolved_name
+        else
+          @server_name = network_interface
+        end
+
+        @site_addresses << network_interface
+
+        self
+      end
+
+      private
+
+      def includes_array?(a, b)
+        !(a & b).empty?
+      end
+
+      def after_init
+        @listeners << ServerIpAddress.new('::')
+        @listeners << ServerIpAddress.new('0.0.0.0')
+      end
+    end
+
+    # This is used if bind address is 0.0.0.0, the server name needs to be
+    # blank
+    class AllIpv4Interfaces < AllInterfaces
+      def self.matches?(opts={})
+        opts[:bind_address] == '0.0.0.0' && opts[:server_name].blank?
+      end
+
+      # Use only ipv4 interfaces
+      def local_network_interfaces
+        network_interfaces_inventory.nil? ? [] : network_interfaces_inventory.network_interfaces(:ipv4)
+      end
+
+      private
+
+      def after_init
+        @listeners << ServerIpAddress.new('0.0.0.0')
+      end
+    end
+
+    # This is used if bind address is ::, the server name needs to be blank
+    class AllIpv6Interfaces < AllInterfaces
+      def self.matches?(opts={})
+        opts[:bind_address] == '::' && opts[:server_name].blank?
+      end
+
+      # Use only ipv6 interfaces
+      def local_network_interfaces
+        network_interfaces_inventory.nil? ? [] : network_interfaces_inventory.network_interfaces(:ipv6)
+      end
+
+      private
+
+      def after_init
+        @listeners << ServerIpAddress.new('::')
+      end
+    end
+
+    # Used if a bind address is given and the server name is blank
+    class BindAddressInformation < BasicInformation
+      def initialize(*args)
+        super
+
+        @listeners << bind_address
+        @site_addresses << bind_address
+      end
+
+      def self.matches?(opts={})
+        !opts[:bind_address].blank? && opts[:server_name].blank?
+      end
+
+      # Resolv
+      def resolve_me(resolver)
+        @server_name = ServerHostname.new(resolver.names_for(bind_address).first)
+        @site_addresses << @server_name unless @server_name.blank?
+
+        self
+      end
+    end
+
+    # Use if server name is given and bind address is blank
+    class ServerNameInformation < BasicInformation
+      def initialize(*args)
+        super
+
+        @checks << Checks::RequiresBindAddressIfServerNameIsGiven.new
+        @site_addresses << server_name
+      end
+
+      def resolve_me(resolver)
+        @bind_address = ServerIpAddress.new(resolver.ips_for(server_name).first)
+
+        unless bind_address.blank?
+          @listeners << bind_address
+          @site_addresses << bind_address
+        end
+
+        self
+      end
+
+      def self.matches?(opts={})
+        opts[:bind_address].blank? && !opts[:server_name].blank?
+      end
+    end
+
+    # Only used if bind address and server name are given and bind address is
+    # not :: or 0.0.0.0
+    class BindAddressAndServerNameInformation < BasicInformation
+      def initialize(*args)
+        super
+
+        @listeners << bind_address
+        @site_addresses << server_name
+        @site_addresses << bind_address
+
+        @checks << Checks::ServerNameResolvesToBindAddress.new
+      end
+
+      def self.matches?(opts={})
+        !opts[:bind_address].blank? && !opts[:server_name].blank? && !%w(:: 0.0.0.0).include?(opts[:bind_address])
+      end
+
+      def resolve_me(*); end
+    end
+
+    # If the server name is either an ipv4 or ipv6 address, e.g. 127.0.0.1 or
+    # ::1, use this one
+    class ServerNameIsIpInformation < BasicInformation
+      def initialize(opts={})
+        super
+
+        ip = ServerIpAddress.new(server_name.to_s)
+
+        @listeners << ip
+        @site_addresses << ip
+      end
+
+      def resolve_me(*); end
+
+      def self.matches?(opts={})
+        ip = IPAddr.new(opts[:server_name])
+
+        ip.ipv4? || ip.ipv6?
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/middleman-core/preview_server/network_interface_inventory.rb

@@ -0,0 +1,65 @@
+require 'middleman-core/preview_server/server_ip_address'
+
+module Middleman
+  class PreviewServer
+    # This holds information about local network interfaces on the user systemd
+    class NetworkInterfaceInventory
+      # Return all ip interfaces
+      class All
+        def network_interfaces
+          ipv4_addresses = Socket.ip_address_list.select(&:ipv4?).map { |ai| ServerIpv4Address.new(ai.ip_address) }
+          ipv6_addresses = Socket.ip_address_list.select(&:ipv6?).map { |ai| ServerIpv6Address.new(ai.ip_address) }
+
+          ipv4_addresses + ipv6_addresses
+        end
+
+        def self.match?(*)
+          true
+        end
+      end
+
+      # Return all ipv4 interfaces
+      class Ipv4
+        def network_interfaces
+          Socket.ip_address_list.select { |ai| ai.ipv4? && !ai.ipv4_loopback? }.map { |ai| ServerIpv4Address.new(ai.ip_address) }
+        end
+
+        def self.match?(type)
+          :ipv4 == type
+        end
+      end
+
+      # Return all ipv6 interfaces
+      class Ipv6
+        def network_interfaces
+          Socket.ip_address_list.select { |ai| ai.ipv6? && !ai.ipv6_loopback? }.map { |ai| ServerIpv6Address.new(ai.ip_address) }
+        end
+
+        def self.match?(type)
+          :ipv6 == type
+        end
+      end
+
+      private
+
+      attr_reader :types
+
+      public
+
+      def initialize
+        @types = []
+        @types << Ipv4
+        @types << Ipv6
+        @types << All
+      end
+
+      # Return ip interfaces
+      #
+      # @param [Symbol] type
+      #   The type of interface which should be returned
+      def network_interfaces(type=:all)
+        types.find { |t| t.match? type.to_sym }.new.network_interfaces
+      end
+    end
+  end
+end

data/lib/middleman-core/preview_server/server_hostname.rb

@@ -0,0 +1,39 @@
+module Middleman
+  class PreviewServer
+    class ServerHostname
+      class ServerFullHostname < SimpleDelegator
+        def to_s
+          __getobj__.gsub(/\s/, '+')
+        end
+
+        def self.match?(*)
+          true
+        end
+
+        alias to_browser to_s
+      end
+
+      class ServerPlainHostname < SimpleDelegator
+        def to_s
+          __getobj__.gsub(/\s/, '+') + '.local'
+        end
+
+        def self.match?(name)
+          # rubocop:disable Style/CaseEquality
+          name != 'localhost' && /^(?=.{1,255}$)[0-9A-Za-z](?:(?:[0-9A-Za-z]|-){0,61}[0-9A-Za-z])?\.?$/ === name
+          # rubocop:enable Style/CaseEquality
+        end
+
+        alias to_browser to_s
+      end
+
+      def self.new(string)
+        @names = []
+        @names << ServerPlainHostname
+        @names << ServerFullHostname
+
+        @names.find { |n| n.match? string }.new(string)
+      end
+    end
+  end
+end