middleman-core 3.3.12 → 4.4.2

data/lib/middleman-core/builder.rb

@@ -0,0 +1,305 @@
+require 'pathname'
+require 'fileutils'
+require 'tempfile'
+require 'parallel'
+require 'middleman-core/rack'
+require 'middleman-core/callback_manager'
+require 'middleman-core/contracts'
+
+module Middleman
+  class Builder
+    extend Forwardable
+    include Contracts
+
+    # Make app & events available to `after_build` callbacks.
+    attr_reader :app, :events
+
+    # Reference to the Thor class.
+    attr_accessor :thor
+
+    # Logger comes from App.
+    def_delegator :@app, :logger
+
+    # Sort order, images, fonts, js/css and finally everything else.
+    SORT_ORDER = %w(.png .jpeg .jpg .gif .bmp .svg .svgz .webp .ico .woff .woff2 .otf .ttf .eot .js .css).freeze
+
+    # Create a new Builder instance.
+    # @param [Middleman::Application] app The app to build.
+    # @param [Hash] opts The builder options
+    def initialize(app, opts={})
+      @app = app
+      @source_dir = Pathname(File.join(@app.root, @app.config[:source]))
+      @build_dir = Pathname(@app.config[:build_dir])
+
+      if @build_dir.expand_path.relative_path_from(@source_dir).to_s =~ /\A[.\/]+\Z/
+        raise ":build_dir (#{@build_dir}) cannot be a parent of :source_dir (#{@source_dir})"
+      end
+
+      @glob = opts.fetch(:glob)
+      @cleaning = opts.fetch(:clean)
+      @parallel = opts.fetch(:parallel, true)
+
+      rack_app = ::Middleman::Rack.new(@app).to_app
+      @rack = ::Rack::MockRequest.new(rack_app)
+
+      @callbacks = ::Middleman::CallbackManager.new
+      @callbacks.install_methods!(self, [:on_build_event])
+    end
+
+    # Run the build phase.
+    # @return [Boolean] Whether the build was successful.
+    Contract Bool
+    def run!
+      @has_error = false
+      @events = {}
+
+      ::Middleman::Util.instrument 'builder.before' do
+        @app.execute_callbacks(:before_build, [self])
+      end
+
+      ::Middleman::Util.instrument 'builder.queue' do
+        queue_current_paths if @cleaning
+      end
+
+      ::Middleman::Util.instrument 'builder.prerender' do
+        prerender_css
+      end
+
+      ::Middleman::Profiling.start
+
+      ::Middleman::Util.instrument 'builder.output' do
+        output_files
+      end
+
+      ::Middleman::Profiling.report('build')
+
+      unless @has_error
+        ::Middleman::Util.instrument 'builder.clean' do
+          clean! if @cleaning
+        end
+
+        ::Middleman::Util.instrument 'builder.after' do
+          @app.execute_callbacks(:after_build, [self])
+        end
+      end
+
+      !@has_error
+    end
+
+    # Pre-request CSS to give Compass a chance to build sprites
+    # @return [Array<Resource>] List of css resources that were output.
+    Contract ResourceList
+    def prerender_css
+      logger.debug '== Prerendering CSS'
+
+      css_files = ::Middleman::Util.instrument 'builder.prerender.output' do
+        resources = @app.sitemap.resources.select { |resource| resource.ext == '.css' }
+        output_resources(resources)
+      end
+
+      ::Middleman::Util.instrument 'builder.prerender.check-files' do
+        # Double-check for compass sprites
+        unless @app.files.find_new_files!.empty?
+          logger.debug '== Checking for Compass sprites'
+          @app.sitemap.ensure_resource_list_updated!
+        end
+      end
+
+      css_files
+    end
+
+    # Find all the files we need to output and do so.
+    # @return [Array<Resource>] List of resources that were output.
+    Contract ResourceList
+    def output_files
+      logger.debug '== Building files'
+
+      resources = @app.sitemap.resources
+                      .reject { |resource| resource.ext == '.css' }
+                      .sort_by { |resource| SORT_ORDER.index(resource.ext) || 100 }
+
+      if @glob
+        resources = resources.select do |resource|
+          if defined?(::File::FNM_EXTGLOB)
+            File.fnmatch(@glob, resource.destination_path, ::File::FNM_EXTGLOB)
+          else
+            File.fnmatch(@glob, resource.destination_path)
+          end
+        end
+      end
+
+      output_resources(resources)
+    end
+
+    Contract ResourceList => ResourceList
+    def output_resources(resources)
+      results = if @parallel
+        ::Parallel.map(resources, &method(:output_resource))
+      else
+        resources.map(&method(:output_resource))
+      end
+
+      @has_error = true if results.any? { |r| r == false }
+
+      if @cleaning && !@has_error
+        results.each do |p|
+          next unless p.exist?
+
+          # handle UTF-8-MAC filename on MacOS
+          cleaned_name = if RUBY_PLATFORM =~ /darwin/
+            p.to_s.encode('UTF-8', 'UTF-8-MAC')
+          else
+            p
+          end
+
+          @to_clean.delete(Pathname(cleaned_name))
+        end
+      end
+
+      resources
+    end
+
+    # Figure out the correct event mode.
+    # @param [Pathname] output_file The output file path.
+    # @param [String] source The source file path.
+    # @return [Symbol]
+    Contract Pathname, String => Symbol
+    def which_mode(output_file, source)
+      if !output_file.exist?
+        :created
+      else
+        FileUtils.compare_file(source.to_s, output_file.to_s) ? :identical : :updated
+      end
+    end
+
+    # Create a tempfile for a given output with contents.
+    # @param [Pathname] output_file The output path.
+    # @param [String] contents The file contents.
+    # @return [Tempfile]
+    Contract Pathname, String => Tempfile
+    def write_tempfile(output_file, contents)
+      file = Tempfile.new([
+                            File.basename(output_file),
+                            File.extname(output_file)
+                          ])
+      file.binmode
+      file.write(contents)
+      file.close
+      File.chmod(0o644, file)
+      file
+    end
+
+    # Actually export the file.
+    # @param [Pathname] output_file The path to output to.
+    # @param [String|Pathname] source The source path or contents.
+    # @return [void]
+    Contract Pathname, Or[String, Pathname] => Any
+    def export_file!(output_file, source)
+      # ::Middleman::Util.instrument "write_file", output_file: output_file do
+      source = write_tempfile(output_file, source.to_s) if source.is_a? String
+
+      method, source_path = if source.is_a? Tempfile
+        [::FileUtils.method(:mv), source.path]
+      else
+        [::FileUtils.method(:cp), source.to_s]
+      end
+
+      mode = which_mode(output_file, source_path)
+
+      if mode == :created || mode == :updated
+        ::FileUtils.mkdir_p(output_file.dirname)
+        method.call(source_path, output_file.to_s)
+      end
+
+      source.unlink if source.is_a? Tempfile
+
+      trigger(mode, output_file)
+      # end
+    end
+
+    # Try to output a resource and capture errors.
+    # @param [Middleman::Sitemap::Resource] resource The resource.
+    # @return [void]
+    Contract IsA['Middleman::Sitemap::Resource'] => Or[Pathname, Bool]
+    def output_resource(resource)
+      ::Middleman::Util.instrument 'builder.output.resource', path: File.basename(resource.destination_path) do
+        output_file = @build_dir + resource.destination_path.gsub('%20', ' ')
+
+        begin
+          if resource.binary?
+            export_file!(output_file, resource.file_descriptor[:full_path])
+          else
+            response = @rack.get(::WEBrick::HTTPUtils.escape(resource.request_path))
+
+            # If we get a response, save it to a tempfile.
+            if response.status == 200
+              export_file!(output_file, binary_encode(response.body))
+            else
+              trigger(:error, output_file, response.body)
+              return false
+            end
+          end
+        rescue => e
+          trigger(:error, output_file, "#{e}\n#{e.backtrace.join("\n")}")
+          return false
+        end
+
+        output_file
+      end
+    end
+
+    # Get a list of all the paths in the destination folder and save them
+    # for comparison against the files we build in this cycle
+    # @return [void]
+    Contract Any
+    def queue_current_paths
+      @to_clean = []
+
+      return unless File.exist?(@app.config[:build_dir])
+
+      paths = ::Middleman::Util.all_files_under(@app.config[:build_dir]).map do |path|
+        Pathname(path)
+      end
+
+      @to_clean = paths.select do |path|
+        path.realpath.relative_path_from(@build_dir.realpath).to_s !~ /\/\./ || path.to_s =~ /\.(htaccess|htpasswd)/
+      end
+
+      # handle UTF-8-MAC filename on MacOS
+      @to_clean = @to_clean.map do |path|
+        if RUBY_PLATFORM =~ /darwin/
+          Pathname(path.to_s.encode('UTF-8', 'UTF-8-MAC'))
+        else
+          Pathname(path)
+        end
+      end
+    end
+
+    # Remove files which were not built in this cycle
+    Contract ArrayOf[Pathname]
+    def clean!
+      to_remove = @to_clean.reject do |f|
+        app.config[:skip_build_clean].call(f.to_s)
+      end
+
+      to_remove.each do |f|
+        FileUtils.rm(f)
+        trigger(:deleted, f)
+      end
+    end
+
+    Contract String => String
+    def binary_encode(string)
+      string.force_encoding('ascii-8bit') if string.respond_to?(:force_encoding)
+      string
+    end
+
+    Contract Symbol, Or[String, Pathname], Maybe[String] => Any
+    def trigger(event_type, target, extra=nil)
+      @events[event_type] ||= []
+      @events[event_type] << target
+
+      execute_callbacks(:on_build_event, [event_type, target, extra])
+    end
+  end
+end

