bunto-assets 1.0.0.pre.alpha

data/lib/bunto/assets/liquid/tag/proxied_asset.rb

@@ -0,0 +1,114 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2016-present - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+require "forwardable"
+
+module Bunto
+  module Assets
+    module Liquid
+      class Tag
+        class ProxiedAsset
+          attr_reader :args, :asset, :env
+          extend Forwardable
+
+          # ------------------------------------------------------------------
+
+          def_delegator :@asset, :liquid_tags
+          def_delegator :@asset, :filename, :source_filename
+          def_delegator :@asset, :content_type
+          def_delegator :@asset, :mtime
+
+          # ------------------------------------------------------------------
+
+          def initialize(asset, args, env, tag)
+            @env = env
+            @asset = asset
+            @args = args
+            @tag = tag
+
+            cache_file
+            proxy_file
+          end
+
+          # ------------------------------------------------------------------
+
+          def cached?
+            @_cached
+          end
+
+          # ------------------------------------------------------------------
+
+          def write_to(name)
+            FileUtils.mkdir_p File.dirname(name)
+            Sprockets::PathUtils.atomic_write(name) do |f|
+              f.write source
+            end
+          end
+
+          # ------------------------------------------------------------------
+
+          def source
+            File.binread(filename)
+          end
+
+          # ------------------------------------------------------------------
+
+          def filename
+            env.in_cache_dir(digest_path)
+          end
+
+          # ------------------------------------------------------------------
+
+          def digest
+            Digest::SHA2.hexdigest(args.proxies.to_s)
+          end
+
+          # ------------------------------------------------------------------
+          # We always digest a proxied asset so it's uniq based on what
+          # proxies you give us, it would be ignorant to treat it otherwise,
+          # we also make sure they are URL safe by digesting the args.
+          # ------------------------------------------------------------------
+
+          def logical_path
+            digest_path
+          end
+
+          # ------------------------------------------------------------------
+
+          def digest_path
+            name = asset.logical_path
+            ext  = File.extname(name)
+            "#{name.chomp(ext)}-#{digest}#{ext}"
+          end
+
+          # ------------------------------------------------------------------
+
+          private
+          def proxy_file
+            unless cached?
+              args.proxies.each do |key, val|
+                Proxies.get(key).first[:class].new(self, val, @args).process
+              end
+            end
+          end
+
+          # ------------------------------------------------------------------
+
+          private
+          def cache_file
+            @_cached = File.file?(filename)
+            return @_cached if @_cached
+
+            dir = File.dirname(filename)
+            FileUtils.mkdir_p dir unless dir == env.in_cache_dir
+            FileUtils.cp asset.filename, filename
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bunto/assets/liquid/tag/proxies.rb

