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

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

@@ -0,0 +1,153 @@
+require 'middleman-core/dns_resolver'
+require 'middleman-core/preview_server/information'
+require 'middleman-core/preview_server/network_interface_inventory'
+require 'middleman-core/preview_server/tcp_port_prober'
+require 'middleman-core/preview_server/server_information_validator'
+
+module Middleman
+  class PreviewServer
+    # This class holds all information which the preview server needs to setup a listener
+    #
+    # * server name
+    # * bind address
+    # * port
+    #
+    # Furthermore it probes for a free tcp port, if the default one 4567 is not available.
+    class ServerInformation
+      private
+
+      attr_reader :resolver, :validator, :network_interface_inventory, :informations, :tcp_port_prober
+
+      public
+
+      attr_writer :https
+
+      def initialize(opts={})
+        @resolver     = opts.fetch(:resolver, DnsResolver.new)
+        @validator    = opts.fetch(:validator, ServerInformationValidator.new)
+        @network_interface_inventory = opts.fetch(:network_interface_inventory, NetworkInterfaceInventory.new)
+        @tcp_port_prober = opts.fetch(:tcp_port_prober, TcpPortProber.new)
+
+        @informations = []
+        @informations << AllInterfaces
+        @informations << AllIpv4Interfaces
+        @informations << AllIpv6Interfaces
+        @informations << ServerNameIsIpInformation
+        @informations << ServerNameInformation
+        @informations << BindAddressInformation
+        @informations << BindAddressAndServerNameInformation
+        @informations << DefaultInformation
+      end
+
+      # The information
+      #
+      # Is cached
+      def information
+        return @information if @information
+
+        # The `DefaultInformation`-class always returns `true`, so there's
+        # always a klass available and find will never return nil
+        listener_klass = informations.find { |l| l.matches? bind_address: @bind_address, server_name: @server_name }
+        @information = listener_klass.new(bind_address: @bind_address, server_name: @server_name)
+
+        @information.show_me_network_interfaces(network_interface_inventory)
+        @information.resolve_me(resolver)
+        @information.port = tcp_port_prober.port(@port)
+        @information.validate_me(validator)
+
+        @information
+      end
+
+      # Use a middleman configuration to get information
+      #
+      # @param [#[]] config
+      #   The middleman config
+      def use(config)
+        @bind_address = config[:bind_address]
+        @port         = config[:port]
+        @server_name  = config[:server_name]
+        @https        = config[:https]
+
+        config[:bind_address] = bind_address
+        config[:port]         = port
+        config[:server_name]  = server_name
+        config[:https]        = https?
+      end
+
+      # Make information of internal server class avaible to make debugging
+      # easier. This can be used to log the class which was used to determine
+      # the preview server settings
+      #
+      # @return [String]
+      #   The name of the class
+      def handler
+        information.class.to_s
+      end
+
+      # Is the server information valid?
+      #
+      # This is used to output a helpful error message, which can be stored in
+      # `#reason`.
+      #
+      # @return [TrueClass, FalseClass]
+      #   The result
+      def valid?
+        information.valid?
+      end
+
+      # The reason why the information is NOT valid
+      #
+      # @return [String]
+      #   The reason why the information is not valid
+      def reason
+        information.reason
+      end
+
+      # The server name
+      #
+      # @return [String]
+      #   The name of the server
+      def server_name
+        information.server_name
+      end
+
+      # The bind address of server
+      #
+      # @return [String]
+      #   The bind address of the server
+      def bind_address
+        information.bind_address
+      end
+
+      # The port on which the server should listen
+      #
+      # @return [Integer]
+      #   The port number
+      def port
+        information.port
+      end
+
+      # A list of site addresses
+      #
+      # @return [Array]
+      #   A list of addresses which can be used to access the middleman preview
+      #   server
+      def site_addresses
+        information.site_addresses
+      end
+
+      # A list of listeners
+      #
+      # @return [Array]
+      #   A list of bind address where the
+      def listeners
+        information.listeners
+      end
+
+      # Is https enabled?
+      def https?
+        @https == true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Middleman
+  class PreviewServer
+    # This class wraps server information to be used in call back
+    #
+    # * listeners
+    # * port
+    # * server name
+    # * site_addresses
+    #
+    # All information is "dupped" and the callback is not meant to be used to
+    # modify these information.
+    class ServerInformationCallbackProxy
+      attr_reader :server_name, :port, :site_addresses, :listeners
+
+      def initialize(server_information)
+        @listeners = ServerUrl.new(
+          hosts: server_information.listeners,
+          port: server_information.port,
+          https: server_information.https?,
+          format_output: false
+        ).to_bind_addresses
+
+        @port           = server_information.port
+        @server_name    = server_information.server_name.dup unless server_information.server_name.nil?
+
+        @site_addresses = ServerUrl.new(
+          hosts: server_information.site_addresses,
+          port: server_information.port,
+          https: server_information.https?,
+          format_output: false
+        ).to_urls
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Middleman
+  class PreviewServer
+    # Validate user input
+    class ServerInformationValidator
+      # Validate the input
+      #
+      # @param [ServerInformation] information
+      #   The information instance which holds information about the preview
+      #   server settings
+      #
+      # @param [Array] checks
+      #   A list of checks which should be evaluated
+      def validate(information, checks)
+        checks.each { |c| c.validate information }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require 'ipaddr'
+require 'forwardable'
+
+module Middleman
+  class PreviewServer
+    class ServerIpAddress
+      def self.new(ip_address)
+        @parser = []
+        @parser << ServerIpv6Address
+        @parser << ServerIpv4Address
+
+        @parser.find { |p| p.match? ip_address }.new(ip_address)
+      end
+    end
+
+    class BasicServerIpAddress < SimpleDelegator
+    end
+
+    class ServerIpv4Address < BasicServerIpAddress
+      def to_browser
+        __getobj__.to_s
+      end
+
+      def self.match?(*)
+        true
+      end
+    end
+
+    class ServerIpv6Address < BasicServerIpAddress
+      def to_s
+        __getobj__.sub(/%.*$/, '')
+      end
+
+      def to_browser
+        format('[%s]', to_s)
+      end
+
+      if RUBY_VERSION < '2'
+        def self.match?(str)
+          str = str.to_s.sub(/%.*$/, '')
+          IPAddr.new(str).ipv6?
+        rescue StandardError
+          false
+        end
+      else
+        def self.match?(str)
+          str = str.to_s.sub(/%.*$/, '')
+          IPAddr.new(str).ipv6?
+        rescue IPAddr::InvalidAddressError, IPAddr::AddressFamilyError
+          false
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'ipaddr'
+
+module Middleman
+  class PreviewServer
+    # This builds the server urls for the preview server
+    class ServerUrl
+      private
+
+      attr_reader :hosts, :port, :https, :format_output
+
+      public
+
+      def initialize(opts={})
+        @hosts = opts.fetch(:hosts)
+        @port  = opts.fetch(:port)
+        @https = opts.fetch(:https, false)
+        @format_output = opts.fetch(:format_output, true)
+      end
+
+      # Return bind addresses
+      #
+      # @return [Array]
+      #   List of bind addresses of format host:port
+      def to_bind_addresses
+        if format_output
+          hosts.map { |l| format('"%s:%s"', l.to_s, port) }
+        else
+          hosts.map { |l| format('%s:%s', l.to_s, port) }
+        end
+      end
+
+      # Return server urls
+      #
+      # @return [Array]
+      #   List of urls of format http://host:port
+      def to_urls
+        if format_output
+          hosts.map { |l| format('"%s://%s:%s"', https? ? 'https' : 'http', l.to_browser, port) }
+        else
+          hosts.map { |l| format('%s://%s:%s', https? ? 'https' : 'http', l.to_browser, port) }
+        end
+      end
+
+      # Return server config urls
+      #
+      # @return [Array]
+      #   List of urls of format http://host:port/__middleman
+      def to_config_urls
+        if format_output
+          hosts.map { |l| format('"%s://%s:%s/__middleman"', https? ? 'https' : 'http', l.to_browser, port) }
+        else
+          hosts.map { |l| format('%s://%s:%s/__middleman', https? ? 'https' : 'http', l.to_browser, port) }
+        end
+      end
+
+      private
+
+      def https?
+        https == true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Middleman
+  class PreviewServer
+    # Probe for tcp ports
+    #
+    # This one first tries `try_port` if this is not available use the free
+    # port returned by TCPServer.
+    class TcpPortProber
+      # Check for port
+      #
+      # @param [Integer] try_port
+      #   The port to be checked
+      #
+      # @return [Integer]
+      #   The port
+      def port(try_port)
+        server = TCPServer.open(try_port)
+        server.close
+
+        try_port
+      rescue
+        server = TCPServer.open(0)
+        port = server.addr[1]
+        server.close
+
+        port
+      end
+    end
+  end
+end