data/lib/middleman-core/callback_manager.rb

@@ -0,0 +1,68 @@
+require 'hamster'
+require 'middleman-core/contracts'
+
+# Immutable Callback Management, complete with Contracts validation.
+module Middleman
+  class CallbackManager
+    include Contracts
+
+    Contract Any
+    def initialize
+      @callbacks = ::Hamster::Hash.empty
+      @subscribers = ::Hamster::Vector.empty
+    end
+
+    Contract RespondTo[:define_singleton_method], ArrayOf[Symbol] => Any
+    def install_methods!(install_target, names)
+      manager = self
+
+      names.each do |method_name|
+        install_target.define_singleton_method(method_name) do |*keys, &b|
+          key_set = keys.unshift(method_name)
+          manager.add(key_set.length > 1 ? key_set : key_set[0], &b)
+        end
+      end
+
+      install_target.define_singleton_method(:execute_callbacks) do |*args|
+        keys = args.shift
+        manager.execute(keys, args[0], self)
+      end
+
+      install_target.define_singleton_method(:callbacks_for, &method(:callbacks_for))
+      install_target.define_singleton_method(:subscribe_to_callbacks, &method(:subscribe))
+    end
+
+    Contract Or[Symbol, ArrayOf[Symbol]], Proc => Any
+    def add(keys, &block)
+      immutable_keys = keys.is_a?(Symbol) ? keys : ::Hamster::Vector.new(keys)
+
+      @callbacks = @callbacks.put(immutable_keys) do |v|
+        v.nil? ? ::Hamster::Vector.new([block]) : v.push(block)
+      end
+    end
+
+    Contract Proc => Any
+    def subscribe(&block)
+      @subscribers = @subscribers.push(block)
+    end
+
+    Contract Or[Symbol, ArrayOf[Symbol]], Maybe[ArrayOf[Any]], Maybe[RespondTo[:instance_exec]] => Any
+    def execute(keys, args=[], scope=self)
+      callbacks = callbacks_for(keys)
+      callbacks_count = callbacks.length + @subscribers.length
+
+      return if callbacks_count < 1
+
+      # ::Middleman::Util.instrument "callbacks.execute", keys: keys, length: callbacks_count do
+      callbacks.each { |b| scope.instance_exec(*args, &b) }
+      @subscribers.each { |b| scope.instance_exec(keys, args, &b) }
+      # end
+    end
+
+    Contract Or[Symbol, ArrayOf[Symbol]] => ::Hamster::Vector
+    def callbacks_for(keys)
+      immutable_keys = keys.is_a?(Symbol) ? keys : ::Hamster::Vector.new(keys)
+      @callbacks.get(immutable_keys) || ::Hamster::Vector.empty
+    end
+  end
+end

