haml 3.1.3 → 3.1.4

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

@@ -49,6 +49,8 @@ module Sass
       # @param obj [Object] The object to cache.
       def store(key, sha, root)
         _store(key, Sass::VERSION, sha, Marshal.dump(root))
+      rescue TypeError, LoadError => e
+        Sass::Util.sass_warn "Warning. Error encountered while saving cache #{path_to(key)}: #{e}"
       end
 
       # Retrieve a {Sass::Tree::RootNode}.
@@ -59,7 +61,7 @@ module Sass
       def retrieve(key, sha)
         contents = _retrieve(key, Sass::VERSION, sha)
         Marshal.load(contents) if contents
-      rescue EOFError, TypeError, ArgumentError => e
+      rescue EOFError, TypeError, ArgumentError, LoadError => e
         Sass::Util.sass_warn "Warning. Error encountered while reading cache #{path_to(key)}: #{e}"
       end
 

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

@@ -1,3 +1,5 @@
+require 'fileutils'
+
 module Sass
   module CacheStores
     # A backend for the Sass cache using the filesystem.

data/vendor/sass/lib/sass/css.rb

@@ -75,7 +75,7 @@ module Sass
     #
     # @return [Tree::Node] The root node of the parsed tree
     def build_tree
-      root = Sass::SCSS::CssParser.new(@template).parse
+      root = Sass::SCSS::CssParser.new(@template, @options[:filename]).parse
       expand_commas      root
       parent_ref_rules   root
       remove_parent_refs root
@@ -106,6 +106,7 @@ module Sass
           next child
         end
         child.rule.first.split(',').map do |rule|
+          next if rule.strip.empty?
           node = Tree::RuleNode.new([rule.strip])
           node.children = child.children
           node

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

@@ -28,6 +28,8 @@ require 'sass/tree/visitors/perform'
 require 'sass/tree/visitors/cssize'
 require 'sass/tree/visitors/convert'
 require 'sass/tree/visitors/to_css'
+require 'sass/tree/visitors/deep_copy'
+require 'sass/tree/visitors/set_options'
 require 'sass/tree/visitors/check_nesting'
 require 'sass/selector'
 require 'sass/environment'
@@ -88,7 +90,10 @@ module Sass
     #
     # `children`: `Array<Line>`
     # : The lines nested below this one.
-    class Line < Struct.new(:text, :tabs, :index, :offset, :filename, :children)
+    #
+    # `comment_tab_str`: `String?`
+    # : The prefix indentation for this comment, if it is a comment.
+    class Line < Struct.new(:text, :tabs, :index, :offset, :filename, :children, :comment_tab_str)
       def comment?
         text[0] == COMMENT_CHAR && (text[1] == SASS_COMMENT_CHAR || text[1] == CSS_COMMENT_CHAR)
       end
@@ -105,6 +110,10 @@ module Sass
     # which is not output as a CSS comment.
     SASS_COMMENT_CHAR = ?/
 
+    # The character that indicates that a comment allows interpolation
+    # and should be preserved even in `:compressed` mode.
+    SASS_LOUD_COMMENT_CHAR = ?!
+
     # The character that follows the general COMMENT_CHAR and designates a CSS comment,
     # which is embedded in the CSS document.
     CSS_COMMENT_CHAR = ?*
@@ -307,7 +316,6 @@ module Sass
         sha = Digest::SHA1.hexdigest(@template)
 
         if root = @options[:cache_store].retrieve(key, sha)
-          @options = root.options.merge(@options)
           root.options = @options
           return root
         end
@@ -316,7 +324,7 @@ module Sass
       check_encoding!
 
       if @options[:syntax] == :scss
-        root = Sass::SCSS::Parser.new(@template).parse
+        root = Sass::SCSS::Parser.new(@template, @options[:filename]).parse
       else
         root = Tree::RootNode.new(@template)
         append_children(root, tree(tabulate(@template)).first, true)
@@ -326,7 +334,7 @@ module Sass
       if @options[:cache] && key && sha
         begin
           old_options = root.options
-          root.options = {:importer => root.options[:importer]}
+          root.options = {}
           @options[:cache_store].store(key, sha, root)
         ensure
           root.options = old_options
