middleman-core 3.4.1 → 4.0.0.alpha.2

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

@@ -1,5 +1,4 @@
 require 'redcarpet'
-require 'active_support/core_ext/module/attribute_accessors'
 
 module Middleman
   module Renderers
@@ -38,6 +37,14 @@ module Middleman
         renderer.new(render_options)
       end
 
+      def evaluate(scope, _)
+        @output ||= begin
+          MiddlemanRedcarpetHTML.scope = ::Middleman::Renderers::Haml.last_haml_scope || scope
+
+          @engine.render(data)
+        end
+      end
+
       private
 
       def covert_options_to_aliases!
@@ -49,7 +56,7 @@ module Middleman
 
     # Custom Redcarpet renderer that uses our helpers for images and links
     class MiddlemanRedcarpetHTML < ::Redcarpet::Render::HTML
-      cattr_accessor :middleman_app
+      cattr_accessor :scope
 
       def initialize(options={})
         @local_options = options.dup
@@ -59,7 +66,7 @@ module Middleman
 
       def image(link, title, alt_text)
         if !@local_options[:no_images]
-          middleman_app.image_tag(link, title: title, alt: alt_text)
+          scope.image_tag(link, title: title, alt: alt_text)
         else
           link_string = link.dup
           link_string << %("#{title}") if title && title.length > 0 && title != alt_text
@@ -72,7 +79,7 @@ module Middleman
           attributes = { title: title }
           attributes.merge!(@local_options[:link_attributes]) if @local_options[:link_attributes]
 
-          middleman_app.link_to(content, link, attributes)
+          scope.link_to(content, link, attributes)
         else
           link_string = link.dup
           link_string << %("#{title}") if title && title.length > 0 && title != alt_text

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

@@ -33,31 +33,32 @@ end
 module Middleman
   module Renderers
     # Sass renderer
-    module Sass
+    class Sass < ::Middleman::Extension
       # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          # Default sass options
-          app.config.define_setting :sass, {}, 'Sass engine options'
-
-          app.before_configuration do
-            template_extensions scss: :css,
-                                sass: :css
-          end
+      def initialize(app, options={}, &block)
+        super
 
-          # Tell Tilt to use it as well (for inline sass blocks)
-          ::Tilt.register 'sass', SassPlusCSSFilenameTemplate
-          ::Tilt.prefer(SassPlusCSSFilenameTemplate)
+        app.files.ignore :sass_cache, :source, /(^|\/)\.sass-cache\//
 
-          # Tell Tilt to use it as well (for inline scss blocks)
-          ::Tilt.register 'scss', ScssPlusCSSFilenameTemplate
-          ::Tilt.prefer(ScssPlusCSSFilenameTemplate)
+        opts = { output_style: :nested }
+        opts[:line_comments] = false if ENV['TEST']
 
-          ::Compass::ImportOnce.activate!
-        end
+        # Default sass options
+        app.config.define_setting :sass, opts, 'Sass engine options'
+
+        app.config.define_setting :sass_assets_paths, [], 'Paths to extra SASS/SCSS files'
+
+        # Tell Tilt to use it as well (for inline sass blocks)
+        ::Tilt.register 'sass', SassPlusCSSFilenameTemplate
+        ::Tilt.prefer(SassPlusCSSFilenameTemplate)
 
-        alias_method :included, :registered
+        # Tell Tilt to use it as well (for inline scss blocks)
+        ::Tilt.register 'scss', ScssPlusCSSFilenameTemplate
+        ::Tilt.prefer(ScssPlusCSSFilenameTemplate)
+
+        ::Compass::ImportOnce.activate!
+
+        require 'middleman-core/renderers/sass_functions'
       end
 
       # A SassTemplate for Tilt which outputs debug messages
@@ -86,21 +87,29 @@ module Middleman
           begin
             @engine.render
           rescue ::Sass::SyntaxError => e
-            ::Sass::SyntaxError.exception_to_css(e)
+            ::Sass::SyntaxError.exception_to_css(e, full_exception: true)
           end
         end
 
         # Change Sass path, for url functions, to the build folder if we're building
         # @return [Hash]
         def sass_options
