sprockets 2.2.3 → 4.0.0

data/lib/sprockets/utils.rb

@@ -1,69 +1,202 @@
+# frozen_string_literal: true
+require 'set'
+
 module Sprockets
-  # `Utils`, we didn't know where else to put it!
+  # Internal: Utils, we didn't know where else to put it! Functions may
+  # eventually be shuffled into more specific drawers.
   module Utils
-    # If theres encoding support (aka Ruby 1.9)
-    if "".respond_to?(:valid_encoding?)
-      # Define UTF-8 BOM pattern matcher.
-      # Avoid using a Regexp literal because it inheirts the files
-      # encoding and we want to avoid syntax errors in other interpreters.
-      UTF8_BOM_PATTERN = Regexp.new("\\A\uFEFF".encode('utf-8'))
-
-      def self.read_unicode(pathname, external_encoding = Encoding.default_external)
-        pathname.open("r:#{external_encoding}") do |f|
-          f.read.tap do |data|
-            # Eager validate the file's encoding. In most cases we
-            # expect it to be UTF-8 unless `default_external` is set to
-            # something else. An error is usually raised if the file is
-            # saved as UTF-16 when we expected UTF-8.
-            if !data.valid_encoding?
-              raise EncodingError, "#{pathname} has a invalid " +
-                "#{data.encoding} byte sequence"
-
-            # If the file is UTF-8 and theres a BOM, strip it for safe concatenation.
-            elsif data.encoding.name == "UTF-8" && data =~ UTF8_BOM_PATTERN
-              data.sub!(UTF8_BOM_PATTERN, "")
-            end
-          end
-        end
+    extend self
+
+    # Internal: Check if object can safely be .dup'd.
+    #
+    # Similar to ActiveSupport #duplicable? check.
+    #
+    # obj - Any Object
+    #
+    # Returns false if .dup would raise a TypeError, otherwise true.
+    def duplicable?(obj)
+      case obj
+      when NilClass, FalseClass, TrueClass, Symbol, Numeric
+        false
+      else
+        true
       end
+    end
 
-    else
-      # Define UTF-8 and UTF-16 BOM pattern matchers.
-      # Avoid using a Regexp literal to prevent syntax errors in other interpreters.
-      UTF8_BOM_PATTERN  = Regexp.new("\\A\\xEF\\xBB\\xBF")
-      UTF16_BOM_PATTERN = Regexp.new("\\A(\\xFE\\xFF|\\xFF\\xFE)")
-
-      def self.read_unicode(pathname)
-        pathname.read.tap do |data|
-          # If the file is UTF-8 and theres a BOM, strip it for safe concatenation.
-          if data =~ UTF8_BOM_PATTERN
-            data.sub!(UTF8_BOM_PATTERN, "")
-
-          # If we find a UTF-16 BOM, theres nothing we can do on
-          # 1.8. Only UTF-8 is supported.
-          elsif data =~ UTF16_BOM_PATTERN
-            raise EncodingError, "#{pathname} has a UTF-16 BOM. " +
-              "Resave the file as UTF-8 or upgrade to Ruby 1.9."
-          end
+    # Internal: Duplicate and store key/value on new frozen hash.
+    #
+    # Seperated for recursive calls, always use hash_reassoc(hash, *keys).
+    #
+    # hash - Hash
+    # key  - Object key
+    #
+    # Returns Hash.
+    def hash_reassoc1(hash, key)
+      hash = hash.dup if hash.frozen?
+      old_value = hash[key]
+      old_value = old_value.dup if duplicable?(old_value)
+      new_value = yield old_value
+      new_value.freeze if duplicable?(new_value)
+      hash.store(key, new_value)
+      hash.freeze
+    end
+
+    # Internal: Duplicate and store key/value on new frozen hash.
+    #
+    # Similar to Hash#store for nested frozen hashes.
+    #
+    # hash  - Hash
+    # key_a - Object key. Use multiple keys for nested hashes.
+    # key_b - Object key. Use multiple keys for nested hashes.
+    # block - Receives current value at key.
+    #
+    # Examples
+    #
+    #     config = {paths: ["/bin", "/sbin"]}.freeze
+    #     new_config = hash_reassoc(config, :paths) do |paths|
+    #       paths << "/usr/local/bin"
+    #     end
+    #
+    # Returns duplicated frozen Hash.
+    def hash_reassoc(hash, key_a, key_b = nil, &block)
+      if key_b
+        hash_reassoc1(hash, key_a) do |value|
+          hash_reassoc(value, key_b, &block)
         end