@@ -419,7 +427,8 @@ but this line was indented by #{Sass::Shared.human_indentation line[/^\s*/]}.
 MSG
       end
 
-      last.text << "\n" << $1
+      last.comment_tab_str ||= comment_tab_str
+      last.text << "\n" << line
       true
     end
 
@@ -485,8 +494,8 @@ MSG
         if child.is_a?(Tree::CommentNode) && child.silent
           if continued_comment &&
               child.line == continued_comment.line +
-              continued_comment.value.count("\n") + 1
-            continued_comment.value << "\n" << child.value
+              continued_comment.lines + 1
+            continued_comment.value += ["\n"] + child.value
             next
           end
 
@@ -537,7 +546,7 @@ WARNING
       when ?$
         parse_variable(line)
       when COMMENT_CHAR
-        parse_comment(line.text)
+        parse_comment(line)
       when DIRECTIVE_CHAR
         parse_directive(parent, line, root)
       when ESCAPE_CHAR
@@ -558,7 +567,7 @@ WARNING
     def parse_property_or_rule(line)
       scanner = StringScanner.new(line.text)
       hack_char = scanner.scan(/[:\*\.]|\#(?!\{)/)
-      parser = Sass::SCSS::SassParser.new(scanner, @line)
+      parser = Sass::SCSS::SassParser.new(scanner, @options[:filename], @line)
 
       unless res = parser.parse_interp_ident
         return Tree::RuleNode.new(parse_interp(line.text))
@@ -581,15 +590,9 @@ WARNING
       if value.strip.empty?
         expr = Sass::Script::String.new("")
       else
-        important = false
-        if value =~ Sass::SCSS::RX::IMPORTANT
-          important = true
-          value = value.gsub(Sass::SCSS::RX::IMPORTANT,"")
-        end
         expr = parse_script(value, :offset => line.offset + line.text.index(value))
-
       end
-      Tree::PropNode.new(parse_interp(name), expr, important, prop)
+      Tree::PropNode.new(parse_interp(name), expr, prop)
     end
 
     def parse_variable(line)
@@ -605,11 +608,19 @@ WARNING
     end
 
     def parse_comment(line)
-      if line[1] == CSS_COMMENT_CHAR || line[1] == SASS_COMMENT_CHAR
-        silent = line[1] == SASS_COMMENT_CHAR
-        Tree::CommentNode.new(
-          format_comment_text(line[2..-1], silent),
-          silent)
+      if line.text[1] == CSS_COMMENT_CHAR || line.text[1] == SASS_COMMENT_CHAR
+        silent = line.text[1] == SASS_COMMENT_CHAR
+        if loud = line.text[2] == SASS_LOUD_COMMENT_CHAR
+          value = self.class.parse_interp(line.text, line.index, line.offset, :filename => @filename)
+          value[0].slice!(2) # get rid of the "!"
+        else
+          value = [line.text]
+        end
+        value = with_extracted_values(value) do |str|
+          str = str.gsub(/^#{line.comment_tab_str}/m, '')[2..-1] # get rid of // or /*
+          format_comment_text(str, silent)
+        end
+        Tree::CommentNode.new(value, silent, loud)
       else
         Tree::RuleNode.new(parse_interp(line))
       end
@@ -750,6 +761,11 @@ WARNING
         break unless scanner.scan(/,\s*/)
       end
 
+      if scanner.scan(/;/)
+        raise SyntaxError.new("Invalid @import: expected end of line, was \";\".",
+          :line => @line)
+      end
+
       return values
     end
 
@@ -757,12 +773,12 @@ WARNING
       return if scanner.eos?
       unless (str = scanner.scan(Sass::SCSS::RX::STRING)) ||
           (uri = scanner.scan(Sass::SCSS::RX::URI))
-        return Tree::ImportNode.new(scanner.scan(/[^,]+/))
+        return Tree::ImportNode.new(scanner.scan(/[^,;]+/))
       end
 
       val = scanner[1] || scanner[2]
       scanner.scan(/\s*/)
-      if media = scanner.scan(/[^,].*/)
+      if media = scanner.scan(/[^,;].*/)
         Tree::DirectiveNode.new("@import #{str || uri} #{media}")
       elsif uri
         Tree::DirectiveNode.new("@import #{uri}")

data/vendor/sass/lib/sass/environment.rb

@@ -93,6 +93,17 @@ module Sass
       @mixins_in_use ||= @parent.mixins_in_use
     end
 
+    def stack_trace
+      trace = []
+      stack.reverse.each_with_index do |entry, i|
+        msg = "#{i == 0 ? "on" : "from"} line #{entry[:line]}"
+        msg << " of #{entry[:filename] || "an unknown file"}"
+        msg << ", in `#{entry[:mixin]}'" if entry[:mixin]
+        trace << msg
+      end
+      trace
+    end
+
     private
 
     def parent_options

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

@@ -229,6 +229,10 @@ END
                                    'Only meaningful for --watch and --update.') do
           @options[:stop_on_error] = true
         end
+        opts.on('-f', '--force', 'Recompile all Sass files, even if the CSS file is newer.',
+                                 'Only meaningful for --update.') do
+          @options[:force] = true
+        end
         opts.on('-c', '--check', "Just check syntax, don't evaluate.") do
           require 'stringio'
           @options[:check_syntax] = true
@@ -238,6 +242,10 @@ END
                 'Output style. Can be nested (default), compact, compressed, or expanded.') do |name|
           @options[:for_engine][:style] = name.to_sym
         end