data/lib/middleman-core/rack.rb

@@ -14,6 +14,12 @@ require 'middleman-core/template_renderer'
 ::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
@@ -102,7 +108,7 @@ module Middleman
 
       begin
         # Write out the contents of the page
-        res.write resource.render({}, { rack: { request: req } })
+        res.write resource.render({}, rack: { request: req })
 
         # Valid content is a 200 status
         res.status = 200

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

@@ -40,7 +40,6 @@ module Middleman
 
     # Haml Renderer
     class Haml < ::Middleman::Extension
-
       def initialize(app, options={}, &block)
         super
 
@@ -53,7 +52,7 @@ module Middleman
               modified_options = options.dup
               modified_options[:context] = compiler_options[:context]
 
-              text = template_class.new(nil, 1, modified_options) {text}.render
+              text = template_class.new(nil, 1, modified_options) { text }.render
               super(text, compiler_options)
             end
           end

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

@@ -24,7 +24,7 @@ module Middleman
 
         resources.each do |resource|
           next if resource.file_descriptor.nil?
-          next unless resource.file_descriptor[:relative_path].to_s =~ %r{\.liquid$}
+          next unless resource.file_descriptor[:full_path].to_s =~ %r{\.liquid$}
 
           # Convert data object into a hash for liquid
           resource.add_metadata locals: {

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

@@ -1,34 +1,4 @@
 require 'sass'
-require 'compass/import-once'
-
-GLOB = /\*|\[.+\]/
-
-# Hack around broken sass globs when combined with import-once
-# Targets compass-import-once 1.0.4
-# Tracking issue: https://github.com/chriseppstein/compass/issues/1529
-module Compass
-  module ImportOnce
-    module Importer
-      def find_relative(uri, base, options, *args)
-        if uri =~ GLOB
-          force_import = true
-        else
-          uri, force_import = handle_force_import(uri)
-        end
-        maybe_replace_with_dummy_engine(super(uri, base, options, *args), options, force_import)
-      end
-
-      def find(uri, options, *args)
-        if uri =~ GLOB
-          force_import = true
-        else
-          uri, force_import = handle_force_import(uri)
-        end
-        maybe_replace_with_dummy_engine(super(uri, options, *args), options, force_import)
-      end
-    end
-  end
-end
 
 module Middleman
   module Renderers
@@ -38,6 +8,8 @@ module Middleman
       def initialize(app, options={}, &block)
         super
 
+        logger.info "== Preferring use of LibSass" if defined?(::SassC)
+
         app.files.ignore :sass_cache, :source, /(^|\/)\.sass-cache\//
 
         opts = { output_style: :nested }
@@ -47,6 +19,7 @@ module Middleman
         app.config.define_setting :sass, opts, 'Sass engine options'
 
         app.config.define_setting :sass_assets_paths, [], 'Paths to extra SASS/SCSS files'
+        app.config.define_setting :sass_source_maps, app.development?, 'Whether to inline sourcemap into Sass'
 
         # Tell Tilt to use it as well (for inline sass blocks)
         ::Tilt.register 'sass', SassPlusCSSFilenameTemplate
@@ -56,8 +29,6 @@ module Middleman
         ::Tilt.register 'scss', ScssPlusCSSFilenameTemplate
         ::Tilt.prefer(ScssPlusCSSFilenameTemplate)
 
-        ::Compass::ImportOnce.activate!
-
         require 'middleman-core/renderers/sass_functions'
       end
 
@@ -82,11 +53,18 @@ module Middleman
         # @return [String]
         def evaluate(context, _)
           @context ||= context
-          @engine = ::Sass::Engine.new(data, sass_options)
+
+          sass_module = if defined?(::SassC)
+            ::SassC
+          else
+            ::Sass
+          end
+
+          @engine = sass_module::Engine.new(data, sass_options)
 
           begin
             @engine.render
-          rescue ::Sass::SyntaxError => e
+          rescue sass_module::SyntaxError => e
             ::Sass::SyntaxError.exception_to_css(e)
           end
         end
@@ -97,13 +75,22 @@ module Middleman
           ctx = @context
 
           more_opts = {
-            load_paths: ctx.config[:sass_assets_paths],
+            load_paths: ::Sass.load_paths | ctx.config[:sass_assets_paths],
             filename: eval_file,
             line: line,
             syntax: syntax,
-            custom: (options[:custom] || {}).merge(middleman_context: ctx.app)
+            custom: (options[:custom] || {}).merge(
+              middleman_context: ctx.app,
+              current_resource: ctx.current_resource
+            )
           }
 
+          if ctx.config[:sass_source_maps]
+            more_opts[:source_map_file] = '.'
+            more_opts[:source_map_embed] = true
+            more_opts[:source_map_contents] = true
+          end
+
           if ctx.is_a?(::Middleman::TemplateContext) && file
             more_opts[:css_filename] = file.sub(/\.s[ac]ss$/, '')
           end