+      else
+        hash_reassoc1(hash, key_a, &block)
       end
     end
 
-    # Prepends a leading "." to an extension if its missing.
+    WHITESPACE_ORDINALS = {0x0A => "\n", 0x20 => " ", 0x09 => "\t"}
+    private_constant :WHITESPACE_ORDINALS
+
+    # Internal: Check if string has a trailing semicolon.
     #
-    #     normalize_extension("js")
-    #     # => ".js"
+    # str - String
     #
-    #     normalize_extension(".css")
-    #     # => ".css"
+    # Returns true or false.
+    def string_end_with_semicolon?(str)
+      i = str.size - 1
+      while i >= 0
+        c = str[i].ord
+        i -= 1
+
+        next if WHITESPACE_ORDINALS[c]
+
+        return c === 0x3B
+      end
+
+      true
+    end
+
+    # Internal: Accumulate asset source to buffer and append a trailing
+    # semicolon if necessary.
+    #
+    # buf    - String buffer to append to
+    # source - String source to append
     #
-    def self.normalize_extension(extension)
-      extension = extension.to_s
-      if extension[/^\./]
-        extension
+    # Returns buf String.
+    def concat_javascript_sources(buf, source)
+      return buf if source.bytesize <= 0
+
+      buf << source
+      # If the source contains non-ASCII characters, indexing on it becomes O(N).
+      # This will lead to O(N^2) performance in string_end_with_semicolon?, so we should use 32 bit encoding to make sure indexing stays O(1)
+      source = source.encode(Encoding::UTF_32LE) unless source.ascii_only?
+      return buf if string_end_with_semicolon?(source)
+
+      # If the last character in the string was whitespace,
+      # such as a newline, then we want to put the semicolon
+      # before the whitespace. Otherwise append a semicolon.
+      if whitespace = WHITESPACE_ORDINALS[source[-1].ord]
+        buf[-1] = ";#{whitespace}"
       else
-        ".#{extension}"
+        buf << ";"
+      end
+
+      buf
+    end
+
+    # Internal: Inject into target module for the duration of the block.
+    #
+    # mod - Module
+    #
+    # Returns result of block.
+    def module_include(base, mod)
+      old_methods = {}
+
+      mod.instance_methods.each do |sym|
+        old_methods[sym] = base.instance_method(sym) if base.method_defined?(sym)
+      end
+
+      mod.instance_methods.each do |sym|
+        method = mod.instance_method(sym)
+        base.send(:define_method, sym, method)
+      end
+
+      yield
+    ensure
+      mod.instance_methods.each do |sym|
+        base.send(:undef_method, sym) if base.method_defined?(sym)
+      end
+      old_methods.each do |sym, method|
+        base.send(:define_method, sym, method)
+      end
+    end
+
+    # Internal: Post-order Depth-First search algorithm.
+    #
+    # Used for resolving asset dependencies.
+    #
+    # initial - Initial Array of nodes to traverse.
+    # block   -
+    #   node  - Current node to get children of
+    #
+    # Returns a Set of nodes.
+    def dfs(initial)
+      nodes, seen = Set.new, Set.new
+      stack = Array(initial).reverse
+
+      while node = stack.pop
+        if seen.include?(node)
+          nodes.add(node)
+        else
+          seen.add(node)
+          stack.push(node)
+          stack.concat(Array(yield node).reverse)
+        end
       end