+        opts.on('--precision NUMBER_OF_DIGITS', Integer,
+                'How many digits of precision to use when outputting decimal numbers. Defaults to 3.') do |precision|
+          ::Sass::Script::Number.precision = precision
+        end
         opts.on('-q', '--quiet', 'Silence warnings and status messages during compilation.') do
           @options[:for_engine][:quiet] = true
         end
@@ -350,6 +358,11 @@ END
         ::Sass::Plugin.options.merge! @options[:for_engine]
         ::Sass::Plugin.options[:unix_newlines] = @options[:unix_newlines]
 
+        if @options[:force]
+          raise "The --force flag may only be used with --update." unless @options[:update]
+          ::Sass::Plugin.options[:always_update] = true
+        end
+
         raise <<MSG if @args.empty?
 What files should I watch? Did you mean something like:
     #{@default_syntax} --watch input.#{@default_syntax}:output.css
@@ -372,7 +385,7 @@ MSG
 
         dirs, files = @args.map {|name| split_colon_path(name)}.
           partition {|i, _| File.directory? i}
-        files.map! {|from, to| [from, to || from.gsub(/\..*?$/, '.css')]}
+        files.map! {|from, to| [from, to || from.gsub(/\.[^.]*?$/, '.css')]}
         dirs.map! {|from, to| [from, to || from]}
         ::Sass::Plugin.options[:template_location] = dirs
 

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

@@ -72,7 +72,8 @@ module Sass
       # 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,
+      # with a few modifications. `:syntax` should be set appropriately,
+      # `:filename` should be set to `uri`,
       # and `:importer` should be set to this importer.
       #
       # @param uri [String] The URI to import.

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

@@ -13,7 +13,7 @@ module Sass
       # @param root [String] The root path.
       #   This importer will import files relative to this path.
       def initialize(root)
-        @root = root
+        @root = File.expand_path(root)
       end
 
       # @see Base#find_relative
@@ -45,14 +45,21 @@ module Sass
         @root
       end
 
+      def hash
+        @root.hash
+      end
+
+      def eql?(other)
+        root.eql?(other.root)
+      end
+
       protected
 
       # If a full uri is passed, this removes the root from it
       # otherwise returns the name unchanged
       def remove_root(name)
-        root = @root.end_with?('/') ? @root : @root + '/'
-        if name.index(root) == 0
-          name[root.length..-1]
+        if name.index(@root + "/") == 0
+          name[(@root.length + 1)..-1]
         else
           name
         end
@@ -77,6 +84,7 @@ module Sass
       #   The first element of each pair is a filename to look for;
       #   the second element is the syntax that file would be in (`:sass` or `:scss`).
       def possible_files(name)
+        name = escape_glob_characters(name)
         dirname, basename, extname = split(name)
         sorted_exts = extensions.sort
         syntax = extensions[extname]
@@ -85,6 +93,11 @@ module Sass
         sorted_exts.map {|ext, syn| ["#{dirname}/{_,}#{basename}.#{ext}", syn]}
       end
 
