sprockets 4.0.1

data/lib/sprockets/eco_processor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+
+module Sprockets
+  # Processor engine class for the Eco compiler. Depends on the `eco` gem.
+  #
+  # For more infomation see:
+  #
+  #   https://github.com/sstephenson/ruby-eco
+  #   https://github.com/sstephenson/eco
+  #
+  module EcoProcessor
+    VERSION = '1'
+
+    def self.cache_key
+      @cache_key ||= "#{name}:#{Autoload::Eco::Source::VERSION}:#{VERSION}".freeze
+    end
+
+    # Compile template data with Eco compiler.
+    #
+    # Returns a JS function definition String. The result should be
+    # assigned to a JS variable.
+    #
+    #     # => "function(...) {...}"
+    #
+    def self.call(input)
+      data = input[:data]
+      input[:cache].fetch([cache_key, data]) do
+        Autoload::Eco.compile(data)
+      end
+    end
+  end
+end

data/lib/sprockets/ejs_processor.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+
+module Sprockets
+  # Processor engine class for the EJS compiler. Depends on the `ejs` gem.
+  #
+  # For more infomation see:
+  #
+  #   https://github.com/sstephenson/ruby-ejs
+  #
+  module EjsProcessor
+    VERSION = '1'
+
+    def self.cache_key
+      @cache_key ||= "#{name}:#{VERSION}".freeze
+    end
+
+    # Compile template data with EJS compiler.
+    #
+    # Returns a JS function definition String. The result should be
+    # assigned to a JS variable.
+    #
+    #     # => "function(obj){...}"
+    #
+    def self.call(input)
+      data = input[:data]
+      input[:cache].fetch([cache_key, data]) do
+        Autoload::EJS.compile(data)
+      end
+    end
+  end
+end

data/lib/sprockets/encoding_utils.rb