+
+      nodes
+    end
+
+    # Internal: Post-order Depth-First search algorithm that gathers all paths
+    # along the way.
+    #
+    # TODO: Rename function.
+    #
+    # path   - Initial Array node path
+    # block  -
+    #   node - Current node to get children of
+    #
+    # Returns an Array of node Arrays.
+    def dfs_paths(path)
+      paths = []
+      stack = [path]
+      seen  = Set.new
+
+      while path = stack.pop
+        seen.add(path.last)
+        paths << path
+
+        children = yield path.last
+        children.reverse_each do |node|
+          stack.push(path + [node]) unless seen.include?(node)
+        end
+      end
+
+      paths
     end
   end
 end

data/lib/sprockets/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module Sprockets
-  VERSION = "2.2.3"
+  VERSION = "4.0.0"
 end

data/lib/sprockets/yui_compressor.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+require 'sprockets/autoload'
+require 'sprockets/digest_utils'
+
+module Sprockets
+  # Public: YUI compressor.
+  #
+  # To accept the default options
+  #
+  #     environment.register_bundle_processor 'application/javascript',
+  #       Sprockets::YUICompressor
+  #
+  # Or to pass options to the YUI::JavaScriptCompressor class.
+  #
+  #     environment.register_bundle_processor 'application/javascript',
+  #       Sprockets::YUICompressor.new(munge: true)
+  #
+  class YUICompressor
+    VERSION = '1'
+
+    # Public: Return singleton instance with default options.
+    #
+    # Returns YUICompressor object.
+    def self.instance
+      @instance ||= new
+    end
+
+    def self.call(input)
+      instance.call(input)
+    end
+
+    def self.cache_key
+      instance.cache_key
+    end
+
+    attr_reader :cache_key
+
+    def initialize(options = {})
+      @options = options
+      @cache_key = "#{self.class.name}:#{Autoload::YUI::Compressor::VERSION}:#{VERSION}:#{DigestUtils.digest(options)}".freeze
+    end
+
+    def call(input)
+      data = input[:data]
+
+      case input[:content_type]
+      when 'application/javascript'
+        Autoload::YUI::JavaScriptCompressor.new(@options).compress(data)
+      when 'text/css'
+        Autoload::YUI::CssCompressor.new(@options).compress(data)
+      else
+        data
+      end
+    end
+  end
+end

data/lib/sprockets.rb

@@ -1,64 +1,229 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
 require 'sprockets/version'
+require 'sprockets/cache'
+require 'sprockets/environment'
+require 'sprockets/errors'
+require 'sprockets/manifest'
 
 module Sprockets
-  # Environment
-  autoload :Base,                    "sprockets/base"
-  autoload :Engines,                 "sprockets/engines"
-  autoload :Environment,             "sprockets/environment"
-  autoload :Index,                   "sprockets/index"
-  autoload :Manifest,                "sprockets/manifest"
-
-  # Assets
-  autoload :Asset,                   "sprockets/asset"
-  autoload :BundledAsset,            "sprockets/bundled_asset"
-  autoload :ProcessedAsset,          "sprockets/processed_asset"
-  autoload :StaticAsset,             "sprockets/static_asset"
-
-  # Processing
-  autoload :CharsetNormalizer,       "sprockets/charset_normalizer"
-  autoload :Context,                 "sprockets/context"
-  autoload :DirectiveProcessor,      "sprockets/directive_processor"
-  autoload :EcoTemplate,             "sprockets/eco_template"
-  autoload :EjsTemplate,             "sprockets/ejs_template"
-  autoload :JstProcessor,            "sprockets/jst_processor"
-  autoload :Processor,               "sprockets/processor"
-  autoload :SafetyColons,            "sprockets/safety_colons"
-
-  # Internal utilities
-  autoload :ArgumentError,           "sprockets/errors"
-  autoload :AssetAttributes,         "sprockets/asset_attributes"
-  autoload :CircularDependencyError, "sprockets/errors"
-  autoload :ContentTypeMismatch,     "sprockets/errors"
-  autoload :EngineError,             "sprockets/errors"
-  autoload :Error,                   "sprockets/errors"
-  autoload :FileNotFound,            "sprockets/errors"
-  autoload :Utils,                   "sprockets/utils"
-
-  module Cache
-    autoload :FileStore, "sprockets/cache/file_store"
-  end
+  require 'sprockets/processor_utils'
+  extend ProcessorUtils
 
   # Extend Sprockets module to provide global registry
