sprockets 2.3.2 → 3.0.0

data/lib/sprockets/utils.rb

@@ -1,55 +1,108 @@
+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
+    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
+
+    # 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   - Object keys. 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, *keys, &block)
+      if keys.size == 1
+        hash_reassoc1(hash, keys[0], &block)
+      else
+        hash_reassoc1(hash, keys[0]) do |value|
+          hash_reassoc(value, *keys[1..-1], &block)
         end
       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: Check if string has a trailing semicolon.
+    #
+    # str - String
+    #
+    # Returns true or false.
+    def string_end_with_semicolon?(str)
+      i = str.size - 1
+      while i >= 0
+        c = str[i]
+        i -= 1
+        if c == "\n" || c == " " || c == "\t"
+          next
+        elsif c != ";"
+          return false
+        else
+          return true
         end
       end
+      true
     end
 
-    # Prepends a leading "." to an extension if its missing.
+    # Internal: Accumulate asset source to buffer and append a trailing
+    # semicolon if necessary.
+    #
+    # buf   - String memo
+    # asset - Asset
+    #
+    # Returns appended buffer String.
+    def concat_javascript_sources(buf, source)
+      if string_end_with_semicolon?(buf)
+        buf + source
+      else
+        buf + ";\n" + source
+      end
+    end
+
+    # Internal: Prepends a leading "." to an extension if its missing.
     #
     #     normalize_extension("js")
     #     # => ".js"
@@ -57,7 +110,7 @@ module Sprockets
     #     normalize_extension(".css")
     #     # => ".css"
     #
-    def self.normalize_extension(extension)
+    def normalize_extension(extension)
       extension = extension.to_s
       if extension[/^\./]
         extension
@@ -65,5 +118,101 @@ module Sprockets
         ".#{extension}"
       end
     end
+
+    # Internal: Feature detect if UnboundMethods can #bind to any Object or
+    # just Objects that share the same super class.
+    # Basically if RUBY_VERSION >= 2.
+    UNBOUND_METHODS_BIND_TO_ANY_OBJECT = begin
+      foo = Module.new { def bar; end }
+      foo.instance_method(:bar).bind(Object.new)
+      true
+    rescue TypeError
+      false
+    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
+
+      unless UNBOUND_METHODS_BIND_TO_ANY_OBJECT
+        base.send(:include, mod) unless base < mod
+      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, seen = [path], Set.new
+
+      while path = stack.pop
+        if !seen.include?(path.last)
+          seen.add(path.last)
+          paths << path if path.size > 1
+
+          Array(yield path.last).reverse_each do |node|
+            stack.push(path + [node])
+          end
+        end
+      end
+
+      paths
+    end
   end
 end

data/lib/sprockets/version.rb

@@ -1,3 +1,3 @@
 module Sprockets
-  VERSION = "2.3.2"
+  VERSION = "3.0.0"
 end

data/lib/sprockets/yui_compressor.rb

@@ -0,0 +1,65 @@
+require 'sprockets/autoload'
+
+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,
+        options
+      ].freeze
+    end
+
+    def call(input)
+      data = input[:data]
+
+      case input[:content_type]
+      when 'application/javascript'
+        key = @cache_key + [input[:content_type], input[:data]]
+        input[:cache].fetch(key) do
+          Autoload::YUI::JavaScriptCompressor.new(@options).compress(data)
+        end
+      when 'text/css'
+        key = @cache_key + [input[:content_type], input[:data]]
+        input[:cache].fetch(key) do
+          Autoload::YUI::CssCompressor.new(@options).compress(data)
+        end
+      else
+        data
+      end
+    end
+  end
+end

data/lib/sprockets.rb

@@ -1,68 +1,159 @@
 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"