-          more_opts = { filename: eval_file, line: line, syntax: syntax }
+          ctx = if defined?(::Middleman::Renderers::Haml)
+            ::Middleman::Renderers::Haml.last_haml_scope || @context
+          else
+            @context
+          end
 
-          if @context.is_a?(::Middleman::Application) && file
-            location_of_sass_file = @context.source_dir
+          more_opts = {
+            load_paths: ctx.config[:sass_assets_paths],
+            filename: eval_file,
+            line: line,
+            syntax: syntax,
+            custom: { middleman_context: ctx.app }
+          }
 
-            parts = basename.split('.')
-            parts.pop
-            more_opts[:css_filename] = File.join(location_of_sass_file, @context.config[:css_dir], parts.join('.'))
+          if ctx.is_a?(::Middleman::TemplateContext) && file
+            more_opts[:css_filename] = file.sub(/\.s[ac]ss$/, '')
           end
 
           options.merge(more_opts)

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

@@ -0,0 +1,116 @@
+module Sprockets
+  module Sass
+    module Functions
+      # Using Middleman::Util#asset_path, return the full path
+      # for the given +source+ as a Sass String. This supports keyword
+      # arguments that mirror the +options+.
+      #
+      # === Examples
+      #
+      #   background: url(image-path("image.jpg"));                // background: url("/assets/image.jpg");
+      #   background: url(image-path("image.jpg", $digest: true)); // background: url("/assets/image-27a8f1f96afd8d4c67a59eb9447f45bd.jpg");
+      #
+      def image_path(source, options={})
+        p = ::Middleman::Util.asset_path(middleman_context, :images, source.value, map_options(options))
+        ::Sass::Script::String.new p.to_s, :string
+      end
+
+      # Using Middleman::Util#asset_path, return the url CSS
+      # for the given +source+ as a Sass String. This supports keyword
+      # arguments that mirror the +options+.
+      #
+      # === Examples
+      #
+      #   background: image-url("image.jpg");                // background: url("/assets/image.jpg");
+      #   background: image-url("image.jpg", $digest: true); // background: url("/assets/image-27a8f1f96afd8d4c67a59eb9447f45bd.jpg");
+      #
+      def image_url(source, options={}, _cache_buster=nil)
+        # Work with the Compass #image_url API
+        if options.respond_to? :value
+          case options.value
+          when true
+            return image_path source
+          else
+            options = {}
+          end
+        end
+        ::Sass::Script::String.new "url(#{image_path(source, options)})"
+      end
+
+      # Using Middleman::Util#asset_path, return the full path
+      # for the given +source+ as a Sass String. This supports keyword
+      # arguments that mirror the +options+.
+      #
+      # === Examples
+      #
+      #   src: url(font-path("font.ttf"));                // src: url("/assets/font.ttf");
+      #   src: url(font-path("font.ttf", $digest: true)); // src: url("/assets/font-27a8f1f96afd8d4c67a59eb9447f45bd.ttf");
+      #
+      def font_path(source, options={})
+        p = ::Middleman::Util.asset_path(middleman_context, :fonts, source.value, map_options(options))
+        ::Sass::Script::String.new p.to_s, :string
+      end
+
+      # Using Middleman::Util#asset_path, return the url CSS
+      # for the given +source+ as a Sass String. This supports keyword
+      # arguments that mirror the +options+.
+      #
+      # === Examples
+      #
+      #   src: font-url("font.ttf");                  // src: url("/assets/font.ttf");
+      #   src: font-url("image.jpg", $digest: true);  // src: url("/assets/font-27a8f1f96afd8d4c67a59eb9447f45bd.ttf");
+      #
+      def font_url(source, options={})
+        # Work with the Compass #font_url API
+        if options.respond_to? :value
+          case options.value
+          when true
+            return font_path source
+          else
+            options = {}
+          end
+        end
+        ::Sass::Script::String.new "url(#{font_path(source, options)})"
+      end
+
+      protected
+
+      # Returns a reference to Middleman's context through
+      # the importer.
+      def middleman_context # :nodoc:
+        options[:custom][:middleman_context]
+      end
+
+      # Returns an options hash where the keys are symbolized
+      # and the values are unwrapped Sass literals.
+      def map_options(options={}) # :nodoc:
+        ::Sass::Util.map_hash(options) do |key, value|
+          [key.to_sym, value.respond_to?(:value) ? value.value : value]
+        end
+      end
+    end
+  end
+end
+
+module Sass::Script::Functions
+  include Sprockets::Sass::Functions
+
+  # Hack to ensure previous API declarations (by Compass or whatever)
+  # don't take precedence.
+  [:asset_path, :asset_url, :image_path, :image_url, :font_path, :font_url, :asset_data_uri].each do |method|
+    defined?(@signatures) && @signatures.delete(method)
+  end
+
+  declare :asset_path,     [:source], var_kwargs: true
+  declare :asset_path,     [:source, :kind]
+  declare :asset_url,      [:source], var_kwargs: true
+  declare :asset_url,      [:source, :kind]
+  declare :image_path,     [:source], var_kwargs: true
+  declare :image_url,      [:source], var_kwargs: true
+  declare :image_url,      [:source, :only_path]
+  declare :image_url,      [:source, :only_path, :cache_buster]
+  declare :font_path,      [:source], var_kwargs: true
+  declare :font_url,       [:source], var_kwargs: true
+  declare :font_url,       [:source, :only_path]
+  declare :asset_data_uri, [:source]
+end

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

