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

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

@@ -0,0 +1,123 @@
+require 'middleman-core/contracts'
+
+# Minify Javascript Extension
+class Middleman::Extensions::MinifyJavascript < ::Middleman::Extension
+  option :inline, false, 'Whether to minify JS inline within HTML files'
+  option :ignore, [], 'Patterns to avoid minifying'
+  option :compressor, proc {
+    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 JS
+    app.use Rack, compressor: options[:compressor],
+                  ignore: Array(options[:ignore]) + [/\.min\./],
+                  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
+    # @param [Hash] options
+    Contract RespondTo[:call], {
+      ignore: ArrayOf[PATH_MATCHER],
+      inline: Bool,
+      compressor: Or[Proc, RespondTo[:to_proc], RespondTo[:compress]]
+    } => Any
+    def initialize(app, options={})
+      @app = app
+      @ignore = options.fetch(:ignore)
+      @inline = options.fetch(:inline)
+
+      @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
+    # @param [Rack::Environmemt] env
+    # @return [Array]
+    def call(env)
+      status, headers, response = @app.call(env)
+
+      type = headers['Content-Type'].try(:slice, /^[^;]*/)
+      @path = env['PATH_INFO']
+
+      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
+
+      if minified
+        headers['Content-Length'] = ::Rack::Utils.bytesize(minified).to_s
+        response = [minified]
+      end
+
+      [status, headers, response]
+    end
+
+    private
+
+    # 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
+        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.include?('type=') || first.include?('text/javascript')
+          first + minify(inline_content) + last
+        else
+          match
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'addressable/uri'
+
+# Relative Assets extension
+class Middleman::Extensions::RelativeAssets < ::Middleman::Extension
+  option :exts, %w(.css .png .jpg .jpeg .webp .svg .svgz .js .gif .ttf .otf .woff .woff2 .eot), 'List of extensions that get cache busters strings appended to them.'
+  option :sources, %w(.css .htm .html .xhtml), 'List of extensions that are searched for relative assets.'
+  option :ignore, [], 'Regexes of filenames to skip adding query strings to'
+  option :rewrite_ignore, [], 'Regexes of filenames to skip processing for path rewrites'
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    app.rewrite_inline_urls id: :asset_hash,
+                            url_extensions: options.exts,
+                            source_extensions: options.sources,
+                            ignore: options.ignore,
+                            rewrite_ignore: options.rewrite_ignore,
+                            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)
+
+    return if uri.path[0..0] != '/'
+
+    relative_path = uri.host.nil?
+
+    full_asset_path = if relative_path
+      dirpath.join(asset_path).to_s
+    else
+      asset_path
+    end
+
+    current_dir = Pathname(request_path).dirname
+    result = Pathname(full_asset_path).relative_path_from(current_dir).to_s
+
+    result
+  end
+end

data/lib/middleman-core/file_renderer.rb

