jekyll-assets 2.0.0.pre.beta2 → 2.0.0.pre.beta3

data/lib/jekyll/assets/context.rb

@@ -1,23 +0,0 @@
-module Jekyll
-  module Assets
-    class Context
-      def initialize(context)
-        patch context
-      end
-
-      def patch(what)
-        what.class_eval do
-          alias_method :_old_asset_path, :asset_path
-          def asset_path(asset, opts = {})
-            out = _old_asset_path asset
-            return unless out
-
-            environment.parent.used.add(environment.find_asset \
-              resolve(asset))
-          out
-          end
-        end
-      end
-    end
-  end
-end

data/lib/jekyll/assets/extras/font-awesome.rb

@@ -1 +0,0 @@
-Jekyll::Assets::Helpers.try_require "font-awesome-sass"

data/lib/jekyll/assets/extras/helpers.rb

@@ -1,6 +0,0 @@
-Jekyll::Assets::Hook.register :env, :post_init do |e|
-  Sprockets::Helpers.configure do |c|
-    c.prefix   = e.prefix_path
-    c.digest   =     e.digest?
-  end
-end

data/lib/jekyll/assets/extras/prefix.rb

@@ -1,5 +0,0 @@
-Jekyll::Assets::Helpers.try_require_if_javascript? "autoprefixer-rails" do
-  Jekyll::Assets::Hook.register :env, :post_init do |e|
-    AutoprefixerRails.install(e)
-  end
-end

data/lib/jekyll/assets/filters.rb

@@ -1,17 +0,0 @@
-module Jekyll
-  module Assets
-    module Filters
-      %W(js css img image javascript stylesheet style asset_path).each do |v|
-        define_method v do |path, args = ""|
-          Tag.send(:new, v, "#{path} #{args}", "").render(
-            @context
-          )
-        end
-      end
-    end
-  end
-end
-
-Liquid::Template.register_filter(
-  Jekyll::Assets::Filters
-)

data/lib/jekyll/assets/helpers.rb

@@ -1,37 +0,0 @@
-module Jekyll
-  module Assets
-    module Helpers
-      class << self
-        def has_javascript?
-          require "execjs"
-          if block_given?
-            yield
-          end
-        rescue LoadError, ExecJS::RuntimeUnavailable
-          Jekyll.logger.debug("ExecJS or JS Runtime not available." \
-            " Skipping loading of library.")
-        end
-
-        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
-          Jekyll.logger.debug("ExecJS, JS Runtime or `#{file}' not available." \
-            " Skipping the loading of libraries.")
-          return
-        end
-      end
-    end
-  end
-end

data/lib/jekyll/assets/hooks/post_read.rb

@@ -1,3 +0,0 @@
-Jekyll::Hooks.register :site, :post_read do |s|
-  Jekyll::Assets::Env.new(s)
-end

data/lib/jekyll/assets/hooks/post_write.rb

@@ -1,3 +0,0 @@
-Jekyll::Hooks.register :site, :post_write do |s|
-  s.sprockets.write_all
-end

data/lib/jekyll/assets/tag.rb