-  autoload :SassCacheStore,          "sprockets/sass_cache_store"
-  autoload :SassImporter,            "sprockets/sass_importer"
-  autoload :SassTemplate,            "sprockets/sass_template"
-  autoload :ScssTemplate,            "sprockets/scss_template"
-
-  # 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,
+    engine_mime_types: {}.freeze,
+    engines: {}.freeze,
+    mime_exts: {}.freeze,
+    mime_types: {}.freeze,
+    paths: [].freeze,
+    pipelines: {}.freeze,
+    postprocessors: Hash.new { |h, k| [].freeze }.freeze,
+    preprocessors: Hash.new { |h, k| [].freeze }.freeze,
+    registered_transformers: Hash.new { |h, k| {}.freeze }.freeze,
+    root: File.expand_path('..', __FILE__).freeze,
+    transformers: Hash.new { |h, k| {}.freeze }.freeze,
+    version: ""
+  }.freeze
+  self.computed_config = {}
+
+  @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/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/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']
+
+  # Common font types
+  register_mime_type 'application/vnd.ms-fontobject', extensions: ['.eot']
+  register_mime_type 'application/x-font-ttf', extensions: ['.ttf']
+  register_mime_type 'application/font-woff', extensions: ['.woff']
+
+  register_pipeline :source do |env|
+    []
+  end
+
+  register_pipeline :self do |env, type, file_type, engine_extnames|
+    env.self_processors_for(type, file_type, engine_extnames)
+  end
 
-  # Cherry pick the default Tilt engines that make sense for
-  # Sprockets. We don't need ones that only generate html like HAML.
+  register_pipeline :default do |env, type, file_type, engine_extnames|
+    env.default_processors_for(type, file_type, engine_extnames)
+  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, :+
+  register_bundle_metadata_reducer 'application/javascript', :data, Utils.method(:concat_javascript_sources)
+  register_bundle_metadata_reducer '*/*', :links, :+
+
+  require 'sprockets/closure_compressor'
+  require 'sprockets/sass_compressor'
+  require 'sprockets/uglifier_compressor'
+  require 'sprockets/yui_compressor'
+  register_compressor 'text/css', :sass, SassCompressor
+  register_compressor 'text/css', :scss, SassCompressor
+  register_compressor 'text/css', :yui, YUICompressor
+  register_compressor 'application/javascript', :closure, ClosureCompressor
+  register_compressor 'application/javascript', :uglifier, UglifierCompressor
+  register_compressor 'application/javascript', :uglify, UglifierCompressor
+  register_compressor 'application/javascript', :yui, YUICompressor
 
   # Mmm, CoffeeScript
-  register_engine '.coffee', Tilt::CoffeeScriptTemplate
+  require 'sprockets/coffee_script_processor'
+  register_engine '.coffee', CoffeeScriptProcessor, mime_type: 'application/javascript'
 
   # JST engines
-  register_engine '.jst',    JstProcessor
-  register_engine '.eco',    EcoTemplate
-  register_engine '.ejs',    EjsTemplate
+  require 'sprockets/eco_processor'
+  require 'sprockets/ejs_processor'
+  require 'sprockets/jst_processor'
+  register_engine '.jst', JstProcessor, mime_type: 'application/javascript'
+  register_engine '.eco', EcoProcessor, mime_type: 'application/javascript'
+  register_engine '.ejs', EjsProcessor, mime_type: 'application/javascript'
 
   # CSS engines
-  register_engine '.less',   Tilt::LessTemplate
-  register_engine '.sass',   SassTemplate
-  register_engine '.scss',   ScssTemplate
+  require 'sprockets/sass_processor'
+  register_engine '.sass', SassProcessor, mime_type: 'text/css'
+  register_engine '.scss', ScssProcessor, mime_type: 'text/css'
+  register_bundle_metadata_reducer 'text/css', :sass_dependencies, Set.new, :+
 
   # Other
-  register_engine '.erb',    Tilt::ERBTemplate
-  register_engine '.str',    Tilt::StringTemplate
+  require 'sprockets/erb_processor'
+  register_engine '.erb', ERBProcessor, mime_type: 'text/plain'
+
+  register_dependency_resolver 'environment-version' do |env|
+    env.version
+  end
+  register_dependency_resolver 'environment-paths' do |env|
+    env.paths
+  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
+
+  depend_on 'environment-version'
+  depend_on 'environment-paths'
 end
+
+require 'sprockets/legacy'