haml 1.7.2 → 1.8.0

data/lib/sass/constant.rb.rej

@@ -0,0 +1,42 @@
+***************
+*** 106,121 ****
+                end
+  
+                # Time for a unary minus!
+-               if negative_okay && symbol == :minus
+-                 negative_okay = true
+                  to_return << :neg
+                  next
+                end
+  
+                # Are we looking at an operator?
+                if symbol && (str.empty? || symbol != :mod)
+                  str = reset_str.call
+-                 negative_okay = true
+                  to_return << symbol
+                  next
+                end
+--- 107,129 ----
+                end
+  
+                # Time for a unary minus!
++               if beginning_of_token && symbol == :minus
++                 beginning_of_token = true
+                  to_return << :neg
+                  next
+                end
+  
++               # Is this a constant?
++               if beginning_of_token && symbol == :const
++                 beginning_of_token = true
++                 to_return << :const
++                 next
++               end
++ 
+                # Are we looking at an operator?
+                if symbol && (str.empty? || symbol != :mod)
+                  str = reset_str.call
++                 beginning_of_token = true
+                  to_return << symbol
+                  next
+                end

data/lib/sass/constant/string.rb

@@ -10,6 +10,10 @@ module Sass::Constant # :nodoc:
     def plus(other)
       Sass::Constant::String.from_value(self.to_s + other.to_s)
     end
+
+    def funcall(other)
+      Sass::Constant::String.from_value("#{self.to_s}(#{other.to_s})")
+    end
     
     def to_s
       @value

data/lib/sass/css.rb

@@ -41,20 +41,52 @@ module Sass
       end
     end
   end
+
+  # This class is based on the Ruby 1.9 ordered hashes.
+  # It keeps the semantics and most of the efficiency of normal hashes
+  # while also keeping track of the order in which elements were set.
+  class OrderedHash
+    Node = Struct.new('Node', :key, :value, :next)
+    include Enumerable
+
+    def initialize
+      @hash = {}
+    end
+
+    def [](key)
+      @hash[key] && @hash[key].value
+    end
+
+    def []=(key, value)
+      node = Node.new(key, value, nil)
+      if @first.nil?
+        @first = @last = node
+      else
+        @last.next = node
+        @last = node
+      end
+      @hash[key] = node
+      value
+    end
+
+    def each
+      return unless @first
+      yield [@first.key, @first.value]
+      node = @first
+      yield [node.key, node.value] while node = node.next
+      self
+    end
+
+    def values
+      self.map { |k, v| v }
+    end
+  end
+
   # :startdoc:
 
   # This class contains the functionality used in the +css2sass+ utility,
   # namely converting CSS documents to Sass templates.
   class CSS
-    # :stopdoc:
-
-    # The Regexp matching a CSS rule
-    RULE_RE = /\s*([^\{]+)\s*\{/
-
-    # The Regexp matching a CSS attribute
-    ATTR_RE = /\s*[^::\{\}]+\s*:\s*[^:;\{\}]+\s*;/
-
-    # :startdoc:
 
     # Creates a new instance of Sass::CSS that will compile the given document
     # to a Sass string when +render+ is called.
@@ -84,9 +116,12 @@ module Sass
     def build_tree
       root = Tree::Node.new(nil)
       whitespace
-      directives(root)
-      rules(root)
-      sort_rules(root)
+      directives    root
+      rules         root
+      expand_commas root
+      nest_rules    root
+      flatten_rules root
+      fold_commas   root
       root
     end
 
@@ -131,11 +166,11 @@ module Sass
         assert_match /:/
         
         value = ''
-        while @template.scan(/[^;\s]+/)
+        while @template.scan(/[^;\s\}]+/)
           value << @template[0] << whitespace
         end
         
-        assert_match /;/        
+        assert_match /(;|(?=\}))/
         rule << Tree::AttrNode.new(name, value, nil)
       end
 
@@ -161,37 +196,125 @@ module Sass
       whitespace
     end
 