@@ -0,0 +1,118 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2016-present - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Bunto
+  module Assets
+    module Liquid
+      class Tag
+        module Proxies
+          def self.add_by_class(class_, name, tag, *args)
+            proc_ = proc { |v| [v.to_s, v, v.to_sym] }
+            all << {
+              :name => proc_.call(name).uniq,
+              :args => [args].flatten.map(&proc_).flatten.uniq,
+              :tags => [ tag].flatten.map(&proc_).flatten.uniq,
+              :class  => class_
+            }
+
+            all
+          end
+
+          # ------------------------------------------------------------------
+
+          def self.add(name, tag, *args, &block)
+            add_by_class(*generate_class(name, tag, &block), *args)
+          end
+
+          # ------------------------------------------------------------------
+
+          def self.keys
+            all.select { |val| !val[:class].is_a?(Symbol) }.map do |val|
+              val[:name]
+            end.flatten
+          end
+
+          # ------------------------------------------------------------------
+
+          def self.base_keys
+            all.select { |val| val[:class].is_a?(Symbol) }.map do |val|
+              val[:name]
+            end.flatten
+          end
+
+          # ------------------------------------------------------------------
+
+          def self.has?(name, tag = nil, arg = nil)
+            get(name, tag, arg).any?
+          end
+
+          # ------------------------------------------------------------------
+
+          def self.get(name, tag = nil, arg = nil)
+            if name && tag && arg then get_by_name_and_tag_and_arg(name, tag, arg)
+            elsif name && tag
+              get_by_name_and_tag(name, tag)
+
+            else
+              all.select do |val|
+                val[:name].include?(name)
+              end
+            end
+          end
+
+          # ------------------------------------------------------------------
+
+          def self.get_by_name_and_tag_and_arg(name, tag, arg)
+            all.select do |val|
+              val[:name].include?(name) && (val[:tags].include?(:all) || val[:tags] \
+                .include?(tag)) && val[:args].include?(arg)
+            end
+          end
+
+          # ------------------------------------------------------------------
+
+          def self.get_by_name_and_tag(name, tag)
+            all.select do |val|
+              val[:name].include?(name) && (val[:tags].include?(:all) || val[:tags] \
+                .include?(tag))
+            end
+          end
+
+          # ------------------------------------------------------------------
+
+          def self.all
+            @_all ||= Set.new
+          end
+
+          # ------------------------------------------------------------------
+
+          private
+          def self.generate_class(name, tag, &block)
+            class_ = const_set(random_name, Class.new)
+            class_.class_eval(&block)
+            return class_, name, tag
+          end
+
+          # ------------------------------------------------------------------
+
+          private
+          def self.random_name
+            (0...12).map { ("a".."z").to_a.values_at(rand(26)) }.join.capitalize
+          end
+
+          # ------------------------------------------------------------------
+          # TODO: Put in a better place.
+          # ------------------------------------------------------------------
+
+          add_by_class :internal, :data, :all, ["@uri"]
+          add_by_class :internal, :sprockets, :all, [
+            "accept", "write_to"
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/bunto/assets/liquid/tag.rb

@@ -0,0 +1,203 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2016-present - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+require "fastimage"
+
+module Bunto
+  module Assets
+    module Liquid
+      class Tag < ::Liquid::Tag
+        require_relative "tag/proxies"
+        require_relative "tag/proxied_asset"
+        require_relative "tag/defaults"
+        require_relative "tag/parser"
+        attr_reader :args
+
+        # --------------------------------------------------------------------
+
+        class << self
+          public :new
+        end
+
+        # --------------------------------------------------------------------
+
+        class AssetNotFoundError < StandardError
+          def initialize(asset)
+            super "Could not find the asset `#{asset}'"
+          end
+        end
+
+        # --------------------------------------------------------------------
+        # Tags that we allow our users to use.
+        # --------------------------------------------------------------------
+
+        AcceptableTags = %W(
+          img
+          image
+          javascript
+          asset_source
+          stylesheet
+          asset_path
+          style
+          asset
+          css
+          js
+        ).freeze
+
+        # --------------------------------------------------------------------
+        # The HTML version of every tag that we accept.
+        # --------------------------------------------------------------------
+
+        Tags = {
+          "css" => %{<link type="text/css" rel="stylesheet" href="%s"%s>},
+          "js"  => %{<script type="text/javascript" src="%s"%s></script>},
+          "img" => %{<img src="%s"%s>}
+        }.freeze
+
+        # --------------------------------------------------------------------
+        # Allows us to normalize tags so we can simplify logic.
+        # --------------------------------------------------------------------
+
+        Alias = {
+          "image" => "img",
+          "stylesheet" => "css",
+          "javascript" => "js",
+          "style" => "css"
+        }.freeze
+
+        # --------------------------------------------------------------------
+
+        def initialize(tag, args, tokens)
+          tag = tag.to_s
+          @tokens = tokens
+          @tag = from_alias(tag)
+          @args = Parser.new(args, @tag)
+          @og_tag = tag
+          super
+        end
+
+        # --------------------------------------------------------------------
+        # NOTE: We only attach to the regenerator if you are using digested
+        #   assets, otherwise we forego any association with it so that we keep
+        #   your builds ultra fast, this is ideal in dev.  Disable digests and
+        #   let us process independent so the entire site isn't regenerated
+        #   because of a single asset change.
+        # --------------------------------------------------------------------
+
+        def render(context)
+          site = context.registers[:site]
+          page = context.registers.fetch(:page, {})
+          args = @args.parse_liquid(context)
+          sprockets = site.sprockets
+          page = page["path"]
+
+          asset = find_asset(args, sprockets)
+          add_as_bunto_dependency(site, sprockets, page, asset)
+          process_tag(args, sprockets, asset)
+
+        rescue => e
+          capture_and_out_error(
+            site, e
+          )
+        end
+
+        # --------------------------------------------------------------------
+
+        private
+        def from_alias(tag)
+          Alias.key?(tag) ? Alias[tag] : tag
+        end
+
+        # --------------------------------------------------------------------
+
+        private
+        def process_tag(args, sprockets, asset)
+          sprockets.used.add(asset) unless @tag == "asset_source"
+          Defaults.set_defaults_for!(@tag, args ||= {}, asset, sprockets)
+          build_html(args, sprockets, asset)
+        end
+
+        # --------------------------------------------------------------------
+
+        private
+        def build_html(args, sprockets, asset, path = get_path(sprockets, asset))
+          return path if @tag == "asset_path"
+          return asset.to_s if @tag == "asset" || @tag == "asset_source"
+          return format(Tags[@tag], asset.data_uri, args.to_html) if args.key?(:data) && args[:data].key?(:uri)
+          format(Tags[@tag], path, args.to_html)
+        end
+
+        # --------------------------------------------------------------------
+
+        private
+        def get_path(sprockets, asset)
+          sprockets.prefix_path(
+            sprockets.digest?? asset.digest_path : asset.logical_path
+          )
+        end
+
+        # --------------------------------------------------------------------
+
+        private
+        def add_as_bunto_dependency(site, sprockets, page, asset)
+          if page && sprockets.digest?
+            site.regenerator.add_dependency(
+              site.in_source_dir(page), site.in_source_dir(asset.logical_path)
+            )
+          end
+        end
+
+        # --------------------------------------------------------------------
+
+        private
+        def find_asset(args, sprockets)
+          sprockets_, file = args[:sprockets] ||= {}, args[:file]
+          if !(out = sprockets.find_asset(file, sprockets_))
+            raise(
+              AssetNotFoundError, args[:file]
+            )
+
+          else
+            out.liquid_tags << self
+            !args.proxies?? out : ProxiedAsset.new(
+              out, args, sprockets, self
+            )
+          end
+        end
+
+        # --------------------------------------------------------------------
+        # There is no guarantee that Bunto will pass on the error for some
+        # reason (unless you are just booting up) so we capture that error and
+        # always output it, it can lead to some double errors but I would
+        # rather there be a double error than no error.
+        # --------------------------------------------------------------------
+
+        private
+        def capture_and_out_error(site, error)
+          if error.is_a?(Sass::SyntaxError)
+            file = error.sass_filename.gsub(/#{Regexp.escape(site.source)}\//, "")
+            Bunto.logger.error(%{Error in #{file}:#{error.sass_line} #{
+              error
+            }})
+
+          else
+            Bunto.logger.error(
+              "", error.to_s
+            )
+          end
+
+          raise error
+        end
+      end
+    end
+  end
+end
+
+# ----------------------------------------------------------------------------
+
+Bunto::Assets::Liquid::Tag::AcceptableTags.each do |tag|
+  Liquid::Template.register_tag tag, Bunto::Assets::Liquid::Tag
+end

data/lib/bunto/assets/liquid.rb

@@ -0,0 +1,15 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2016-present - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Bunto
+  module Assets
+    module Liquid
+      require_relative "liquid/drop"
+      require_relative "liquid/filters"
+      require_relative "liquid/tag"
+    end
+  end
+end

data/lib/bunto/assets/logger.rb

@@ -0,0 +1,59 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2016-present - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Bunto
+  module Assets
+    class Logger
+      PREFIX = "Bunto Assets:"
+
+      def log
+        @_log ||= Bunto.logger
+      end
+
+      # ----------------------------------------------------------------------
+      # Log Level: 1
+      # ----------------------------------------------------------------------
+
+      def warn(msg = nil, &block)
+        msg = (block_given?? block.call : msg)
+        log.warn(PREFIX, msg)
+      end
+
+      # ----------------------------------------------------------------------
+      # Log Level: 1
+      # ----------------------------------------------------------------------
+
+      def error(msg = nil, &block)
+        msg = (block_given?? block.call : msg)
+        log.error(PREFIX, msg)
+      end
+
+      # ----------------------------------------------------------------------
+      # Log Level: 2
+      # ----------------------------------------------------------------------
+
+      def info(msg = nil, &block)
+        msg = (block_given?? block.call : msg)
+        log.info(PREFIX, msg)
+      end
+
+      # ----------------------------------------------------------------------
+      # Log Level: 3
+      # ----------------------------------------------------------------------
+
+      def debug(msg = nil, &block)
+        msg = (block_given?? block.call : msg)
+        log.debug(PREFIX, msg)
+      end
+
+      # ----------------------------------------------------------------------
+
+      def log_level=(*)
+        raise RuntimeError, "Please set log levels on Bunto.logger"
+      end
+    end
+  end
+end

data/lib/bunto/assets/patches/bunto/cleaner.rb

@@ -0,0 +1,16 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2016-present - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Bunto
+  class Cleaner
+    alias _old_obsolete_files obsolete_files
+    def obsolete_files
+      _old_obsolete_files.delete_if do |path|
+        path =~ %r!\A#{Regexp.escape(site.in_dest_dir("assets"))}(\/.*)?\Z!
+      end
+    end
+  end
+end

data/lib/bunto/assets/patches/bunto/site.rb

@@ -0,0 +1,11 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2016-present - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Bunto
+  class Site
+    attr_accessor :sprockets
+  end
+end

data/lib/bunto/assets/patches/kernel.rb

@@ -0,0 +1,29 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2016-present - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Kernel
+  def try_require(file)
+    require file
+    if block_given?
+      yield
+    end
+  rescue LoadError
+    return nil
+  end
+
+  # --------------------------------------------------------------------------
+
+  def try_require_if_javascript(file)
+    ["execjs", file].map(&method(:require))
+    if block_given?
+      yield
+    end
+  rescue LoadError, ExecJS::RuntimeUnavailable
+    Bunto.logger.debug("ExecJS, JS Runtime or `#{file}' not available." \
+      " Skipping the loading of libraries.")
+    return
+  end
+end

data/lib/bunto/assets/patches/sprockets/asset.rb

@@ -0,0 +1,21 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2016-present - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Sprockets
+  class Asset
+    def liquid_tags
+      metadata[:liquid_tags] ||= Set.new
+    end
+
+    # ------------------------------------------------------------------------
+
+    def data_uri
+      "data:#{content_type};base64,#{Rack::Utils.escape(
+        Base64.encode64(to_s)
+      )}"
+    end
+  end
+end

