haml 3.1.0.alpha.33 → 3.1.0.alpha.36

data/vendor/sass/lib/sass/cache_stores/base.rb

@@ -0,0 +1,84 @@
+module Sass
+  module CacheStores
+    # 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}.
+    #
+    # @abstract
+    class Base
+      # 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 obj [Object] The object to cache.
+      def store(key, sha, root)
+        _store(key, Sass::VERSION, sha, Sass::Util.dump(root))
+      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 [Object] The cached object.
+      def retrieve(key, sha)
+        contents = _retrieve(key, Sass::VERSION, sha)
+        Sass::Util.load(contents) if contents
+      rescue EOFError, TypeError, ArgumentError => e
+        Sass::Util.sass_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
+  end
+end

data/vendor/sass/lib/sass/cache_stores/filesystem.rb

@@ -0,0 +1,56 @@
+module Sass
+  module CacheStores
+    # A backend for the Sass cache using the filesystem.
+    class Filesystem < Base
+      # The directory where the cached files will be stored.
+      #
+      # @return [String]
+      attr_accessor :cache_location
+
+      # @param cache_location [String] see \{#cache\_location}
+      def initialize(cache_location)
+        @cache_location = cache_location
+      end
+
+      # @see Base#\_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
+        Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
+      end
+
+      # @see Base#\_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
+  end
+end

data/vendor/sass/lib/sass/cache_stores/memory.rb

@@ -0,0 +1,51 @@
+module Sass
+  module CacheStores
+    # A backend for the Sass cache using in-process memory.
+    class Memory < Base
+      # Since the {Memory} store 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)
+        Memory.new
+      end
+
+      # Create a new, empty cache store.
+      def initialize
+        @contents = {}
+      end
+
+      # @see Base#_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 Base#_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
+  end
+end

data/vendor/sass/lib/sass/cache_stores/null.rb

@@ -0,0 +1,25 @@
+module Sass
+  module CacheStores
+    # 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 Null < Base
+      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
+end

data/vendor/sass/lib/sass/engine.rb

@@ -1,12 +1,14 @@
 require 'strscan'
+require 'set'
 require 'digest/sha1'
-require 'sass/cache_store'
+require 'sass/cache_stores'
 require 'sass/tree/node'
 require 'sass/tree/root_node'
 require 'sass/tree/rule_node'
 require 'sass/tree/comment_node'
 require 'sass/tree/prop_node'
 require 'sass/tree/directive_node'
+require 'sass/tree/media_node'
 require 'sass/tree/variable_node'
 require 'sass/tree/mixin_def_node'
 require 'sass/tree/mixin_node'
@@ -14,9 +16,11 @@ require 'sass/tree/extend_node'
 require 'sass/tree/if_node'
 require 'sass/tree/while_node'
 require 'sass/tree/for_node'
+require 'sass/tree/each_node'
 require 'sass/tree/debug_node'
 require 'sass/tree/warn_node'
 require 'sass/tree/import_node'
+require 'sass/tree/charset_node'
 require 'sass/selector'
 require 'sass/environment'
 require 'sass/script'
@@ -152,7 +156,7 @@ module Sass
       # Tracks the original filename of the top-level Sass file
       options[:original_filename] = options[:original_filename] || options[:filename]
 
-      options[:cache_store] ||= Sass::FileCacheStore.new(options[:cache_location])
+      options[:cache_store] ||= Sass::CacheStores::Filesystem.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]
@@ -238,13 +242,14 @@ module Sass
     end
     alias_method :to_css, :render
 
-    # Parses the document into its parse tree.
+    # Parses the document into its parse tree. Memoized.
     #
     # @return [Sass::Tree::Node] The root of the parse tree.
     # @raise [Sass::SyntaxError] if there's an error in the document
     def to_tree
-      return _to_tree unless @options[:quiet]
-      Sass::Util.silence_sass_warnings {_to_tree}
+      @tree ||= @options[:quiet] ?
+        Sass::Util.silence_sass_warnings {_to_tree} :
+        _to_tree
     end
 
     # Returns the original encoding of the document,
@@ -259,12 +264,42 @@ module Sass
       @original_encoding
     end
 
+    # Gets a set of all the documents
+    # that are (transitive) dependencies of this document,
+    # not including the document itself.
+    #
+    # @return [[Sass::Engine]] The dependency documents.
+    def dependencies
+      _dependencies(Set.new, engines = Set.new)
+      engines - [self]
+    end
+
+    # Helper for \{#dependencies}.
+    #
+    # @private
+    def _dependencies(seen, engines)
+      return if seen.include?(key = [@options[:filename], @options[:importer]])
+      seen << key
+      engines << self
+      to_tree.grep(Tree::ImportNode) do |n|
+        next if n.css_import?
+        n.imported_file._dependencies(seen, engines)
+      end
+    end
+
     private
 
     def _render
       rendered = _to_tree.render
       return rendered if ruby1_8?
-      return rendered.encode(source_encoding)
+      begin
+        # Try to convert the result to the original encoding,
+        # but if that doesn't work fall back on UTF-8
+        rendered = rendered.encode(source_encoding)
+      rescue EncodingError
+      end
+      rendered.gsub(Regexp.new('\A@charset "(.*?)"'.encode(source_encoding)),
+        "@charset \"#{source_encoding.name}\"".encode(source_encoding))
     end
 
     def _to_tree