-    def sort_rules(root)
-      root.children.sort! do |c1, c2|
-        if c1.is_a?(Tree::RuleNode) && c2.is_a?(Tree::RuleNode)
-          c1.rule <=> c2.rule
-        elsif !(c1.is_a?(Tree::RuleNode) || c2.is_a?(Tree::RuleNode)) || c2.is_a?(Tree::RuleNode)
-          -1
+    # Transform
+    #
+    #   foo, bar, baz
+    #     color: blue
+    #
+    # into
+    #
+    #   foo
+    #     color: blue
+    #   bar
+    #     color: blue
+    #   baz
+    #     color: blue
+    #
+    # Yes, this expands the amount of code,
+    # but it's necessary to get nesting to work properly.
+    def expand_commas(root)
+      root.children.map! do |child|
+        next child unless Tree::RuleNode === child && child.rule.include?(',')
+        child.rule.split(',').map do |rule|
+          node = Tree::RuleNode.new(rule, nil)
+          node.children = child.children
+          node
+        end
+      end
+      root.children.flatten!
+    end
+
+    # Nest rules so that
+    #
+    #   foo
+    #     color: green
+    #   foo bar
+    #     color: red
+    #   foo baz
+    #     color: blue
+    #
+    # becomes
+    #
+    #   foo
+    #     color: green
+    #     bar
+    #       color: red
+    #     baz
+    #       color: blue
+    # 
+    def nest_rules(root)
+      rules = OrderedHash.new
+      root.children.select { |c| Tree::RuleNode === c }.each do |child|
+        root.children.delete child
+        first, rest = child.rule.split(' ', 2)
+        rules[first] ||= Tree::RuleNode.new(first, nil)
+        if rest
+          child.rule = rest
+          rules[first] << child
         else
-          1
+          rules[first].children += child.children
         end
       end
 
-      prev_rules = []
-      prev_rule_values = []
-      root.children.each do |child|
-        if child.is_a? Tree::RuleNode
-          joined_prev_values = prev_rule_values.join(' ')
-          until prev_rules.empty? || child.rule =~ /^#{Regexp.escape(joined_prev_values)}/
-            prev_rules.pop
-            prev_rule_values.pop
-          end
-          
-          unless prev_rules.empty?
-            child.rule.slice!(0..(joined_prev_values.size))
-            prev_rules[-1] << child
-            root.children.delete child
-          end
-          
-          prev_rules << child
-          prev_rule_values << child.rule
+      rules.values.each { |v| nest_rules(v) }
+      root.children += rules.values
+    end
+
+    # Flatten rules so that
+    #
+    #   foo
+    #     bar
+    #       baz
+    #         color: red
+    #
+    # becomes
+    #
+    #   foo bar baz
+    #     color: red
+    # 
+    def flatten_rules(root)
+      root.children.each { |child| flatten_rule(child) if child.is_a?(Tree::RuleNode) }
+    end
+
+    def flatten_rule(rule)
+      while rule.children.size == 1 && rule.children.first.is_a?(Tree::RuleNode)
+        child = rule.children.first
+        rule.rule = "#{rule.rule} #{child.rule}"
+        rule.children = child.children
+      end
+
+      flatten_rules(rule)
+    end
+
+    # Transform
+    #
+    #   foo
+    #     bar
+    #       color: blue
+    #     baz
+    #       color: blue
+    #
+    # into
+    #
+    #   foo
+    #     bar, baz
+    #       color: blue
+    #
+    def fold_commas(root)
+      prev_rule = nil
+      root.children.map! do |child|
+        next child unless Tree::RuleNode === child
+
+        if prev_rule && prev_rule.children == child.children
+          prev_rule.rule << ", #{child.rule}"
+          next nil
         end
+
+        fold_commas(child)
+        prev_rule = child
+        child
       end
+      root.children.compact!
     end
   end
 end

data/lib/sass/engine.rb

@@ -3,6 +3,7 @@ require 'sass/tree/value_node'
 require 'sass/tree/rule_node'
 require 'sass/tree/comment_node'
 require 'sass/tree/attr_node'
+require 'sass/tree/directive_node'
 require 'sass/constant'
 require 'sass/error'
 require 'haml/util'
@@ -38,6 +39,9 @@ module Sass
 
     # The character used to denote a compiler directive.
     DIRECTIVE_CHAR = ?@
+    
+    # Designates a non-parsed rule.
+    ESCAPE_CHAR    = ?\\
 
     # The regex that matches and extracts data from
     # attributes of the form <tt>:name attr</tt>.