-  extend Engines
-  @engines = {}
+  require 'sprockets/configuration'
+  require 'sprockets/context'
+  require 'digest/sha2'
+  extend Configuration
+
+  self.config = {
+    bundle_processors: Hash.new { |h, k| [].freeze }.freeze,
+    bundle_reducers: Hash.new { |h, k| {}.freeze }.freeze,
+    compressors: Hash.new { |h, k| {}.freeze }.freeze,
+    dependencies: Set.new.freeze,
+    dependency_resolvers: {}.freeze,
+    digest_class: Digest::SHA256,
+    mime_exts: {}.freeze,
+    mime_types: {}.freeze,
+    paths: [].freeze,
+    pipelines: {}.freeze,
+    pipeline_exts: {}.freeze,
+    postprocessors: Hash.new { |h, k| [].freeze }.freeze,
+    preprocessors: Hash.new { |h, k| [].freeze }.freeze,
+    registered_transformers: [].freeze,
+    root: __dir__.dup.freeze,
+    transformers: Hash.new { |h, k| {}.freeze }.freeze,
+    exporters: Hash.new { |h, k| Set.new.freeze }.freeze,
+    version: "",
+    gzip_enabled: true,
+    export_concurrent: true
+  }.freeze
+
+  @context_class = Context
+
+  require 'logger'
+  @logger = Logger.new($stderr)
+  @logger.level = Logger::FATAL
+
+  # Common asset text types
+  register_mime_type 'application/javascript', extensions: ['.js'], charset: :unicode
+  register_mime_type 'application/json', extensions: ['.json'], charset: :unicode
+  register_mime_type 'application/ruby', extensions: ['.rb']
+  register_mime_type 'application/xml', extensions: ['.xml']
+  register_mime_type 'text/css', extensions: ['.css'], charset: :css
+  register_mime_type 'text/html', extensions: ['.html', '.htm'], charset: :html
+  register_mime_type 'text/plain', extensions: ['.txt', '.text']
+  register_mime_type 'text/yaml', extensions: ['.yml', '.yaml'], charset: :unicode
+
+  # Common image types
+  register_mime_type 'image/x-icon', extensions: ['.ico']
+  register_mime_type 'image/bmp', extensions: ['.bmp']
+  register_mime_type 'image/gif', extensions: ['.gif']
+  register_mime_type 'image/webp', extensions: ['.webp']
+  register_mime_type 'image/png', extensions: ['.png']
+  register_mime_type 'image/jpeg', extensions: ['.jpg', '.jpeg']
+  register_mime_type 'image/tiff', extensions: ['.tiff', '.tif']
+  register_mime_type 'image/svg+xml', extensions: ['.svg']
+
+  # Common audio/video types
+  register_mime_type 'video/webm', extensions: ['.webm']
+  register_mime_type 'audio/basic', extensions: ['.snd', '.au']
+  register_mime_type 'audio/aiff', extensions: ['.aiff']
+  register_mime_type 'audio/mpeg', extensions: ['.mp3', '.mp2', '.m2a', '.m3a']
+  register_mime_type 'application/ogg', extensions: ['.ogx']
+  register_mime_type 'audio/ogg', extensions: ['.ogg', '.oga']
+  register_mime_type 'audio/midi', extensions: ['.midi', '.mid']
+  register_mime_type 'video/avi', extensions: ['.avi']
+  register_mime_type 'audio/wave', extensions: ['.wav', '.wave']
+  register_mime_type 'video/mp4', extensions: ['.mp4', '.m4v']
+  register_mime_type 'audio/aac', extensions: ['.aac']
+  register_mime_type 'audio/mp4', extensions: ['.m4a']
+  register_mime_type 'audio/flac', extensions: ['.flac']
+
+  # Common font types
+  register_mime_type 'application/vnd.ms-fontobject', extensions: ['.eot']
+  register_mime_type 'application/x-font-opentype', extensions: ['.otf']
+  register_mime_type 'application/x-font-ttf', extensions: ['.ttf']
+  register_mime_type 'application/font-woff', extensions: ['.woff']
+  register_mime_type 'application/font-woff2', extensions: ['.woff2']
 
