haml-edge 3.1.73 → 3.1.74

data/EDGE_GEM_VERSION

@@ -1 +1 @@
-3.1.73
+3.1.74

data/VERSION

@@ -1 +1 @@
-3.1.73
+3.1.74

data/lib/haml/exec.rb

@@ -281,19 +281,19 @@ END
           output = @options[:output]
 
           @options[:syntax] ||= :scss if input.is_a?(File) && input.path =~ /\.scss$/
-          tree =
+          engine =
             if input.is_a?(File) && !@options[:check_syntax]
-              ::Sass::Files.tree_for(input.path, @options[:for_engine])
+              ::Sass::Files.engine_for(input.path, @options[:for_engine])
             else
               # We don't need to do any special handling of @options[:check_syntax] here,
               # because the Sass syntax checking happens alongside evaluation
               # and evaluation doesn't actually evaluate any code anyway.
-              ::Sass::Engine.new(input.read(), @options[:for_engine]).to_tree
+              ::Sass::Engine.new(input.read(), @options[:for_engine])
             end
 
           input.close() if input.is_a?(File)
 
-          output.write(tree.render)
+          output.write(engine.render)
           output.close() if output.is_a? File
         rescue ::Sass::SyntaxError => e
           raise e if @options[:trace]
@@ -769,10 +769,10 @@ END
               Less::Engine.new(input).to_tree.to_sass_tree.send("to_#{@options[:to]}", @options[:for_tree])
             else
               if input.is_a?(File)
-                ::Sass::Files.tree_for(input.path, @options[:for_engine])
+                ::Sass::Files.engine_for(input.path, @options[:for_engine])
               else
-                ::Sass::Engine.new(input.read, @options[:for_engine]).to_tree
-              end.send("to_#{@options[:to]}", @options[:for_tree])
+                ::Sass::Engine.new(input.read, @options[:for_engine])
+              end.to_tree.send("to_#{@options[:to]}", @options[:for_tree])
             end
           end
 

data/lib/haml/util.rb

@@ -263,6 +263,43 @@ module Haml
       version_gt(v1, v2) || !version_gt(v2, v1)
     end
 
+    # A wrapper for `Marshal.dump` that calls `#_before_dump` on the object
+    # before dumping it, `#_after_dump` afterwards.
+    # It also calls `#_around_dump` and passes it a block in which the object is dumped.
+    #
+    # If any of these methods are undefined, they are not called.
+    #
+    # @param obj [Object] The object to dump.
+    # @return [String] The dumped data.
+    def dump(obj)
+      obj._before_dump if obj.respond_to?(:_before_dump)
+      return Marshal.dump(obj) unless obj.respond_to?(:_around_dump)
+      res = nil
+      obj._around_dump {res = Marshal.dump(obj)}
+      res
+    ensure
+      obj._after_dump if obj.respond_to?(:_after_dump)
+    end
+
+    # A wrapper for `Marshal.load` that calls `#_after_load` on the object
+    # after loading it, if it's defined.
+    #
+    # @param data [String] The data to load.
+    # @return [Object] The loaded object.
+    def load(data)
+      obj = Marshal.load(data)
+      obj._after_load if obj.respond_to?(:_after_load)
+      obj
+    end
+
+    # Throws a NotImplementedError for an abstract method.
+    #
+    # @param obj [Object] `self`
+    # @raise [NotImplementedError]
+    def abstract(obj)
+      raise NotImplementedError.new("#{obj.class} must implement ##{caller_info[2]}")
+    end
+
     # Silence all output to STDERR within a block.
     #
     # @yield A block in which no output will be printed to STDERR

data/lib/sass/cache_store.rb