@@ -69,7 +73,7 @@ module Sass
       }.merge! options
       @template = template.split(/\n\r|\n/)
       @lines = []
-      @constants = {}
+      @constants = {"important" => "!important"}
     end
 
     # Processes the template and returns the result as a string.
@@ -232,6 +236,8 @@ module Sass
         parse_comment(line)
       when DIRECTIVE_CHAR
         parse_directive(line)
+      when ESCAPE_CHAR
+        Tree::RuleNode.new(line[1..-1], @options[:style])
       else
         if line =~ ATTRIBUTE_ALTERNATE_MATCHER
           parse_attribute(line, ATTRIBUTE_ALTERNATE)
@@ -242,6 +248,14 @@ module Sass
     end
 
     def parse_attribute(line, attribute_regx)
+      if @options[:attribute_syntax] == :normal &&
+          attribute_regx == ATTRIBUTE_ALTERNATE
+        raise SyntaxError.new("Illegal attribute syntax: can't use alternate syntax when :attribute_syntax => :normal is set.")
+      elsif @options[:attribute_syntax] == :alternate &&
+          attribute_regx == ATTRIBUTE
+        raise SyntaxError.new("Illegal attribute syntax: can't use normal syntax when :attribute_syntax => :alternate is set.")
+      end
+
       name, eq, value = line.scan(attribute_regx)[0]
 
       if name.nil? || value.nil?
@@ -281,7 +295,7 @@ module Sass
       when "import"
         import(value)
       else
