jekyll-assets 2.4.0 → 3.0.0

data/lib/jekyll/assets/extensible.rb

@@ -0,0 +1,86 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+module Jekyll
+  module Assets
+    class Extensible
+      attr_reader :ctx
+      attr_reader :args
+      attr_reader :jekyll
+      attr_reader :asset
+      attr_reader :env
+
+      # --
+      def initialize(asset:, args:, ctx:)
+        @args = args
+        @env = ctx.registers[:site].sprockets
+        @jekyll = ctx.registers[:site]
+        @jekyll = @env.jekyll
+        @asset = asset
+        @ctx = ctx
+      end
+
+      # --
+      # Allows us to keep track of inheritence.
+      # @note you should be using this when using extensible.
+      # @param [<Any>] kls the class.
+      # @return [Array<Class>]
+      # --
+      def self.inherited(kls = nil)
+        @inherited ||= []
+        return @inherited if kls.nil?
+        @inherited << kls
+      end
+
+      # --
+      def self.requirements
+        @requirements ||= {
+          args: [], types: [
+            #
+          ]
+        }
+      end
+
+      # --
+      # @note a type is a "content type"
+      # Allows you to use types to determine if this class fits.
+      # @param [String] type the content type.
+      # @param [Hash] args the arguments.
+      # @return [true, false]
+      # --
+      def self.for?(type:, args:)
+        for_type?(type) && for_args?(args)
+      end
+
+      # --
+      def self.for_args?(args)
+        return true if arg_keys.empty?
+        arg_keys.collect { |k| args.key?(k) }.none? do |k|
+          k == false
+        end
+      end
+
+      # --
+      def self.for_type?(type)
+        return true if content_types.empty?
+        content_types.any? do |k|
+          k.is_a?(Regexp) ? type =~ k : k.to_s == type.to_s
+        end
+      end
+
+      # --
+      # Creates `#arg_keys`, and `#content_types` so that you
+      #   can limit your surface for an extensible plugin.  For
+      #   example if you only work for
+      # --
+      [%i(arg_keys args), %i(content_types types)].each do |(k, v)|
+        instance_eval <<-RUBY
+          def self.#{k}(*a)
+            requirements[:#{v}].concat(a)
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/jekyll/assets/filters.rb

@@ -0,0 +1,22 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require_relative "context"
+require_relative "tag"
+
+module Jekyll
+  module Assets
+    module Filters
+      def asset(path, args = "")
+        args = "#{path} #{args}"
+        ctx = Liquid::ParseContext.new
+        tag = Tag.new("asset", args, ctx)
+        tag.render(@context)
+      end
+    end
+  end
+end
+
+filter = Jekyll::Assets::Filters
+Liquid::Template.register_filter(filter)

data/lib/jekyll/assets/hook.rb

@@ -1,77 +1,144 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
+# Copyright: 2012 - 2017 - MIT License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
 
 module Jekyll
   module Assets
     class Hook
       class UnknownHookError < RuntimeError
-        def initialize(base: nil, point: nil)
-          super "Unknown hook #{base ? "base" : "point"} '#{base || point}'"
+        def initialize(point)
+          super "Unknown hook point `#{point}'"
         end
       end
 
-      # ----------------------------------------------------------------------
+      # --
+      class << self
+        attr_reader :points
+      end
 
-      HOOK_ALIASES = {
-        :env => {
-          :post_init => :init,
-          :pre_init  => :init
-        }
-      }
+      # --
+      @points = {
+        env: {
+          before_init: {
+            1 => [],
+            2 => [],
+            3 => [],
+          },
+
+          after_init: {
+            1 => [],
+            2 => [],
+            3 => [],
+          },
+        },
 
-      # ----------------------------------------------------------------------
+        config: {
+          before_merge: {
+            1 => [],
+            2 => [],
+            3 => [],
+          },
+        },
 
-      HOOK_POINTS = {
-        :env => [
-          :init
-        ]
+        asset: {
+          before_compile: {
+            1 => [],
+            2 => [],
+            3 => [],
+          },
+        },
+
+        liquid: {
+          pre_render: {
+            1 => [],
+            2 => [],
+            3 => [],
+          },
+        },
       }
 
-      # ----------------------------------------------------------------------
+      # --
+      # Create a hook point to attach hooks to.
+      # @param [Array<String,Symbol>] point the parent and child.
+      # @note plugins can create their own points if wished.
+      # @return [Hash<Hash<Array>>]
+      # --
+      def self.add_point(*point)
+        raise ArgumentError, "only give 2 points" if point.count > 2
 
-      def self.all
-        @_all ||= {}
-      end
+        @points[point[0]] ||= {}
+        @points[point[0]][point[1]] ||= {
+          #
+        }
 
-      # ----------------------------------------------------------------------
-      # Trigger a hook, giving an optional block where we pass you the,
-      # proc we got and then you can do as you please (such as instance eval)
-      # but if you do not give us one then we simply pass the args.
-      # ----------------------------------------------------------------------
-
-      def self.trigger(base, point_, *args, &block)
-        raise ArgumentError, "Do not give args with a block" if !args.empty? && block_given?
-        if all.key?(base) && all[base].key?(point_)
-          Set.new.merge(point(base, point_, :early)).merge(point(base, point_)).map do |v|
-            block_given?? block.call(v) : v.call(*args)
-          end
+        1.upto(3).each do |i|
+          @points[point[0]][point[1]][i] ||= [
+            #
+          ]
         end
+
+        @points
       end
 
-      # ----------------------------------------------------------------------
+      # --
+      # @return [Array<Proc>]
+      # @param [Array<String,Symbol>] point the parent and child.
+      # @note this is really internal.
+      # Get a hook point.
+      # --
+      def self.get_point(*point)
+        check_point(*point)
 
-      def self.point(base, point, when_ = :late)
-        point = all[base][point] ||= {
-          :early => Set.new,
-          :late  => Set.new
-        }
+        @points[point[0]][point[1]]
+          .each_with_object([]) do |(_, v), a|
+            a.concat(v)
+          end
+      end
 
-        point[when_]
+      # --
+      # Trigger a hook point.
+      # @note plugins can trigger their own hooks.
+      # @param [Array<String,Symbol>] point the parent and child.
+      # @param [Proc{}] block the code to run.
+      # @see self.add_point
+      # @return [nil]
+      # --
+      def self.trigger(*point, &block)
+        get_point(*point).map do |v|
+          block.call(v)
+        end
       end
 
-      # ----------------------------------------------------------------------
+      # --
+      # Register a hook on a hook point.
+      # @param [Array<String,Symbol>] point the parent and child.
+      # @param [Integer] priority your priority.
+      # @note this is what plugins should use.
+      # @return [nil]
+      # --
+      def self.register(*point, priority: 2, &block)
+        if priority > 3
+          raise ArgumentError,
+            "priority must be between 1 and 3"
+        end
 
-      def self.register(base, point, when_ = :late, &block)
-        raise UnknownHookError, base: base unless HOOK_POINTS.key?(base)
-        point = HOOK_ALIASES[base][point] if HOOK_ALIASES.fetch(base, {}).key?(point)
-        raise UnknownHookError, point: point unless HOOK_POINTS[base].include?(point)
-        all[base] ||= {}
+        check_point(*point)
+        out = @points[point[0]]
+        out = out[point[1]]
+        out = out[priority]
+        out << block
+      end
 
-        point(base, point, when_) \
-          .add(block)
+      # --
+      # @param point the points to check.
+      # Checks that a point exists or raises an error.
+      # @return [nil]
+      # --
+      def self.check_point(*point)
+        raise ArgumentError, "only give 2 points" if point.count > 2
+        if !@points.key?(point[0]) || !@points[point[0]].key?(point[1])
+          raise ArgumentError, "Unknown hook #{point}"
+        end
       end
     end
   end

data/lib/jekyll/assets/html.rb

@@ -0,0 +1,88 @@
+# Frozen-string-literal: true
+# Copyright: 2012 - 2017 - MIT License
+# Encoding: utf-8
+
+require_relative "extensible"
+require "nokogiri"
+
+module Jekyll
+  module Assets
+    class HTML < Extensible
+      attr_reader :doc
+
+      # --
+      # rubocop:disable Style/RedundantReturn
+      # --
+      def self.skips
+        return %i(
+          inline path data pic
+        )
+      end
+
+      # --
+      def initialize(doc:, **kwd)
+        super(**kwd)
+        @doc = doc
+      end
+
+      # --
+      # @param [Hash] args the arguments.
+      # @param [String] type the content type.
+      # Search for plugins and runners and then run them.
+      # @param [Sprockets::Asset] the current asset.
+      # @note look inside of plugins for examples.
+      # rubocop:enable Style/RedundantReturn
+      # @return [String] the final result.
+      # @param [Env] env the env.
+      # --
+      def self.build(args:, asset:, ctx:)
+        rtn = inherited.select do |o|
+          o.for?({
+            type: asset.content_type,
+            args: args,
+          })
+        end
+
+        doc = make_doc(rtn, asset: asset)
+        rtn.each do |o|
+          o = o.new({
+            doc: doc,
+            asset: asset,
+            args: args,
+            ctx: ctx,
+          })
+
+          o.run
+        end
+
+        # SVG will need to_xml!
+        out = doc.is_a?(Nokogiri::XML::Document) ? doc.to_xml : doc.to_html
+        rtn.select { |v| v.respond_to?(:cleanup) }.each do |o|
+          out = o.cleanup(out)
+        end
+        out
+      end
+
+      # --
+      # Allows a plugin to inform us if they want XML.
+      # @note technically this can break sub-plugins later.
+      # @return [true, false]
+      # --
+      def self.wants_xml?
+        false
+      end
+
+      # --
+      # Make an HTML/XML doc to work on.
+      # @note see `self.wants_html?` to control this.
+      # @return [Nokogiri::Document]
+      # --
+      def self.make_doc(builders, asset:)
+        wants = builders.map(&:wants_xml?).uniq
+        raise "incompatible wants xml/html for builders" if wants.size > 1
+        !wants[0] ? Nokogiri::HTML::DocumentFragment.parse("") :
+          Nokogiri::XML.parse(asset.to_s)
+      end
+    end
+  end
+end

data/lib/jekyll/assets/logger.rb

@@ -1,75 +1,33 @@
-# ----------------------------------------------------------------------------
 # Frozen-string-literal: true
-# Copyright: 2012 - 2016 - MIT License
+# Copyright: 2012 - 2017 - MIT License
 # Encoding: utf-8
-# ----------------------------------------------------------------------------
+
+require "jekyll"
 
 module Jekyll
   module Assets
     class Logger
-      PREFIX = "Jekyll Assets:"
-
-      class << self
-
-        # --
-        # @param [String] msg the message you wish to send out.
-        # Deprecate a method and warn the user about it.
-        # --
-        def deprecate(msg, instance)
-          filepath = caller[1].split(/\.rb:/).first + ".rb"
-          filepath = Pathutil.new(filepath).relative_path_from(instance.in_source_dir)
-          Jekyll.logger.error("", format("%s: %s", msg.red, filepath))
-          yield if block_given?
-        end
+      PREFIX = "Assets: "
+      def self.logger
+        self
       end
 
       # --
-      # @return [Jekyll:Logger]
-      # The logger.
-      # --
-      def log
-        return @log ||= Jekyll.logger
-      end
-
-      # --
-      # Log Level: 1
-      # --
-      def warn(msg = nil)
-        log.warn(PREFIX,
-          block_given?? yield : msg
-        )
-      end
-
+      # @note this is to be removed after 3.6.
+      # Creates self methods so that we can accept blocks.
+      # @param [String,Proc] message the message that to log.
+      # @return nil
       # --
-      # Log Level: 1
-      # --
-      def error(msg = nil)
-        log.error(PREFIX,
-          block_given?? yield : msg
-        )
-      end
-
-      # --
-      # Log Level: 2
-      # --
-      def info(msg = nil)
-        log.info(PREFIX,
-          block_given?? yield : msg
-        )
-      end
-
-      # --
-      # Log Level: 3
-      # --
-      def debug(msg = nil)
-        log.debug(PREFIX,
-          block_given?? yield : msg
-        )
+      %i(warn error info debug).each do |v|
+        define_singleton_method v do |message = nil, &block|
+          message = block.call if block
+          Jekyll.logger.send(v, PREFIX, message)
+        end
       end
 
       # --
-      def log_level=(*)
-        raise "Please set log levels on Jekyll.logger"
+      def self.efile(file)
+        Jekyll.logger.error("Asset File", file)
       end
     end
   end