-  # Cherry pick the default Tilt engines that make sense for
-  # Sprockets. We don't need ones that only generate html like HAML.
+  require 'sprockets/source_map_processor'
+  register_mime_type 'application/js-sourcemap+json', extensions: ['.js.map']
+  register_mime_type 'application/css-sourcemap+json', extensions: ['.css.map']
+  register_transformer 'application/javascript', 'application/js-sourcemap+json', SourceMapProcessor
+  register_transformer 'text/css', 'application/css-sourcemap+json', SourceMapProcessor
+
+  register_pipeline :source do |env|
+    []
+  end
+
+  register_pipeline :self do |env, type, file_type|
+    env.self_processors_for(type, file_type)
+  end
+
+  register_pipeline :default do |env, type, file_type|
+    env.default_processors_for(type, file_type)
+  end
+
+  require 'sprockets/add_source_map_comment_to_asset_processor'
+  register_pipeline :debug do
+    [AddSourceMapCommentToAssetProcessor]
+  end
+
+  require 'sprockets/directive_processor'
+  register_preprocessor 'text/css', DirectiveProcessor.new(comments: ["//", ["/*", "*/"]])
+  register_preprocessor 'application/javascript', DirectiveProcessor.new(comments: ["//", ["/*", "*/"]])
+
+  require 'sprockets/bundle'
+  register_bundle_processor 'application/javascript', Bundle
+  register_bundle_processor 'text/css', Bundle
+
+  register_bundle_metadata_reducer '*/*', :data, proc { +"" }, :concat
+  register_bundle_metadata_reducer 'application/javascript', :data, proc { +"" }, Utils.method(:concat_javascript_sources)
+  register_bundle_metadata_reducer '*/*', :links, :+
+  register_bundle_metadata_reducer '*/*', :sources, proc { [] }, :+
+
+  require 'sprockets/closure_compressor'
+  require 'sprockets/sass_compressor'
+  require 'sprockets/sassc_compressor'
+  require 'sprockets/jsminc_compressor'
+  require 'sprockets/uglifier_compressor'
+  require 'sprockets/yui_compressor'
+  register_compressor 'text/css', :sass, SassCompressor
+  register_compressor 'text/css', :sassc, SasscCompressor
+  register_compressor 'text/css', :scss, SassCompressor
+  register_compressor 'text/css', :scssc, SasscCompressor
+  register_compressor 'text/css', :yui, YUICompressor
+  register_compressor 'application/javascript', :closure, ClosureCompressor
+  register_compressor 'application/javascript', :jsmin, JSMincCompressor
+  register_compressor 'application/javascript', :jsminc, JSMincCompressor
+  register_compressor 'application/javascript', :uglifier, UglifierCompressor
+  register_compressor 'application/javascript', :uglify, UglifierCompressor
+  register_compressor 'application/javascript', :yui, YUICompressor
+
+  # Babel, TheFuture™ is now
+  require 'sprockets/babel_processor'
+  register_mime_type 'application/ecmascript-6', extensions: ['.es6'], charset: :unicode
+  register_transformer 'application/ecmascript-6', 'application/javascript', BabelProcessor
+  register_preprocessor 'application/ecmascript-6', DirectiveProcessor.new(comments: ["//", ["/*", "*/"]])
 
   # Mmm, CoffeeScript