@@ -0,0 +1,213 @@
+require 'stringio'
+
+module Sass
+  # An abstract base class for backends for the Sass cache.
+  # Any key-value store can act as such a backend;
+  # it just needs to implement the
+  # \{#_store} and \{#_retrieve} methods.
+  #
+  # To use a cache store with Sass,
+  # use the {file:SASS_REFERENCE.md#cache_store-option `:cache_store` option}.
+  class CacheStore
+    # Store cached contents for later retrieval
+    # Must be implemented by all CacheStore subclasses
+    #
+    # Note: cache contents contain binary data.
+    #
+    # @param key [String] The key to store the contents under
+    # @param version [String] The current sass version.
+    #                Cached contents must not be retrieved across different versions of sass.
+    # @param sha [String] The sha of the sass source.
+    #                Cached contents must not be retrieved if the sha has changed.
+    # @param contents [String] The contents to store.
+    def _store(key, version, sha, contents)
+      raise "#{self.class} must implement #_store."
+    end
+
+    # Retrieved cached contents.
+    # Must be implemented by all subclasses.
+    # 
+    # Note: if the key exists but the sha or version have changed,
+    # then the key may be deleted by the cache store, if it wants to do so.
+    #
+    # @param key [String] The key to retrieve
+    # @param version [String] The current sass version.
+    #                Cached contents must not be retrieved across different versions of sass.
+    # @param sha [String] The sha of the sass source.
+    #                Cached contents must not be retrieved if the sha has changed.
+    # @return [String] The contents that were previously stored.
+    # @return [NilClass] when the cache key is not found or the version or sha have changed.
+    def _retrieve(key, version, sha)
+      raise "#{self.class} must implement #_retrieve."
+    end
+
+    # Store a {Sass::Tree::RootNode}.
+    #
+    # @param key [String] The key to store it under.
+    # @param sha [String] The checksum for the contents that are being stored.
+    # @param root [Sass::Tree::RootNode] The root of the tree to be stored.
+    def store(key, sha, root)
+      orig_options = root.options
+      begin
+        _store(key, Sass::VERSION, sha, Haml::Util.dump(root))
+      ensure
+        root.options = orig_options
+      end
+    end
+
+    # Retrieve a {Sass::Tree::RootNode}.
+    #
+    # @param key [String] The key the root element was stored under.
+    # @param sha [String] The checksum of the root element's content.
+    # @return [Sass::Tree::RootNode] The root node.
+    def retrieve(key, sha)
+      contents = _retrieve(key, Sass::VERSION, sha)
+      Haml::Util.load(contents) if contents
+    rescue EOFError, TypeError, ArgumentError => e
+      raise
+      Haml::Util.haml_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
+    end
+
+    # Return the key for the sass file.
+    #
+    # The `(sass_dirname, sass_basename)` pair
+    # should uniquely identify the Sass document,
+    # but otherwise there are no restrictions on their content.
+    #
+    # @param sass_dirname [String]
+    #   The fully-expanded location of the Sass file.
+    #   This corresponds to the directory name on a filesystem.
+    # @param sass_basename [String] The name of the Sass file that is being referenced.
+    #   This corresponds to the basename on a filesystem.
+    def key(sass_dirname, sass_basename)
+      dir = Digest::SHA1.hexdigest(sass_dirname)
+      filename = "#{sass_basename}c"
+      "#{dir}/#{filename}"
+    end
+  end
+
+  # A backend for the Sass cache using the filesystem.
+  class FileCacheStore < CacheStore
+    # The directory where the cached files will be stored.
+    #
+    # @return [String]
+    attr_accessor :cache_location
+
+    # Create a new FileCacheStore.
+    #
+    # @param cache_location [String] see \{#cache\_location}
+    def initialize(cache_location)
+      @cache_location = cache_location
+    end
+
+    # @see {CacheStore#\_retrieve\_}
+    def _retrieve(key, version, sha)
+      return unless File.readable?(path_to(key))
+      contents = nil
+      File.open(path_to(key), "rb") do |f|
+        if f.readline("\n").strip == version && f.readline("\n").strip == sha
+          return f.read
+        end
+      end
+      File.unlink path_to(key)
+      nil
+    rescue EOFError, TypeError, ArgumentError => e
+      Haml::Util.haml_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
+    end
+
+    # @see {CacheStore#\_store\_}
+    def _store(key, version, sha, contents)
+      return unless File.writable?(File.dirname(@cache_location))
+      return if File.exists?(@cache_location) && !File.writable?(@cache_location)
+      compiled_filename = path_to(key)
+      return if File.exists?(File.dirname(compiled_filename)) && !File.writable?(File.dirname(compiled_filename))
+      return if File.exists?(compiled_filename) && !File.writable?(compiled_filename)
+      FileUtils.mkdir_p(File.dirname(compiled_filename))
+      File.open(compiled_filename, "wb") do |f|
+        f.puts(version)
+        f.puts(sha)
+        f.write(contents)
+      end
+    end
+
+    private
+
+    # Returns the path to a file for the given key.
+    #
+    # @param key [String]
+    # @return [String] The path to the cache file.
+    def path_to(key)
+      File.join(cache_location, key)
+    end
+  end
+
+  # A backend for the Sass cache using in-process memory.
+  class InMemoryCacheStore < CacheStore
+    # Since the {InMemoryCacheStore} is stored in the Sass tree's options hash,
+    # when the options get serialized as part of serializing the tree,
+    # you get crazy exponential growth in the size of the cached objects
+    # unless you don't dump the cache.
+    #
+    # @private
+    def _dump(depth)
+      ""
+    end
+
+    # If we deserialize this class, just make a new empty one.
+    #
+    # @private
+    def self._load(repr)
+      InMemoryCacheStore.new
+    end
+
+    # Create a new, empty cache store.
+    def initialize
+      @contents = {}
+    end
+
+    # @see CacheStore#_retrieve
+    def _retrieve(key, version, sha)
+      if @contents.has_key?(key)
+        return unless @contents[key][:version] == version
+        return unless @contents[key][:sha] == sha
+        return @contents[key][:contents]
+      end
+    end
+    
+    # @see CacheStore#_store
+    def _store(key, version, sha, contents)
+      @contents[key] = {
+        :version => version,
+        :sha => sha,
+        :contents => contents
+      }
+    end
+    
+    # Destructively clear the cache.
+    def reset!
+      @contents = {}
+    end
+  end
+
+  # Doesn't store anything, but records what things it should have stored.
+  # This doesn't currently have any use except for testing and debugging.
+  #
+  # @private
+  class NullCacheStore < CacheStore
+    def initialize
+      @keys = {}
+    end
+
+    def _retrieve(key, version, sha)
+      nil
+    end
+    
+    def _store(key, version, sha, contents)
+      @keys[key] = true
+    end
+    
+    def was_set?(key)
+      @keys[key]
+    end
+  end
+end