data/lib/middleman-core/config_context.rb

@@ -0,0 +1,67 @@
+require 'rack/mime'
+require 'middleman-core/callback_manager'
+
+module Middleman
+  class ConfigContext
+    extend Forwardable
+
+    attr_reader :app
+
+    # Whitelist methods that can reach out.
+    def_delegators :@app, :config, :logger, :use, :map, :mime_type, :files, :root, :build?, :server?, :environment?, :extensions
+    def_delegator :"@app.extensions", :activate
+
+    def initialize(app, template_context_class)
+      @app = app
+      @template_context_class = template_context_class
+
+      @callbacks = ::Middleman::CallbackManager.new
+      @callbacks.install_methods!(self, [:before_build, :after_build, :configure, :after_configuration, :ready])
+
+      # Trigger internal callbacks when app level are executed.
+      app.subscribe_to_callbacks(&method(:execute_callbacks))
+    end
+
+    def include(mod)
+      extend(mod)
+    end
+
+    def helpers(*helper_modules, &block)
+      helper_modules ||= []
+
+      if block_given?
+        block_module = Module.new
+        block_module.module_eval(&block)
+        helper_modules << block_module
+      end
+
+      helper_modules.each do |mod|
+        @template_context_class.send :include, mod
+      end
+    end
+
+    def include_environment(name)
+      path = File.dirname(__FILE__)
+      other_config = File.join(path, name.to_s)
+
+      return unless File.exist? other_config
+
+      instance_eval File.read(other_config), other_config, 1
+    end
+
+    def set(key, default=nil, &block)
+      config.define_setting(key, default) unless config.defines_setting?(key)
+      @app.config[key] = block_given? ? block : default
+    end
+
+    # Add a new mime-type for a specific extension
+    #
+    # @param [Symbol] type File extension
+    # @param [String] value Mime type
+    # @return [void]
+    def mime_type(type, value)
+      type = ".#{type}" unless type.to_s[0] == '.'
+      ::Rack::Mime::MIME_TYPES[type] = value
+    end
+  end
+end