-  register_engine '.coffee', Tilt::CoffeeScriptTemplate
+  require 'sprockets/coffee_script_processor'
+  register_mime_type 'text/coffeescript', extensions: ['.coffee', '.js.coffee']
+  register_transformer 'text/coffeescript', 'application/javascript', CoffeeScriptProcessor
+  register_preprocessor 'text/coffeescript', DirectiveProcessor.new(comments: ["#", ["###", "###"]])
+
+  # JST processors
+  require 'sprockets/eco_processor'
+  require 'sprockets/ejs_processor'
+  require 'sprockets/jst_processor'
+  register_mime_type 'text/eco', extensions: ['.eco', '.jst.eco']
+  register_mime_type 'text/ejs', extensions: ['.ejs', '.jst.ejs']
+  register_transformer 'text/eco', 'application/javascript+function', EcoProcessor
+  register_transformer 'text/ejs', 'application/javascript+function', EjsProcessor
+  register_transformer 'application/javascript+function', 'application/javascript', JstProcessor
+
+  # CSS processors
+  require 'sprockets/sassc_processor'
+  register_mime_type 'text/sass', extensions: ['.sass', '.css.sass']
+  register_mime_type 'text/scss', extensions: ['.scss', '.css.scss']
+  register_transformer 'text/sass', 'text/css', SasscProcessor
+  register_transformer 'text/scss', 'text/css', ScsscProcessor
+  register_preprocessor 'text/sass', DirectiveProcessor.new(comments: ["//", ["/*", "*/"]])
+  register_preprocessor 'text/scss', DirectiveProcessor.new(comments: ["//", ["/*", "*/"]])
+  register_bundle_metadata_reducer 'text/css', :sass_dependencies, Set.new, :+
+
+  # ERB
+  require 'sprockets/erb_processor'
+  register_transformer_suffix(%w(
+    application/ecmascript-6
+    application/javascript
+    application/json
+    application/xml
+    text/coffeescript
+    text/css
+    text/html
+    text/plain
+    text/sass
+    text/scss
+    text/yaml
+    text/eco
+  ), 'application/\2+ruby', '.erb', ERBProcessor)
+
+  register_mime_type 'application/html+ruby', extensions: ['.html.erb', '.erb', '.rhtml'], charset: :html
+  register_mime_type 'application/xml+ruby', extensions: ['.xml.erb', '.rxml']
+
+  require 'sprockets/exporters/file_exporter'
+  require 'sprockets/exporters/zlib_exporter'
+  require 'sprockets/exporters/zopfli_exporter'
+  register_exporter '*/*', Exporters::FileExporter
+  register_exporter '*/*', Exporters::ZlibExporter
+
+  register_dependency_resolver 'environment-version' do |env|
+    env.version
+  end
+  register_dependency_resolver 'environment-paths' do |env|
+    env.paths.map {|path| env.compress_from_root(path) }
+  end
+  register_dependency_resolver 'file-digest' do |env, str|
+    env.file_digest(env.parse_file_digest_uri(str))
+  end
+  register_dependency_resolver 'processors' do |env, str|
+    env.resolve_processors_cache_key_uri(str)
+  end
+  register_dependency_resolver 'env' do |env, str|
+    _, var = str.split(':', 2)
+    ENV[var]
+  end
 
-  # JST engines
-  register_engine '.jst',    JstProcessor
-  register_engine '.eco',    EcoTemplate
-  register_engine '.ejs',    EjsTemplate
+  depend_on 'environment-version'
+  depend_on 'environment-paths'
 
-  # CSS engines
-  register_engine '.less',   Tilt::LessTemplate
-  register_engine '.sass',   Tilt::SassTemplate
-  register_engine '.scss',   Tilt::ScssTemplate
+  require 'sprockets/preprocessors/default_source_map'
+  register_preprocessor 'text/css',               Preprocessors::DefaultSourceMap.new
+  register_preprocessor 'application/javascript', Preprocessors::DefaultSourceMap.new
 
-  # Other
-  register_engine '.erb',    Tilt::ERBTemplate
-  register_engine '.str',    Tilt::StringTemplate
+  register_bundle_metadata_reducer 'text/css',               :map, proc { |input| { "version" => 3, "file" => PathUtils.split_subpath(input[:load_path], input[:filename]), "sections" => [] } }, SourceMapUtils.method(:concat_source_maps)
+  register_bundle_metadata_reducer 'application/javascript', :map, proc { |input| { "version" => 3, "file" => PathUtils.split_subpath(input[:load_path], input[:filename]), "sections" => [] } }, SourceMapUtils.method(:concat_source_maps)
 end