data/lib/bunto/assets/patches.rb

@@ -0,0 +1,10 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2016-present - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+require_relative "patches/bunto/cleaner"
+require_relative "patches/sprockets/asset"
+require_relative "patches/bunto/site"
+require_relative "patches/kernel"

data/lib/bunto/assets/processors/liquid.rb

@@ -0,0 +1,42 @@
+module Bunto
+  module Assets
+    module Processors
+      class Liquid
+        FOR = %W(
+          text/css text/sass text/less application/javascript
+          text/scss text/coffeescript text/javascript).freeze
+        EXT = %W(.liquid .js.liquid .css.liquid .scss.liquid).freeze
+
+        # --------------------------------------------------------------------
+
+        def self.call(context, bunto = context[:environment].bunto)
+          if context[:environment].parent.asset_config["features"]["liquid"] || \
+              File.extname(context[:filename]) == ".liquid"
+
+            payload_ = bunto.site_payload
+            renderer = bunto.liquid_renderer.file(context[:filename])
+            context[:data] = renderer.parse(context[:data]).render! payload_, :registers => {
+              :site => bunto
+            }
+          end
+        end
+      end
+    end
+  end
+end
+
+# ----------------------------------------------------------------------------
+# There might be a few missing, if there is please do let me know.
+# ----------------------------------------------------------------------------
+
+Bunto::Assets::Processors::Liquid::EXT.each do |ext|
+  Sprockets.register_engine(
+    ext, Bunto::Assets::Processors::Liquid
+  )
+end
+
+Bunto::Assets::Processors::Liquid::FOR.each do |val|
+  Sprockets.register_preprocessor(
+    val, Bunto::Assets::Processors::Liquid
+  )
+end