-        raise SyntaxError.new("Unknown compiler directive: #{"@#{directive} #{value}".dump}", @line)
+        Tree::DirectiveNode.new(line, @options[:style])
       end
     end
 
@@ -290,7 +304,13 @@ module Sass
 
       files.split(/,\s*/).each do |filename|
         engine = nil
-        filename = find_file_to_import(filename)
+
+        begin
+          filename = self.class.find_file_to_import(filename, @options[:load_paths])
+        rescue Exception => e
+          raise SyntaxError.new(e.message, @line)
+        end
+
         if filename =~ /\.css$/
           nodes << Tree::ValueNode.new("@import url(#{filename});", @options[:style])
         else
@@ -319,10 +339,9 @@ module Sass
       nodes
     end
 
-    def find_file_to_import(filename)
+    def self.find_file_to_import(filename, load_paths)
       was_sass = false
       original_filename = filename
-      new_filename = nil
 
       if filename[-5..-1] == ".sass"
         filename = filename[0...-5]
@@ -331,18 +350,11 @@ module Sass
         return filename
       end
 
-      @options[:load_paths].each do |path|
-        full_path = File.join(path, filename) + '.sass'
-
-        if File.readable?(full_path)
-          new_filename = full_path
-          break
-        end
-      end
+      new_filename = find_full_path("#{filename}.sass", load_paths)
 
       if new_filename.nil?
         if was_sass
-          raise SyntaxError.new("File to import not found or unreadable: #{original_filename}", @line)
+          raise Exception.new("File to import not found or unreadable: #{original_filename}")
         else
           return filename + '.css'
         end
@@ -350,5 +362,17 @@ module Sass
         new_filename
       end
     end
+
+    def self.find_full_path(filename, load_paths)
+      load_paths.each do |path|
+        ["_#{filename}", filename].each do |name|
+          full_path = File.join(path, name)
+          if File.readable?(full_path)
+            return full_path
+          end
+        end
+      end
+      nil
+    end
   end
 end

data/lib/sass/plugin.rb

@@ -26,62 +26,40 @@ module Sass
       def options=(value)
         @@options.merge!(value)
       end
-      
+
       # Checks each stylesheet in <tt>options[:css_location]</tt>
       # to see if it needs updating,
       # and updates it using the corresponding template
       # from <tt>options[:templates]</tt>
       # if it does.
       def update_stylesheets
+        return if options[:never_update]
+
         Dir.glob(File.join(options[:template_location], "**", "*.sass")).entries.each do |file|
-          
+
           # Get the relative path to the file with no extension
           name = file.sub(options[:template_location] + "/", "")[0...-5]
-                    
-          if options[:always_update] || stylesheet_needs_update?(name)
+
+          if !forbid_update?(name) && (options[:always_update] || stylesheet_needs_update?(name))
             css = css_filename(name)
             File.delete(css) if File.exists?(css)
-            
+
             filename = template_filename(name)
             l_options = @@options.dup
             l_options[:filename] = filename
-            l_options[:load_paths] = (l_options[:load_paths] || []) + [l_options[:template_location]]
+            l_options[:load_paths] = load_paths
             engine = Engine.new(File.read(filename), l_options)
-            begin
-              result = engine.render
-            rescue Exception => e
-              if options[:full_exception]
-                e_string = "#{e.class}: #{e.message}"
-
-                if e.is_a? Sass::SyntaxError
-                  e_string << "\non line #{e.sass_line}"
-
-                  if e.sass_filename
-                    e_string << " of #{e.sass_filename}"
-
-                    if File.exists?(e.sass_filename)
-                      e_string << "\n\n"
-
-                      min = [e.sass_line - 5, 0].max
-                      File.read(e.sass_filename).rstrip.split("\n")[
-                          min .. e.sass_line + 5
-                      ].each_with_index do |line, i|
-                        e_string << "#{min + i + 1}: #{line}\n"
-                      end
-                    end
-                  end
-                end
-                result = "/*\n#{e_string}\n\nBacktrace:\n#{e.backtrace.join("\n")}\n*/"
-              else
-                result = "/* Internal stylesheet error */"
-              end
-            end
-            
+            result = begin
+                       engine.render
+                     rescue Exception => e
+                       exception_string(e)
+                     end
+
             # Create any directories that might be necessary
             dirs = [l_options[:css_location]]
             name.split("/")[0...-1].each { |dir| dirs << "#{dirs[-1]}/#{dir}" }
             dirs.each { |dir| Dir.mkdir(dir) unless File.exist?(dir) }
-            
+
             # Finally, write the file
             File.open(css, 'w') do |file|
               file.print(result)
@@ -89,19 +67,76 @@ module Sass
           end
         end
       end
-      
+
       private
-      
+
+      def load_paths
+        (options[:load_paths] || []) + [options[:template_location]]
+      end
+
+      def exception_string(e)
+        if options[:full_exception]
+          e_string = "#{e.class}: #{e.message}"
+
+          if e.is_a? Sass::SyntaxError
+            e_string << "\non line #{e.sass_line}"
+
+            if e.sass_filename
+              e_string << " of #{e.sass_filename}"
+
+              if File.exists?(e.sass_filename)
+                e_string << "\n\n"
+
+                min = [e.sass_line - 5, 0].max
+                File.read(e.sass_filename).rstrip.split("\n")[
+                  min .. e.sass_line + 5
+                ].each_with_index do |line, i|
+                  e_string << "#{min + i + 1}: #{line}\n"
+                end
+              end
+            end
+          end
+          "/*\n#{e_string}\n\nBacktrace:\n#{e.backtrace.join("\n")}\n*/"
+        else
+          "/* Internal stylesheet error */"
+        end
+      end
+
       def template_filename(name)
-        "#{@@options[:template_location]}/#{name}.sass"
+        "#{options[:template_location]}/#{name}.sass"
       end
-      
+
       def css_filename(name)
-        "#{@@options[:css_location]}/#{name}.css"
+        "#{options[:css_location]}/#{name}.css"
+      end
+
+      def forbid_update?(name)
+        name[0] == ?_
       end
-      
+
       def stylesheet_needs_update?(name)
-        !File.exists?(css_filename(name)) || (File.mtime(template_filename(name)) - 2) > File.mtime(css_filename(name))
+        if !File.exists?(css_filename(name))
+          return true
+        else
+          css_mtime = File.mtime(css_filename(name))
+          File.mtime(template_filename(name)) > css_mtime ||
+            dependencies(template_filename(name)).any?(&dependency_updated?(css_mtime))
+        end
+      end
+
+      def dependency_updated?(css_mtime)
+        lambda do |dep|
+          File.mtime(dep) > css_mtime ||
+            dependencies(dep).any?(&dependency_updated?(css_mtime))
+        end
+      end
+
+      def dependencies(filename)
+        File.readlines(filename).grep(/^@import /).map do |line|
+          line[8..-1].split(',').map do |inc|
+            Sass::Engine.find_file_to_import(inc.strip, load_paths)
+          end
+        end.flatten.grep(/\.sass$/)
       end
     end
   end