+      def escape_glob_characters(name)
+        name.gsub(/[\*\[\]\{\}\?]/) do |char|
+          "\\#{char}"
+        end
+      end
 
       REDUNDANT_DIRECTORY = %r{#{Regexp.escape(File::SEPARATOR)}\.#{Regexp.escape(File::SEPARATOR)}}
       # Given a base directory and an `@import`ed name,
@@ -95,7 +108,7 @@ module Sass
       # @return [(String, Symbol)] A filename-syntax pair.
       def find_real_file(dir, name)
         for (f,s) in possible_files(remove_root(name))
-          path = (dir == ".") ? f : "#{dir}/#{f}"
+          path = (dir == "." || Pathname.new(f).absolute?) ? f : "#{dir}/#{f}"
           if full_path = Dir[path].first
             full_path.gsub!(REDUNDANT_DIRECTORY,File::SEPARATOR)
             return full_path, s
@@ -116,14 +129,6 @@ module Sass
         [dirname, basename, extension]
       end
 
-      def hash
-        @root.hash
-      end
-
-      def eql?(other)
-        root.eql?(other.root)
-      end
-
       private
 
       def _find(dir, name, options)

data/vendor/sass/lib/sass/less.rb

@@ -31,7 +31,7 @@ module Less
 WARNING: Sass doesn't support mixing in selector sequences.
 Replacing "#{sel}" with "@extend #{base}"
 WARNING
-              env << Node::SassNode.new(Sass::Tree::CommentNode.new("// #{sel};", true))
+              env << Node::SassNode.new(Sass::Tree::CommentNode.new(["// #{sel};"], true, false))
               env << Node::SassNode.new(Sass::Tree::ExtendNode.new([base]))
             end
           end
@@ -225,7 +225,7 @@ WARNING
     class Property
       def to_sass_tree
         return if hide_in_sass
-        Sass::Tree::PropNode.new([self], @value.to_sass_tree, false, :new)
+        Sass::Tree::PropNode.new([self], @value.to_sass_tree, :new)
       end
     end
 

data/vendor/sass/lib/sass/logger.rb

@@ -0,0 +1,15 @@
+module Sass::Logger
+
+end
+
+require "sass/logger/log_level"
+require "sass/logger/base"
+
+module Sass
+
+  class << self
+    attr_accessor :logger
+  end
+
+  self.logger = Sass::Logger::Base.new
+end

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

@@ -0,0 +1,32 @@
+require 'sass/logger/log_level'
+
+class Sass::Logger::Base
+  
+  include Sass::Logger::LogLevel
+
+  attr_accessor :log_level
+  attr_accessor :disabled
+
+  log_level :trace
+  log_level :debug
+  log_level :info
+  log_level :warn
+  log_level :error
+
+  def initialize(log_level = :debug)
+    self.log_level = log_level
+  end
+
+  def logging_level?(level)
+    !disabled && self.class.log_level?(level, log_level)
+  end
+
+  def log(level, message)
+    self._log(level, message) if logging_level?(level)
+  end
+
+  def _log(level, message)
+    Kernel::warn(message)
+  end
+
+end

data/vendor/sass/lib/sass/logger/log_level.rb

@@ -0,0 +1,49 @@
+module Sass
+  module Logger
+    module LogLevel
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      
+      module ClassMethods
+        def inherited(subclass)
+          subclass.log_levels = subclass.superclass.log_levels.dup
+        end
+
+        def log_levels
+          @log_levels ||= {}
+        end
+
+        def log_levels=(levels)
+          @log_levels = levels
+        end
+
+        def log_level?(level, min_level)
+          log_levels[level] >= log_levels[min_level]
+        end
+
+        def log_level(name, options = {})
+          if options[:prepend]
+            level = log_levels.values.min
+            level = level.nil? ? 0 : level - 1
+          else
+            level = log_levels.values.max
+            level = level.nil? ? 0 : level + 1
+          end
+          log_levels.update(name => level)
+          define_logger(name)
+        end
+
+        def define_logger(name, options = {})
+          class_eval %Q{
+            def #{name}(message)
+              #{options.fetch(:to, :log)}(#{name.inspect}, message)
+            end
+          }
+        end
+      end
+      
+    end
+  end
+end