data/lib/middleman-core/configuration.rb

@@ -1,90 +1,5 @@
 module Middleman
   module Configuration
-    # Access to a global configuration manager for the whole Middleman project,
-    # plus backwards compatibility mechanisms for older Middleman projects.
-    module Global
-      def self.included(app)
-        app.send :extend, ClassMethods
-      end
-
-      module ClassMethods
-        # Global configuration for the whole Middleman project.
-        # @return [ConfigurationManager]
-        def config
-          @_config ||= ConfigurationManager.new
-        end
-
-        # Set attributes (global variables)
-        #
-        # @deprecated Prefer accessing settings through "config".
-        #
-        # @param [Symbol] key Name of the attribue
-        # @param default Attribute value
-        # @return [void]
-        def set(key, default=nil, &block)
-          config.define_setting(key, default) unless config.defines_setting?(key)
-          @inst.set(key, default, &block) if @inst
-        end
-
-        # Access global settings as methods, to preserve compatibility with
-        # old Middleman.
-        #
-        # @deprecated Prefer accessing settings through "config".
-        def method_missing(method, *args)
-          if config.defines_setting? method
-            config[method]
-          else
-            super
-          end
-        end
-
-        # Needed so that method_missing makes sense
-        def respond_to?(method, include_private=false)
-          super || config.defines_setting?(method)
-        end
-      end
-
-      def config
-        self.class.config
-      end
-
-      # Backwards compatibilty with old Sinatra template interface
-      #
-      # @deprecated Prefer accessing settings through "config".
-      #
-      # @return [ConfigurationManager]
-      alias_method :settings, :config
-
-      # Set attributes (global variables)
-      #
-      # @deprecated Prefer accessing settings through "config".
-      #
-      # @param [Symbol] key Name of the attribue
-      # @param value Attribute value
-      # @return [void]
-      def set(key, value=nil, &block)
-        value = block if block_given?
-        config[key] = value
-      end
-
-      # Access global settings as methods, to preserve compatibility with
-      # old Middleman.
-      #
-      # @deprecated Prefer accessing settings through "config".
-      def method_missing(method, *args)
-        if config.defines_setting? method
-          config[method]
-        else
-          super
-        end
-      end
-
-      # Needed so that method_missing makes sense
-      def respond_to?(method, include_private=false)
-        super || config.defines_setting?(method)
-      end
-    end
-
     # A class that manages a collection of documented settings.
     # Can be used by extensions as well as the main Middleman
     # application. Extensions should probably finalize their instance