@@ -315,7 +350,7 @@ module Sass
       comment_tab_str = nil
       first = true
       lines = []
-      string.gsub(/\r|\n|\r\n|\r\n/, "\n").scan(/^.*?$/).each_with_index do |line, index|
+      string.gsub(/\r|\n|\r\n|\r\n/, "\n").scan(/^[^\n]*?$/).each_with_index do |line, index|
         index += (@options[:line] || 1)
         if line.strip.empty?
           lines.last.text << "\n" if lines.last && lines.last.comment?
@@ -424,23 +459,21 @@ MSG
       children.each do |line|
         child = build_tree(parent, line, root)
 
-        if child.is_a?(Tree::RuleNode) && child.continued?
-          raise SyntaxError.new("Rules can't end in commas.",
-            :line => child.line) unless child.children.empty?
-          if continued_rule
+        if child.is_a?(Tree::RuleNode)
+          if child.continued? && child.children.empty?
+            if continued_rule
+              continued_rule.add_rules child
+            else
+              continued_rule = child
+            end
+            next
+          elsif continued_rule
             continued_rule.add_rules child
-          else
-            continued_rule = child
+            continued_rule.children = child.children
+            continued_rule, child = nil, continued_rule
           end
-          next
-        end
-
-        if continued_rule
-          raise SyntaxError.new("Rules can't end in commas.",
-            :line => continued_rule.line) unless child.is_a?(Tree::RuleNode)
-          continued_rule.add_rules child
-          continued_rule.children = child.children
-          continued_rule, child = nil, continued_rule
+        elsif continued_rule
+          continued_rule = nil
         end
 
         if child.is_a?(Tree::CommentNode) && child.silent
@@ -458,9 +491,6 @@ MSG
         validate_and_append_child(parent, child, line, root)
       end
 
-      raise SyntaxError.new("Rules can't end in commas.",
-        :line => continued_rule.line) if continued_rule
-
       parent
     end
 
@@ -602,6 +632,8 @@ WARNING
         parse_mixin_include(line, root)
       elsif directive == "for"
         parse_for(line, root, value)
+      elsif directive == "each"
+        parse_each(line, root, value)
       elsif directive == "else"
         parse_else(parent, line, value)
       elsif directive == "while"
@@ -628,6 +660,14 @@ WARNING
           :line => @line + 1) unless line.children.empty?
         offset = line.offset + line.text.index(value).to_i
         Tree::WarnNode.new(parse_script(value, :offset => offset))
+      elsif directive == "charset"
+        name = value && value[/\A(["'])(.*)\1\Z/, 2] #"
+        raise SyntaxError.new("Invalid charset directive '@charset': expected string.") unless name
+        raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath charset directives.",
+          :line => @line + 1) unless line.children.empty?
+        Tree::CharsetNode.new(name)
+      elsif directive == "media"
+        Tree::MediaNode.new(value)
       else
         Tree::DirectiveNode.new(line.text)
       end
@@ -657,6 +697,27 @@ WARNING
       Tree::ForNode.new(var, parsed_from, parsed_to, to_name == 'to')
     end
 
+    def parse_each(line, root, text)
+      var, list_expr = text.scan(/^([^\s]+)\s+in\s+(.+)$/).first
+
+      if var.nil? # scan failed, try to figure out why for error message
+        if text !~ /^[^\s]+/
+          expected = "variable name"
+        elsif text !~ /^[^\s]+\s+from\s+.+/
+          expected = "'in <expr>'"
+        end
+        raise SyntaxError.new("Invalid for directive '@each #{text}': expected #{expected}.")
+      end
+      raise SyntaxError.new("Invalid variable \"#{var}\".") unless var =~ Script::VALIDATE
+      if var.slice!(0) == ?!
+        offset = line.offset + line.text.index("!" + var) + 1
+        Script.var_warning(var, @line, offset, @options[:filename])
+      end
+
+      parsed_list = parse_script(list_expr, :offset => line.offset + line.text.index(list_expr))
+      Tree::EachNode.new(var, parsed_list)
+    end
+
     def parse_else(parent, line, text)
       previous = parent.children.last
       raise SyntaxError.new("@else must come after @if.") unless previous.is_a?(Tree::IfNode)

data/vendor/sass/lib/sass/exec.rb

@@ -123,9 +123,18 @@ module Sass
       # @param color [Symbol] The name of the color to use for this action.
       #   Can be `:red`, `:green`, or `:yellow`.
       def puts_action(name, color, arg)
+        return if @options[:for_engine][:quiet]
         printf color(color, "%11s %s\n"), name, arg
       end
 
+      # Same as \{Kernel.puts}, but doesn't print anything if the `--quiet` option is set.
+      #
+      # @param args [Array] Passed on to \{Kernel.puts}
+      def puts(*args)
+        return if @options[:for_engine][:quiet]
+        Kernel.puts(*args)
+      end
+
       # Wraps the given string in terminal escapes
       # causing it to have the given color.
       # If terminal esapes aren't supported on this platform,
@@ -219,7 +228,7 @@ END
                 'Output style. Can be nested (default), compact, compressed, or expanded.') do |name|
           @options[:for_engine][:style] = name.to_sym
         end
-        opts.on('-q', '--quiet', 'Silence warnings during compilation.') do
+        opts.on('-q', '--quiet', 'Silence warnings and status messages during compilation.') do
           @options[:for_engine][:quiet] = true
         end
         opts.on('-g', '--debug-info',