@@ -18,36 +18,29 @@ end
 module Middleman
   module Renderers
     # Slim renderer
-    module Slim
+    class Slim < ::Middleman::Extension
       # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          app.before_configuration do
-            template_extensions slim: :html
-          end
-
-          # Setup Slim options to work with partials
-          ::Slim::Engine.set_options(
-            buffer: '@_out_buf',
-            use_html_safe: true,
-            generator: ::Temple::Generators::RailsOutputBuffer,
-            disable_escape: true
-          )
+      def initialize(_app, _options={}, &_block)
+        super
+
+        # Setup Slim options to work with partials
+        ::Slim::Engine.set_default_options(
+          buffer: '@_out_buf',
+          use_html_safe: true,
+          generator: ::Temple::Generators::RailsOutputBuffer,
+          disable_escape: true
+        )
+      end
 
-          app.after_configuration do
-            context_hack = {
-              context: self
-            }
+      def after_configuration
+        context_hack = {
+          context: app.template_context_class.new(app)
+        }
 
-            ::Slim::Embedded::SassEngine.disable_option_validator!
-            %w(sass scss markdown).each do |engine|
-              ::Slim::Embedded.options[engine.to_sym] = context_hack
-            end
-          end
+        ::Slim::Embedded::SassEngine.disable_option_validator!
+        %w(sass scss markdown).each do |engine|
+          ::Slim::Embedded.default_options[engine.to_sym] = context_hack
         end
-
-        alias_method :included, :registered
       end
     end
   end

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

@@ -3,21 +3,11 @@ require 'stylus/tilt'
 
 module Middleman
   module Renderers
-    # Sass renderer
-    module Stylus
-      # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          # Default less options
-          app.set :styl, {}
+    class Stylus < ::Middleman::Extension
+      def initialize(app, options={}, &block)
+        super
 
-          app.before_configuration do
-            template_extensions styl: :css
-          end
-        end
-
-        alias_method :included, :registered
+        app.config.define_setting :styl, {}, 'Stylus config options'
       end
     end
   end

data/lib/middleman-core/sitemap/extensions/ignores.rb

@@ -1,88 +1,50 @@
 module Middleman
   module Sitemap
     module Extensions
-      module Ignores
-        # Setup extension
-        class << self
-          # Once registered
-          def registered(app)
-            # Include methods
-            app.send :include, InstanceMethods
+      # Class to handle managing ignores
+      class Ignores < Extension
+        def initialize(app, config={}, &block)
+          super
 