@@ -0,0 +1,136 @@
+require 'tilt'
+require 'active_support/core_ext/string/output_safety'
+require 'active_support/core_ext/module/delegation'
+require 'middleman-core/contracts'
+
+::Tilt.mappings.delete('html') # WTF, Tilt?
+::Tilt.mappings.delete('csv')
+
+module Middleman
+  class FileRenderer
+    extend Forwardable
+    include Contracts
+
+    def self.cache
+      @_cache ||= ::Tilt::Cache.new
+    end
+
+    def_delegator :"self.class", :cache
+
+    def initialize(app, path)
+      @app = app
+      @path = path.to_s
+    end
+
+    # Render an on-disk file. Used for everything, including layouts.
+    #
+    # @param [Hash] locs
+    # @param [Hash] opts
+    # @param [Class] context
+    # @return [String]
+    Contract Hash, Hash, Any, Maybe[Proc] => String
+    def render(locs, opts, context, &block)
+      path = @path.dup
+
+      # Detect the remdering engine from the extension
+      extension = File.extname(path)
+      engine = extension[1..-1].to_sym
+
+      # Store last engine for later (could be inside nested renders)
+      context.current_engine, engine_was = engine, context.current_engine
+
+      # Save current buffer for later
+      buf_was = context.save_buffer
+
+      # Read from disk or cache the contents of the file
+      body = if opts[:template_body]
+        opts.delete(:template_body)
+      else
+        template_data_for_file
+      end
+
+      # Merge per-extension options from config
+      extension = File.extname(path)
+      options = {}.merge!(opts).merge!(options_for_ext(extension))
+      options[:outvar] ||= '@_out_buf'
+      options[:context] = context
+      options.delete(:layout)
+
+      # Overwrite with frontmatter options
+      options = options.deep_merge(options[:renderer_options]) if options[:renderer_options]
+
+      template_class = ::Tilt[path]
+
+      # Allow hooks to manipulate the template before render
+      body = @app.callbacks_for(:before_render).reduce(body) do |sum, callback|
+        callback.call(sum, path, locs, template_class) || sum
+      end
+
+      # Read compiled template from disk or cache
+      template = ::Tilt.new(path, 1, options) { body }
+      # template = cache.fetch(:compiled_template, extension, options, body) do
+      #   ::Tilt.new(path, 1, options) { body }
+      # end
+
+      # Render using Tilt
+      # content = ::Middleman::Util.instrument 'render.tilt', path: path do
+      #   template.render(context, locs, &block)
+      # end
+      content = template.render(context, locs, &block)
+
+      # Allow hooks to manipulate the result after render
+      content = @app.callbacks_for(:after_render).reduce(content) do |sum, callback|
+        callback.call(sum, path, locs, template_class) || sum
+      end
+
+      output = ::ActiveSupport::SafeBuffer.new ''
+      output.safe_concat content
+      output
+    ensure
+      # Reset stored buffer
+      context.restore_buffer(buf_was)
+      context.current_engine = engine_was
+    end
+
+    # Get the template data from a path
+    # @param [String] path
+    # @return [String]
+    Contract String
+    def template_data_for_file
+      file = @app.files.find(:source, @path)
+
+      if @app.extensions[:front_matter] || (file && !file[:types].include?(:no_frontmatter))
+        result = @app.extensions[:front_matter].template_data_for_file(@path)
+        return result unless result.nil?
+      end
+
+      file ? file.read : File.read(@path)
+    end
+
+    protected
+
+    # Get a hash of configuration options for a given file extension, from
+    # config.rb
+    #
+    # @param [String] ext
+    # @return [Hash]
+    Contract String => Hash
+    def options_for_ext(ext)
+      # Read options for extension from config/Tilt or cache
+      cache.fetch(:options_for_ext, ext) do
+        options = {}
+
+        # Find all the engines which handle this extension in tilt. Look for
+        # config variables of that name and merge it
+        extension_class = ::Tilt[ext]
+        ::Tilt.mappings.each do |mapping_ext, engines|
+          next unless engines.include? extension_class
+          engine_options = @app.config[mapping_ext.to_sym] || {}
+          options.merge!(engine_options)
+        end
+
+        options
+      end
+    end
+  end
+end

data/lib/middleman-core/load_paths.rb

@@ -0,0 +1,47 @@
+# Core Pathname library used for traversal
+require 'pathname'
+
+module Middleman
+  class << self
+    def setup_load_paths
+      @_is_setup ||= begin
+
+        # Only look for config.rb if MM_ROOT isn't set
+        if !ENV['MM_ROOT'] && (found_path = findup('config.rb'))
+          ENV['MM_ROOT'] = found_path
+        end
+
+        # If we've found the root, try to setup Bundler
+        setup_bundler if ENV['MM_ROOT']
+
+        true
+      end
+    end
+
+    private
+
+    # Set BUNDLE_GEMFILE and run Bundler setup. Raises an exception if there is no Gemfile
+    def setup_bundler
+      ENV['BUNDLE_GEMFILE'] ||= File.join(findup('Gemfile', ENV['MM_ROOT']), 'Gemfile')
+
+      unless File.exist?(ENV['BUNDLE_GEMFILE'])
+        ENV['BUNDLE_GEMFILE'] = File.expand_path('../../../../Gemfile', __FILE__)
+      end
+
+      if File.exist?(ENV['BUNDLE_GEMFILE'])
+        require 'bundler/setup'
+        Bundler.require
+      else
+        raise "Couldn't find your Gemfile. Middleman projects require a Gemfile for specifying dependencies."
+      end
+    end
+
+    # Recursive method to find a file in parent directories
+    def findup(filename, cwd=Dir.pwd)
+      cwd = Pathname(cwd)
+      return cwd.to_s if (cwd + filename).exist?
+      return false if cwd.root?
+      findup(filename, cwd.parent)
+    end
+  end
+end