@@ -0,0 +1,262 @@
+# frozen_string_literal: true
+require 'base64'
+require 'stringio'
+require 'zlib'
+
+module Sprockets
+  # Internal: HTTP transport encoding and charset detecting related functions.
+  # Mixed into Environment.
+  module EncodingUtils
+    extend self
+
+    ## Binary encodings ##
+
+    # Public: Use deflate to compress data.
+    #
+    # str - String data
+    #
+    # Returns a compressed String
+    def deflate(str)
+      deflater = Zlib::Deflate.new(
+        Zlib::BEST_COMPRESSION,
+        -Zlib::MAX_WBITS,
+        Zlib::MAX_MEM_LEVEL,
+        Zlib::DEFAULT_STRATEGY
+      )
+      deflater << str
+      deflater.finish
+    end
+
+    # Internal: Unmarshal optionally deflated data.
+    #
+    # Checks leading marshal header to see if the bytes are uncompressed
+    # otherwise inflate the data an unmarshal.
+    #
+    # str - Marshaled String
+    # window_bits - Integer deflate window size. See ZLib::Inflate.new()
+    #
+    # Returns unmarshaled Object or raises an Exception.
+    def unmarshaled_deflated(str, window_bits = -Zlib::MAX_WBITS)
+      major, minor = str[0], str[1]
+      if major && major.ord == Marshal::MAJOR_VERSION &&
+          minor && minor.ord <= Marshal::MINOR_VERSION
+        marshaled = str
+      else
+        begin
+          marshaled = Zlib::Inflate.new(window_bits).inflate(str)
+        rescue Zlib::DataError
+          marshaled = str
+        end
+      end
+      Marshal.load(marshaled)
+    end
+
+    # Public: Use gzip to compress data.
+    #
+    # str - String data
+    #
+    # Returns a compressed String
+    def gzip(str)
+      io = StringIO.new
+      gz = Zlib::GzipWriter.new(io, Zlib::BEST_COMPRESSION)
+      gz.mtime = 1
+      gz << str
+      gz.finish
+      io.string
+    end
+
+    # Public: Use base64 to encode data.
+    #
+    # str - String data
+    #
+    # Returns a encoded String
+    def base64(str)
+      Base64.strict_encode64(str)
+    end
+
+
+    ## Charset encodings ##
+
+    # Internal: Shorthand aliases for detecter functions.
+    CHARSET_DETECT = {}
+
+    # Internal: Mapping unicode encodings to byte order markers.
+    BOM = {
+      Encoding::UTF_32LE => [0xFF, 0xFE, 0x00, 0x00],
+      Encoding::UTF_32BE => [0x00, 0x00, 0xFE, 0xFF],
+      Encoding::UTF_8    => [0xEF, 0xBB, 0xBF],
+      Encoding::UTF_16LE => [0xFF, 0xFE],
+      Encoding::UTF_16BE => [0xFE, 0xFF]
+    }
+
+    # Public: Basic string detecter.
+    #
+    # Attempts to parse any Unicode BOM otherwise falls back to the
+    # environment's external encoding.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns encoded String.
+    def detect(str)
+      str = detect_unicode_bom(str)
+
+      # Attempt Charlock detection
+      if str.encoding == Encoding::BINARY
+        charlock_detect(str)
+      end
+
+      # Fallback to environment's external encoding
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding.default_external)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:default] = method(:detect)
+
+    # Internal: Use Charlock Holmes to detect encoding.
+    #
+    # To enable this code path, require 'charlock_holmes'
+    #
+    # Returns encoded String.
+    def charlock_detect(str)
+      if defined? CharlockHolmes::EncodingDetector
+        if detected = CharlockHolmes::EncodingDetector.detect(str)
+          str.force_encoding(detected[:encoding]) if detected[:encoding]
+        end
+      end
+
+      str
+    end
+
+    # Public: Detect Unicode string.
+    #
+    # Attempts to parse Unicode BOM and falls back to UTF-8.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns encoded String.
+    def detect_unicode(str)
+      str = detect_unicode_bom(str)
+
+      # Fallback to UTF-8
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding::UTF_8)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:unicode] = method(:detect_unicode)
+
+    # Public: Detect and strip BOM from possible unicode string.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns UTF 8/16/32 encoded String without BOM or the original String if
+    # no BOM was present.
+    def detect_unicode_bom(str)
+      bom_bytes = str.byteslice(0, 4).bytes.to_a
+
+      BOM.each do |encoding, bytes|
+        if bom_bytes[0, bytes.size] == bytes
+          str = str.dup
+          str.force_encoding(Encoding::BINARY)
+          str.slice!(0, bytes.size)
+          str.force_encoding(encoding)
+          return str
+        end
+      end
+
+      return str
+    end
+
+    # Public: Detect and strip @charset from CSS style sheet.
+    #
+    # str - String.
+    #
+    # Returns a encoded String.
+    def detect_css(str)
+      str = detect_unicode_bom(str)
+
+      if name = scan_css_charset(str)
+        encoding = Encoding.find(name)
+        str = str.dup
+        str.force_encoding(encoding)
+        len = "@charset \"#{name}\";".encode(encoding).size
+        str.slice!(0, len)
+        str
+      end
+
+      # Fallback to UTF-8
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding::UTF_8)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:css] = method(:detect_css)
+
+    # Internal: @charset bytes
+    CHARSET_START = [0x40, 0x63, 0x68, 0x61, 0x72, 0x73, 0x65, 0x74, 0x20, 0x22]
+    CHARSET_SIZE  = CHARSET_START.size
+
+    # Internal: Scan binary CSS string for @charset encoding name.
+    #
+    # str - ASCII-8BIT encoded String
+    #
+    # Returns encoding String name or nil.
+    def scan_css_charset(str)
+      buf = []
+      i = 0
+
+      str.each_byte.each do |byte|
+        # Halt on line breaks
+        break if byte == 0x0A || byte == 0x0D
+
+        # Only ascii bytes
+        next unless 0x0 < byte && byte <= 0xFF
+
+        if i < CHARSET_SIZE
+        elsif i == CHARSET_SIZE
+          if buf == CHARSET_START
+            buf = []
+          else
+            break
+          end
+        elsif byte == 0x22
+          return buf.pack('C*')
+        end
+
+        buf << byte
+        i += 1
+      end
+
+      nil
+    end
+
+    # Public: Detect charset from HTML document.
+    #
+    # Attempts to parse any Unicode BOM otherwise attempt Charlock detection
+    # and finally falls back to the environment's external encoding.
+    #
+    # str - String.
+    #
+    # Returns a encoded String.
+    def detect_html(str)
+      str = detect_unicode_bom(str)
+
+      # Attempt Charlock detection
+      if str.encoding == Encoding::BINARY
+        charlock_detect(str)
+      end
+
+      # Fallback to environment's external encoding
+      if str.encoding == Encoding::BINARY
+        str.force_encoding(Encoding.default_external)
+      end
+
+      str
+    end
+    CHARSET_DETECT[:html] = method(:detect_html)
+  end
+end