@@ -1,148 +0,0 @@
-module Jekyll
-  module Assets
-
-    # TODO: Somewhere in here we need to designate the proxy as an asset
-    #   so that the env does not need to be aware of anything.
-
-    class Tag < Liquid::Tag
-      require_relative "tag/proxied_asset"
-      require_relative "tag/parser"
-      attr_reader :args
-
-      class AssetNotFoundError < StandardError
-        def initialize(asset)
-          super "Could not find the asset `#{asset}'"
-        end
-      end
-
-      TAGS = {
-        "css" => %Q{<link type="text/css" rel="stylesheet" href="%s"%s>},
-        "js"  => %Q{<script type="text/javascript" src="%s"%s></script>},
-        "img" => %Q{<img src="%s"%s>}
-      }
-
-      ALIAS = {
-        "image" => "img",
-        "stylesheet" => "css",
-        "javascript" => "js",
-        "style" => "css"
-      }
-
-      def initialize(tag, args, tokens)
-        @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, {}).fetch("path", nil)
-        sprockets = site.sprockets
-
-        asset = find_asset(sprockets)
-        add_as_jekyll_dependency(site, sprockets, page, asset)
-        process_tag(sprockets, asset)
-      rescue => e
-        capture_and_out_error \
-          site, e
-      end
-
-      private
-      def from_alias(tag)
-        ALIAS[tag] || \
-          tag
-      end
-
-      private
-      def process_tag(sprockets, asset)
-        set_img_alt asset if @tag == "img"
-        out = get_path sprockets, asset
-        sprockets.used.add(asset)
-
-        if @tag == "asset_path"
-          return out
-
-        elsif @tag == "asset" || @tag == "asset_source"
-          return asset.to_s
-
-        elsif @args[:data][:uri]
-          return TAGS[@tag] % [
-            asset.data_uri, @args.to_html
-          ]
-
-        else
-          return TAGS[@tag] % [
-            out, @args.to_html
-          ]
-        end
-      end
-
-      private
-      def get_path(sprockets, asset)
-        sprockets.prefix_path(
-          sprockets.digest?? asset.digest_path : asset.logical_path
-        )
-      end
-
-      private
-      def set_img_alt(asset)
-        if !@args[:html]["alt"]
-          return @args[:html]["alt"] = asset.logical_path
-        end
-      end
-
-      private
-      def add_as_jekyll_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(sprockets)
-        if !(out = sprockets.find_asset(@args[:file], @args[:sprockets]))
-          raise AssetNotFoundError, @args[:file]
-        else
-          out.liquid_tags << self
-          if !@args.has_proxies?
-            out else ProxiedAsset.new(
-              out, @args, sprockets, self
-            )
-          end
-        end
-      end
-
-      # There is no guarantee that Jekyll 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)}\//, "")
-          Jekyll.logger.error(%Q{Error in #{file}:#{error.sass_line}  #{error}})
-        else
-          Jekyll.logger.error \
-            "", error.to_s
-        end
-
-        raise error
-      end
-    end
-  end
-end
-
-%W(js css img image javascript stylesheet style asset_path asset_source asset).each do |t|
-  Liquid::Template.register_tag t, Jekyll::Assets::Tag
-end

data/lib/jekyll/assets/tag/parser.rb

@@ -1,129 +0,0 @@
-require_relative "proxies"
-require "forwardable"
-
-module Jekyll
-  module Assets
-
-    # Examples:
-    #   - {% tag value argument:value %}
-    #   - {% tag value "argument:value" %}
-    #   - {% tag value argument:"I have spaces" %}
-    #   - {% tag value argument:value\:with\:colon %}
-    #   - {% tag value argument:"I can even escape \\: here too!" %}
-    #   - {% tag value proxy:key:value %}
-
-    class Tag
-      class Parser
-        attr_reader :args, :raw_args
-        extend Forwardable
-
-        def_delegator :@args, :to_h
-        def_delegator :@args, :has_key?
-        def_delegator :@args, :fetch
-        def_delegator :@args, :[]
-
-        ACCEPT = {
-          "css" => "text/css", "js" => "application/javascript"
-        }
-
-        class UnescapedColonError < StandardError
-          def initialize
-            super "Unescaped double colon argument."
-          end
-        end
-
-        class UnknownProxyError < StandardError
-          def initialize
-            super "Unknown proxy argument."
-          end
-        end
-
-        def initialize(args, tag)
-          @raw_args, @tags = args, tag
-          @tag = tag
-          parse_raw
-          set_accept
-        end
-
-        def to_html
-          @args[:html].map do |k, v|
-            %Q{ #{k}="#{v}"}
-          end. \
-          join
-        end
-
-        def proxies
-          keys = (args.keys - Proxies.base_keys - [:file, :html])
-          args.select do |k, v|
-            keys.include?(k)
-          end
-        end
-
-        def has_proxies?
-          proxies.any?
-        end
-
-        private
-        def parse_raw
-          @args = from_shellwords.each_with_index.inject(dhash) do |h, (k, i)|
-            if i == 0 then h[:file] = k
-              elsif k =~ /:/ && (k = k.split(/(?<!\\):/)) then parse_col h, k
-              else h[:html][k] = true
-            end
-
-            h
-          end
-        end
-
-        private
-        def parse_col(h, k)
-          k[-1] = k[-1].gsub(/\\:/, ":")
-          if k.size == 3 then as_proxy h, k
-            elsif k.size == 2 then as_bool_or_html h, k
-            else raise UnescapedColonError
-          end
-        end
-
-        private
-        def as_bool_or_html(h, k)
-          key, sub_key = k
-          if Proxies.has?(key, @tag, "@#{sub_key}")
-            h[key.to_sym][sub_key.to_sym] = true
-          else
-            h[:html][key] = k[1]
-          end
-        end
-
-        private
-        def as_proxy(h, k)
-          key, sub_key, value = k
-          if Proxies.has?(key, @tag, sub_key)
-            h[key.to_sym][sub_key.to_sym] = \
-              value
-          elsif Proxies.has?(key)
-            raise UnknownProxyError
-          end
-        end
-
-        private
-        def set_accept
-          if (accept = ACCEPT[@tag]) && !args[:sprockets][:accept]
-            @args[:sprockets][:accept]  =  accept
-          end
-        end
-
-        private
-        def dhash
-          Hash.new do |h, k|
-            h[k] = {}
-          end
-        end
-
-        private
-        def from_shellwords
-          Shellwords.shellwords(@raw_args)
-        end
-      end
-    end
-  end
-end

data/lib/jekyll/assets/tag/proxied_asset.rb

@@ -1,84 +0,0 @@
-require "forwardable"
-
-module Jekyll
-  module Assets
-    class Tag
-      class ProxiedAsset
-        attr_reader :args, :asset, :env
-        extend Forwardable
-
-        def_delegator :@asset, :liquid_tags
-        def_delegator :@asset, :content_type
-        def_delegator :@asset, :filename
-
-        def initialize(asset, args, env, tag)
-          @env = env
-          @asset = asset
-          @args = args
-          @tag = tag
-          cache_file
-          proxy_file
-        end
-
-        def cached?
-          @_cached
-        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)
-          "#{File.basename(name, ext)}-#{digest}#{ext}"
-        end
-
-        def write_to(name)
-          File.binwrite(
-            name, source
-          )
-        end
-
-        private
-        def proxy_file
-          unless cached?
-            args.proxies.each do |k, v|
-              Proxies.get(k).first[:cls].new(self, v).process
-            end
-          end
-        end
-
-        private
-        def cache_file
-          if File.file?(filename)
-            @_cached = true else @_cached = false
-            FileUtils.cp asset.filename, filename
-          end
-        end
-      end
-    end
-  end
-end