@@ -118,7 +33,6 @@ module Middleman
       # Set the value of a setting by key. Creates the setting if it doesn't exist.
       # @param [Symbol] key
       # @param [Object] val
-      # rubocop:disable UselessSetterCall
       def []=(key, val)
         setting_obj = setting(key) || define_setting(key)
         setting_obj.value = val
@@ -126,7 +40,7 @@ module Middleman
 
       # Allow configuration settings to be read and written via methods
       def method_missing(method, *args)
-        if defines_setting?(method) && args.size == 0
+        if defines_setting?(method) && args.empty?
           self[method]
         elsif method.to_s =~ /^(\w+)=$/ && args.size == 1
           self[$1.to_sym] = args[0]
@@ -150,16 +64,19 @@ module Middleman
       # Define a new setting, with optional default and user-friendly description.
       # Once the configuration manager is finalized, no new settings may be defined.
       #
-      # @param [Symbol] key
-      # @param [Object] default
-      # @param [String] description
+      # @example
+      #   config.define_setting :compress, false, 'Whether to compress the output'
+      # @param [Symbol] key The name of the option
+      # @param [Object] default The default value for the option
+      # @param [String] description A human-readable description of what the option does
+      # @param [Hash] options Additional options.
       # @return [ConfigSetting]
-      def define_setting(key, default=nil, description=nil)
+      def define_setting(key, default=nil, description=nil, options={})
         raise "Setting #{key} doesn't exist" if @finalized
         raise "Setting #{key} already defined" if @settings.key?(key)
         raise 'Setting key must be a Symbol' unless key.is_a? Symbol
 
-        @settings[key] = ConfigSetting.new(key, default, description)
+        @settings[key] = ConfigSetting.new(key, default, description, options)
       end
 
       # Switch the configuration manager is finalized, it switches to read-only
@@ -177,7 +94,7 @@ module Middleman
       # Load in a list of settings
       def load_settings(other_settings)
         other_settings.each do |setting|
-          new_setting = define_setting(setting.key, setting.default, setting.description)
+          new_setting = define_setting(setting.key, setting.default, setting.description, setting.options)
           new_setting.value = setting.value if setting.value_set?
         end
       end
@@ -207,11 +124,15 @@ module Middleman
       # A human-friendly description of the setting
       attr_accessor :description
 
-      def initialize(key, default, description)
+      # Additional config.
+      attr_accessor :options
+
+      def initialize(key, default, description, options={})
         @value_set = false
         self.key = key
         self.default = default
         self.description = description
+        self.options = options
       end
 
       # The user-supplied value for this setting, overriding the default
@@ -228,9 +149,8 @@ module Middleman
       end
 
       # Whether or not there has been a value set beyond the default
-      # rubocop:disable TrivialAccessors
       def value_set?
-        @value_set
+        @value_set == true
       end
     end
   end