data/lib/sprockets/environment.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+require 'sprockets/base'
+require 'sprockets/cache/memory_store'
+require 'sprockets/cached_environment'
+
+module Sprockets
+  class Environment < Base
+    # `Environment` should be initialized with your application's root
+    # directory. This should be the same as your Rails or Rack root.
+    #
+    #     env = Environment.new(Rails.root)
+    #
+    def initialize(root = ".")
+      initialize_configuration(Sprockets)
+      self.root = root
+      self.cache = Cache::MemoryStore.new
+      yield self if block_given?
+    end
+
+    # Returns a cached version of the environment.
+    #
+    # All of its file system calls are cached which makes `cached` much
+    # faster. This behavior is ideal in production since the file
+    # system only changes between deploys.
+    def cached
+      CachedEnvironment.new(self)
+    end
+    alias_method :index, :cached
+
+    def find_asset(*args, **options)
+      cached.find_asset(*args, **options)
+    end
+
+    def find_asset!(*args)
+      cached.find_asset!(*args)
+    end
+
+    def find_all_linked_assets(*args, &block)
+      cached.find_all_linked_assets(*args, &block)
+    end
+
+    def load(*args)
+      cached.load(*args)
+    end
+  end
+end

data/lib/sprockets/erb_processor.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require 'erb'
+
+class Sprockets::ERBProcessor
+  # Public: Return singleton instance with default options.
+  #
+  # Returns ERBProcessor object.
+  def self.instance
+    @instance ||= new
+  end
+
+  def self.call(input)
+    instance.call(input)
+  end
+
+  def initialize(&block)
+    @block = block
+  end
+
+  def call(input)
+    match = ERB.version.match(/\Aerb\.rb \[(?<version>[^ ]+) /)
+    if match && match[:version] >= "2.2.0" # Ruby 2.6+
+      engine = ::ERB.new(input[:data], trim_mode: '<>')
+    else
+      engine = ::ERB.new(input[:data], nil, '<>')
+    end
+    engine.filename = input[:filename]
+
+    context = input[:environment].context_class.new(input)
+    klass = (class << context; self; end)
+    klass.const_set(:ENV, context.env_proxy)
+    klass.class_eval(&@block) if @block
+
+    data = engine.result(context.instance_eval('binding'))
+    context.metadata.merge(data: data)
+  end
+end

data/lib/sprockets/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+# Define some basic Sprockets error classes
+module Sprockets
+  class Error           < StandardError; end
+  class ArgumentError           < Error; end
+  class ContentTypeMismatch     < Error; end
+  class NotImplementedError     < Error; end
+  class NotFound                < Error; end
+  class ConversionError         < NotFound; end
+  class FileNotFound            < NotFound; end
+  class FileOutsidePaths        < NotFound; end
+end

data/lib/sprockets/exporters/base.rb

@@ -0,0 +1,71 @@
+module Sprockets
+  module Exporters
+    # Convienence class for all exporters to inherit from
+    #
+    # An exporter is responsible for exporting a Sprockets::Asset
+    # to a file system. For example the Exporters::File class
+    # writes the asset to it's destination. The Exporters::Zlib class
+    # writes a gzip copy of the asset to disk.
+    class Base
+      attr_reader :asset, :environment, :directory, :target
+
+      # Public: Creates new instance
+      #
+      # Initialize will be called with
+      # keyword arguments:
+      #
+      # - asset: An instance of Sprockets::Asset.
+      # - environment: An instance of Sprockets::Environment.
+      # - directory: String representing the target directory to write to.
+      #
+      # These will all be stored as accessible values. In addition a
+      # +target+ will be available which is the target directory and
+      # the asset's digest path combined.
+      def initialize(asset: nil, environment: nil, directory: nil)
+        @asset       = asset
+        @environment = environment
+        @directory   = directory
+        @target      = ::File.join(directory, asset.digest_path)
+        setup
+      end
+
+      # Public: Callback that is executed after intialization
+      #
+      # Any setup that needs to be done can be performed in the +setup+
+      # method. It will be called immediately after initialization.
+      def setup
+      end
+
+      # Public: Handles logic for skipping exporter and notifying logger
+      #
+      # The `skip?` will be called before anything will be written.
+      # If `skip?` returns truthy it will not continue. This method
+      # takes a `logger` that responds to +debug+ and +info+.  The `skip?`
+      # method is the only place expected to write to a logger, any other
+      # messages may produce jumbled logs.
+      def skip?(logger)
+        false
+      end
+
+      # Public: Contains logic for writing "exporting" asset to disk
+      #
+      # If the exporter is not skipped it then Sprockets will execute it's
+      # `call` method. This method takes no arguments and should only use
+      # elements passed in via initialize or stored in `setup`.
+      def call
+        raise "Must subclass and implement call"
+      end
+
+      # Public: Yields a file that can be written to with the input
+      #
+      # `filename`. Defaults to the `target`. Method
+      # is safe to use in forked or threaded environments.
+      def write(filename = target)
+        FileUtils.mkdir_p File.dirname(filename)
+        PathUtils.atomic_write(filename) do |f|
+          yield f
+        end
+      end
+    end
+  end
+end