data/lib/sass/callbacks.rb

@@ -23,8 +23,22 @@ module Sass
   #   m.on_string_munged {|str, res| puts "#{str} was munged into #{res}!"}
   #   m.munge "bar" #=> bar was munged into bbaarr!
   module Callbacks
+    # Automatically includes {InstanceMethods}
+    # when something extends this module.
+    #
+    # @param base [Module]
+    def self.extended(base)
+      base.send(:include, InstanceMethods)
+    end
     protected
 
+    module InstanceMethods
+      # Removes all callbacks registered against this object.
+      def clear_callbacks!
+        @_sass_callbacks = {}
+      end
+    end
+
     # Define a callback with the given name.
     # This will define an `on_#{name}` method
     # that registers a block,

data/lib/sass/engine.rb

@@ -1,5 +1,6 @@
 require 'strscan'
 require 'digest/sha1'
+require 'sass/cache_store'
 require 'sass/tree/node'
 require 'sass/tree/root_node'
 require 'sass/tree/rule_node'
@@ -21,10 +22,11 @@ require 'sass/environment'
 require 'sass/script'
 require 'sass/scss'
 require 'sass/error'
-require 'sass/files'
+require 'sass/importers'
 require 'haml/shared'
 
 module Sass
+
   # A Sass mixin.
   #
   # `name`: `String`
@@ -130,30 +132,94 @@ module Sass
       :cache => true,
       :cache_location => './.sass-cache',
       :syntax => :sass,
+      :filesystem_importer => Sass::Importers::Filesystem
     }.freeze
 
+    # Converts a Sass options hash into a standard form, filling in
+    # default values and resolving aliases.
+    #
+    # @param options [{Symbol => Object}] The options hash;
+    #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+    # @return [{Symbol => Object}] The normalized options hash.
+    # @private
+    def self.normalize_options(options)
+      options = DEFAULT_OPTIONS.merge(options.reject {|k, v| v.nil?})
+
+      # If the `:filename` option is passed in without an importer,
+      # assume it's using the default filesystem importer.
+      options[:importer] ||= options[:filesystem_importer].new(".") if options[:filename]
+
+      options[:cache_store] ||= Sass::FileCacheStore.new(options[:cache_location])
+      # Support both, because the docs said one and the other actually worked
+      # for quite a long time.
+      options[:line_comments] ||= options[:line_numbers]
+
+      options[:load_paths] = options[:load_paths].map do |p|
+        next p unless p.is_a?(String)
+        options[:filesystem_importer].new(p)
+      end
+
+      # Backwards compatibility
+      options[:property_syntax] ||= options[:attribute_syntax]
+      case options[:property_syntax]
+      when :alternate; options[:property_syntax] = :new
+      when :normal; options[:property_syntax] = :old
+      end
+
+      options
+    end
+
+    # Returns the {Sass::Engine} for the given file.
+    # This is preferable to Sass::Engine.new when reading from a file
+    # because it properly sets up the Engine's metadata,
+    # enables parse-tree caching,
+    # and infers the syntax from the filename.
+    #
+    # @param filename [String] The path to the Sass or SCSS file
+    # @param options [{Symbol => Object}] The options hash;
+    #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    # @return [Sass::Engine] The Engine for the given Sass or SCSS file.
+    # @raise [Sass::SyntaxError] if there's an error in the document.
+    def self.for_file(filename, options)
+      had_syntax = options[:syntax]
+
+      if had_syntax
+        # Use what was explicitly specificed
+      elsif filename =~ /\.scss$/
+        options.merge!(:syntax => :scss)
+      elsif filename =~ /\.sass$/
+        options.merge!(:syntax => :sass)
+      end
+
+      Sass::Engine.new(File.read(filename), options.merge(:filename => filename))
+    end
+
+    # The options for the Sass engine.
+    # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    #
+    # @return [{Symbol => Object}]
+    attr_reader :options
+
+    # Creates a new Engine. Note that Engine should only be used directly
+    # when compiling in-memory Sass code.
+    # If you're compiling a single Sass file from the filesystem,
+    # use \{Sass::Engine.for\_file}.
+    # If you're compiling multiple files from the filesystem,
+    # use {Sass::Plugin.
+    #
     # @param template [String] The Sass template.
     #   This template can be encoded using any encoding
     #   that can be converted to Unicode.
     #   If the template contains an `@charset` declaration,
     #   that overrides the Ruby encoding
     #   (see {file:SASS_REFERENCE.md#encodings the encoding documentation})