data/lib/middleman-core/logger.rb

@@ -0,0 +1,47 @@
+# Use the Ruby/Rails logger
+require 'active_support/notifications'
+require 'active_support/logger'
+require 'thread'
+
+module Middleman
+  # The Middleman Logger
+  class Logger < ActiveSupport::Logger
+    def self.singleton(*args)
+      if !@_logger || args.length > 0
+        if args.length == 1 && (args.first.is_a?(::String) || args.first.respond_to?(:write))
+          args = [0, false, args.first]
+        end
+        @_logger = new(*args)
+      end
+
+      @_logger
+    end
+
+    def initialize(log_level=1, is_instrumenting=false, target=$stdout)
+      super(target)
+
+      self.level = log_level
+      @instrumenting = is_instrumenting
+
+      if @instrumenting != false
+        ::ActiveSupport::Notifications.subscribe(/\.middleman$/, self)
+      end
+
+      @mutex = Mutex.new
+    end
+
+    def add(*args)
+      @mutex.synchronize do
+        super
+      end
+    end
+
+    def call(message, *args)
+      return if @instrumenting.is_a?(String) && @instrumenting != 'instrument' && !message.include?(@instrumenting)
+
+      evt = ::ActiveSupport::Notifications::Event.new(message, *args)
+      return unless evt.duration > 30
+      info "== Instrument (#{evt.name.sub(/.middleman$/, '')}): #{evt.duration}ms\n#{args.last}"
+    end
+  end
+end

data/lib/middleman-core/meta_pages.rb

@@ -0,0 +1,112 @@
+require 'rack/builder'
+require 'rack/static'
+require 'tilt'
+require 'middleman-core/meta_pages/sitemap_tree'
+require 'middleman-core/meta_pages/config_setting'
+
+module Middleman
+  module MetaPages
+    # Metadata pages to be served in preview, in order to present information about the Middleman
+    # application and its configuration. Analogous to Firefox/Chrome's "about:" pages.
+    #
+    # Built using a ghetto little Rack web framework cobbled together because I didn't want to depend
+    # on Sinatra or figure out how to host Middleman inside Middleman.
+    class Application
+      def initialize(middleman)
+        # Hold a reference to the middleman application
+        @middleman = middleman
+
+        meta_pages = self
+        @rack_app = ::Rack::Builder.new do
+          # Serve assets from metadata/assets
+          use ::Rack::Static, urls: ['/assets'], root: File.join(File.dirname(__FILE__), 'meta_pages')
+
+          map '/' do
+            run meta_pages.method(:index)
+          end
+
+          map '/sitemap' do
+            run meta_pages.method(:sitemap)
+          end
+
+          map '/config' do
+            run meta_pages.method(:config)
+          end
+        end
+      end
+
+      def call(*args)
+        @rack_app.call(*args)
+      end
+
+      # The index page
+      def index(_)
+        template('index.html.erb')
+      end
+
+      # Inspect the sitemap
+      def sitemap(_)
+        resources = @middleman.sitemap.resources(true)
+
+        sitemap_tree = SitemapTree.new
+
+        resources.each do |resource|
+          sitemap_tree.add_resource resource
+        end
+
+        template('sitemap.html.erb', sitemap_tree: sitemap_tree)
+      end
+
+      # Inspect configuration
+      def config(_)
+        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
+
+          if extension.is_a?(Hash)
+            # Multiple instance extension
+            if extension.size == 1
+              extension_config[ext_name] = extension_options(extension.values.first)
+            else
+              extension.each do |inst, ext|
+                extension_config["#{ext_name} (#{inst})"] = extension_options(ext)
+              end
+            end
+          else
+            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
+
+      private
+
+      # 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(::Object.new, locals)
+        response(content)
+      end
+
+      # Respond to an HTML request
+      def response(content)
+        [200, { 'Content-Type' => 'text/html' }, Array(content)]
+      end
+
+      def extension_options(extension)
+        extension.options.all_settings.map { |c| ConfigSetting.new(c) }
+      end
+    end
+  end
+end