-            ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
-          end
+          @app.add_to_config_context(:ignore, &method(:create_ignore))
+          @app.define_singleton_method(:ignore, &method(:create_ignore))
 
-          alias_method :included, :registered
-        end
+          # Array of callbacks which can ass ignored
+          @ignored_callbacks = Set.new
 
-        # Helpers methods for Resources
-        module ResourceInstanceMethods
-          # Whether the Resource is ignored
-          # @return [Boolean]
-          def ignored?
-            @app.ignore_manager.ignored?(path) ||
-              (!proxy? &&
-                @app.ignore_manager.ignored?(source_file.sub("#{@app.source_dir}/", ''))
-              )
-          end
+          @app.sitemap.define_singleton_method(:ignored?, &method(:ignored?))
         end
 
-        # Ignore-related instance methods
-        module InstanceMethods
-          def ignore_manager
-            @_ignore_manager ||= IgnoreManager.new(self)
+        # Ignore a path or add an ignore callback
+        # @param [String, Regexp] path Path glob expression, or path regex
+        # @return [void]
+        Contract Maybe[Or[String, Regexp]], Proc => Any
+        def create_ignore(path=nil, &block)
+          if path.is_a? Regexp
+            @ignored_callbacks << proc { |p| p =~ path }
+          elsif path.is_a? String
+            path_clean = ::Middleman::Util.normalize_path(path)
+            if path_clean.include?('*') # It's a glob
+              @ignored_callbacks << proc { |p| File.fnmatch(path_clean, p) }
+            else
+              # Add a specific-path ignore unless that path is already covered
+              return if ignored?(path_clean)
+              @ignored_callbacks << proc { |p| p == path_clean }
+            end
+          elsif block_given?
+            @ignored_callbacks << block
           end
 
-          # Ignore a path or add an ignore callback
-          # @param [String, Regexp] path Path glob expression, or path regex
-          # @return [void]
-          def ignore(path=nil, &block)
-            ignore_manager.ignore(path, &block)
-          end
+          @app.sitemap.invalidate_resources_not_ignored_cache!
         end
 
-        # Class to handle managing ignores
-        class IgnoreManager
-          def initialize(app)
-            @app = app
-
-            # Array of callbacks which can ass ignored
-            @ignored_callbacks = []
-          end
-
-          # Ignore a path or add an ignore callback
-          # @param [String, Regexp] path Path glob expression, or path regex
-          # @return [void]
-          def ignore(path=nil, &block)
-            if path.is_a? Regexp
-              @ignored_callbacks << proc { |p| p =~ path }
-            elsif path.is_a? String
-              path_clean = ::Middleman::Util.normalize_path(path)
-              if path_clean.include?('*') # It's a glob
-                if defined? File::FNM_EXTGLOB
-                  @ignored_callbacks << proc { |p| File.fnmatch(path_clean, p, File::FNM_EXTGLOB) }
-                else
-                  @ignored_callbacks << proc { |p| File.fnmatch(path_clean, p) }
-                end
-              else
-                # Add a specific-path ignore unless that path is already covered
-                return if ignored?(path_clean)
-                @ignored_callbacks << proc { |p| p == path_clean }
-              end
-            elsif block_given?
-              @ignored_callbacks << block
-            end
-
-            @app.sitemap.invalidate_resources_not_ignored_cache!
-          end
-
-          # Whether a path is ignored
-          # @param [String] path
-          # @return [Boolean]
-          def ignored?(path)
-            path_clean = ::Middleman::Util.normalize_path(path)
-            @ignored_callbacks.any? { |b| b.call(path_clean) }
-          end
+        # Whether a path is ignored
+        # @param [String] path
+        # @return [Boolean]
+        Contract String => Bool
+        def ignored?(path)
+          path_clean = ::Middleman::Util.normalize_path(path)
+          @ignored_callbacks.any? { |b| b.call(path_clean) }
         end
       end
     end