-    # @param options [{Symbol => Object}] An options hash;
-    #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
+    # @param options [{Symbol => Object}] An options hash.
+    #   See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+    # @see {Sass::Engine.for_file}
+    # @see {Sass::Plugin}
     def initialize(template, options={})
-      @options = DEFAULT_OPTIONS.merge(options.reject {|k, v| v.nil?})
+      @options = self.class.normalize_options(options)
       @template = template
-
-      # Support both, because the docs said one and the other actually worked
-      # for quite a long time.
-      @options[:line_comments] ||= @options[:line_numbers]
-
-      # Backwards compatibility
-      @options[:property_syntax] ||= @options[:attribute_syntax]
-      case @options[:property_syntax]
-      when :alternate; @options[:property_syntax] = :new
-      when :normal; @options[:property_syntax] = :old
-      end
     end
 
     # Render the template to CSS.
@@ -199,6 +265,18 @@ module Sass
     end
 
     def _to_tree
+      if (@options[:cache] || @options[:read_cache]) &&
+          @options[:filename] && @options[:importer]
+        key = sassc_key
+        sha = Digest::SHA1.hexdigest(@template)
+
+        if root = @options[:cache_store].retrieve(key, sha)
+          @options = root.options.merge(@options)
+          root.options = @options
+          return root
+        end
+      end
+
       check_encoding!
 
       if @options[:syntax] == :scss
@@ -209,6 +287,7 @@ module Sass
       end
 
       root.options = @options
+      @options[:cache_store].store(key, sha, root) if @options[:cache] && key && sha
       root
     rescue SyntaxError => e
       e.modify_backtrace(:filename => @options[:filename], :line => @line)
@@ -216,6 +295,10 @@ module Sass
       raise e
     end
 
+    def sassc_key
+      @options[:cache_store].key(*@options[:importer].key(@options[:filename], @options))
+    end
+
     def check_encoding!
       return if @checked_encoding
       @checked_encoding = true

data/lib/sass/error.rb

@@ -125,6 +125,7 @@ module Sass
     # @return [Array<String>]
     def backtrace
       return nil if super.nil?
+      return super if sass_backtrace.all? {|h| h.empty?}
       sass_backtrace.map do |h|
         "#{h[:filename] || "(sass)"}:#{h[:line]}" +
           (h[:mixin] ? ":in `#{h[:mixin]}'" : "")
@@ -178,7 +179,9 @@ END
       private
 
       def header_string(e, options)
-        return "#{e.class}: #{e.message}" unless e.is_a? Sass::SyntaxError
+        unless e.is_a?(Sass::SyntaxError) && e.sass_line && e.sass_template
+          return "#{e.class}: #{e.message}"
+        end
 
         line_offset = options[:line] || 1
         line_num = e.sass_line + 1 - line_offset

data/lib/sass/importers/base.rb

@@ -0,0 +1,138 @@
+module Sass
+  module Importers
+    # The abstract base class for Sass importers.
+    # All importers should inherit from this.
+    #
+    # At the most basic level, an importer is given a string
+    # and must return a {Sass::Engine} containing some Sass code.
+    # This string can be interpreted however the importer wants;
+    # however, subclasses are encouraged to use the URI format
+    # for pathnames.
+    #
+    # Importers that have some notion of "relative imports"
+    # should take a single load path in their constructor,
+    # and interpret paths as relative to that.
+    # They should also implement the \{#find\_relative} method.
+    #
+    # Importers should be serializable via `Marshal.dump`.
+    # In addition to the standard `_dump` and `_load` methods,
+    # importers can define `_before_dump`, `_after_dump`, `_around_dump`,
+    # and `_after_load` methods as per {Haml::Util#dump} and {Haml::Util#load}.
+    #
+    # @abstract
+    class Base
+
+      # Find a Sass file relative to another file.
+      # Importers without a notion of "relative paths"
+      # should just return nil here.
+      #
+      # If the importer does have a notion of "relative paths",
+      # it should ignore its load path during this method.
+      #
+      # See \{#find} for important information on how this method should behave.
+      #
+      # The `:filename` option passed to the returned {Sass::Engine}
+      # should be of a format that could be passed to \{#find}.
+      #
+      # @param uri [String] The URI to import. This is not necessarily relative,
+      #   but this method should only return true if it is.
+      # @param base [String] The base filename. If `uri` is relative,
+      #   it should be interpreted as relative to `base`.
+      #   `base` is guaranteed to be in a format importable by this importer.
+      # @param options [{Symbol => Object}] Options for the Sass file
+      #   containing the `@import` that's currently being resolved.
+      # @return [Sass::Engine, nil] An Engine containing the imported file,
+      #   or nil if it couldn't be found or was in the wrong format.
+      def find_relative(uri, base, options)
+        Haml::Util.abstract(self)
+      end
+
+      # Find a Sass file, if it exists.
+      #
+      # This is the primary entry point of the Importer.
+      # It corresponds directly to an `@import` statement in Sass.
+      # It should do three basic things:
+      #
+      # * Determine if the URI is in this importer's format.
+      #   If not, return nil.
+      # * Determine if the file indicated by the URI actually exists and is readable.
+      #   If not, return nil.
+      # * Read the file and place the contents in a {Sass::Engine}.
+      #   Return that engine.
+      #
+      # If this importer's format allows for file extensions,
+      # it should treat them the same way as the default {Filesystem} importer.
+      # If the URI explicitly has a `.sass` or `.scss` filename,
+      # the importer should look for that exact file
+      # and import it as the syntax indicated.
+      # If it doesn't exist, the importer should return nil.
+      #
+      # If the URI doesn't have either of these extensions,
+      # the importer should look for files with the extensions.
+      # If no such files exist, it should return nil.
+      #
+      # The {Sass::Engine} to be returned should be passed `options`,
+      # with a few modifications. `:filename` and `:syntax` should be set appropriately,
+      # and `:importer` should be set to this importer.
+      #
+      # @param uri [String] The URI to import.
+      # @param options [{Symbol => Object}] Options for the Sass file
+      #   containing the `@import` that's currently being resolved.
+      #   This is safe for subclasses to modify destructively.
+      #   Callers should only pass in a value they don't mind being destructively modified.
+      # @return [Sass::Engine, nil] An Engine containing the imported file,
+      #   or nil if it couldn't be found or was in the wrong format.
+      def find(uri, options)
+        Haml::Util.abstract(self)
+      end
+
+      # Returns the time the given Sass file was last modified.
+      #
+      # If the given file has been deleted or the time can't be accessed
+      # for some other reason, this should return nil.
+      #
+      # @param uri [String] The URI of the file to check.
+      #   Comes from a `:filename` option set on an engine returned by this importer.
+      # @param options [{Symbol => Objet}] Options for the Sass file
+      #   containing the `@import` currently being checked.
+      # @return [Time, nil]
+      def mtime(uri, options)
+        Haml::Util.abstract(self)
+      end
+
+      # Get the cache key pair for the given Sass URI.
+      # The URI need not be checked for validity.
+      #
+      # The only strict requirement is that the returned pair of strings
+      # uniquely identify the file at the given URI.
+      # However, the first component generally corresponds roughly to the directory,
+      # and the second to the basename, of the URI.
+      #
+      # Note that keys must be unique *across importers*.
+      # Thus it's probably a good idea to include the importer name
+      # at the beginning of the first component.
+      #
+      # @param uri [String] A URI known to be valid for this importer.
+      # @param options [{Symbol => Object}] Options for the Sass file
+      #   containing the `@import` currently being checked.
+      # @return [(String, String)] The key pair which uniquely identifies
+      #   the file at the given URI.
+      def key(uri, options)
+        Haml::Util.abstract(self)
+      end
+
+      # A string representation of the importer.
+      # Should be overridden by subclasses.
+      #
+      # This is used to help debugging,
+      # and should usually just show the load path encapsulated by this importer.
+      #
+      # @return [String]
+      def to_s
+        Haml::Util.abstract(self)
+      end
+    end
+  end
+end
+
+