haml 1.8.0 → 2.0.3

data/lib/sass/css.rb

@@ -6,11 +6,11 @@ module Sass
   # :stopdoc:
   module Tree
     class Node
-      def to_sass
+      def to_sass(opts = {})
         result = ''
 
         children.each do |child|
-          result << "#{child.to_sass(0)}\n"
+          result << "#{child.to_sass(0, opts)}\n"
         end
 
         result
@@ -18,17 +18,17 @@ module Sass
     end
 
     class ValueNode
-      def to_sass(tabs)
+      def to_sass(tabs, opts = {})
         "#{value}\n"
       end
     end
 
     class RuleNode
-      def to_sass(tabs)
-        str = "#{'  ' * tabs}#{rule}\n"
+      def to_sass(tabs, opts = {})
+        str = "\n#{'  ' * tabs}#{rule}#{children.any? { |c| c.is_a? AttrNode } ? "\n" : ''}"
 
         children.each do |child|
-          str << "#{child.to_sass(tabs + 1)}"
+          str << "#{child.to_sass(tabs + 1, opts)}"
         end
 
         str
@@ -36,8 +36,14 @@ module Sass
     end
 
     class AttrNode
-      def to_sass(tabs)
-        "#{'  ' * tabs}:#{name} #{value}\n"
+      def to_sass(tabs, opts = {})
+        "#{'  ' * tabs}#{opts[:alternate] ? '' : ':'}#{name}#{opts[:alternate] ? ':' : ''} #{value}\n"
+      end
+    end
+
+    class DirectiveNode
+      def to_sass(tabs, opts = {})
+        "#{'  ' * tabs}#{value}#{children.map {|c| c.to_sass(tabs + 1, opts)}}\n"
       end
     end
   end
@@ -46,25 +52,40 @@ module Sass
   # 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)
+    Node = Struct.new(:key, :value, :next, :prev)
     include Enumerable
 
     def initialize
       @hash = {}
     end
 
+    def initialize_copy(other)
+      @hash = other.instance_variable_get('@hash').clone
+    end
+
     def [](key)
       @hash[key] && @hash[key].value
     end
 
     def []=(key, value)
-      node = Node.new(key, value, nil)
+      node = Node.new(key, value)
+
+      if old = @hash[key]
+        if old.prev
+          old.prev.next = old.next
+        else # old is @first and @last
+          @first = @last = nil
+        end
+      end
+
       if @first.nil?
         @first = @last = node
       else
+        node.prev = @last
         @last.next = node
         @last = node
       end
+
       @hash[key] = node
       value
     end
@@ -90,11 +111,12 @@ module Sass
 
     # Creates a new instance of Sass::CSS that will compile the given document
     # to a Sass string when +render+ is called.
-    def initialize(template)
+    def initialize(template, options = {})
       if template.is_a? IO
         template = template.read
       end
 
+      @options = options
       @template = StringScanner.new(template)
     end
 
@@ -102,10 +124,10 @@ module Sass
     # containing the CSS template.
     def render
       begin
-        build_tree.to_sass
+        build_tree.to_sass(@options).strip + "\n"
       rescue Exception => err
         line = @template.string[0...@template.pos].split("\n").size
-        
+
         err.backtrace.unshift "(css):#{line}"
         raise err
       end
@@ -116,46 +138,42 @@ module Sass
     def build_tree
       root = Tree::Node.new(nil)
       whitespace
-      directives    root
-      rules         root
-      expand_commas root
-      nest_rules    root
-      flatten_rules root
-      fold_commas   root
+      rules              root
+      expand_commas      root
+      parent_ref_rules   root
+      remove_parent_refs root
+      flatten_rules      root
+      fold_commas        root
       root
     end
 
-    def directives(root)
-      while @template.scan(/@/)
-        name = @template.scan /[^\s;]+/
-        whitespace
-        value = @template.scan /[^;]+/
-        assert_match /;/
+    def rules(root)
+      while r = rule
+        root << r
         whitespace
-
-        if name == "import" && value =~ /^(url\()?"?([^\s\(\)\"]+)\.css"?\)?$/
-          value = $2
-        end
-
-        root << Tree::ValueNode.new("@#{name} #{value};", nil)
       end
     end
 
-    def rules(root)
-      rules = []
-      while @template.scan(/[^\{\s]+/)
-        rules << @template[0]
-        whitespace
+    def rule
+      return unless rule = @template.scan(/[^\{\};]+/)
+      rule.strip!
+      directive = rule[0] == ?@
 
-        if @template.scan(/\{/)
-          result = Tree::RuleNode.new(rules.join(' '), nil)
-          root << result
-          rules = []
+      if directive
+        node = Tree::DirectiveNode.new(rule, nil)
+        return node if @template.scan(/;/)
 
-          whitespace
-          attributes(result)
-        end
+        assert_match /\{/
+        whitespace
+
+        rules(node)
+        return node
       end
+
+      assert_match /\{/
+      node = Tree::RuleNode.new(rule, nil)
+      attributes(node)
+      return node
     end
 
     def attributes(rule)
@@ -164,12 +182,12 @@ module Sass
         whitespace
 
         assert_match /:/
-        
+
         value = ''
         while @template.scan(/[^;\s\}]+/)
           value << @template[0] << whitespace
         end
-        
+
         assert_match /(;|(?=\}))/
         rule << Tree::AttrNode.new(name, value, nil)
       end
@@ -191,7 +209,10 @@ module Sass
 
     def assert_match(re)
       if !@template.scan(re)
-        raise Exception.new("Invalid CSS!")
+        line = @template.string[0..@template.pos].count "\n"
+        # Display basic regexps as plain old strings
+        expected = re.source == Regexp.escape(re.source) ? "\"#{re.source}\"" : re.inspect
+        raise Exception.new("Invalid CSS on line #{line}: expected #{expected}")
       end
       whitespace
     end
@@ -224,7 +245,22 @@ module Sass
       root.children.flatten!
     end
 
-    # Nest rules so that
+    # Make rules use parent refs so that
+    #
+    #   foo
+    #     color: green
+    #   foo.bar
+    #     color: blue
+    #
+    # becomes
+    #
+    #   foo
+    #     color: green
+    #     &.bar
+    #       color: blue
+    #
+    # This has the side effect of nesting rules,
+    # so that
     #
     #   foo
     #     color: green
@@ -237,29 +273,50 @@ module Sass
     #
     #   foo
     #     color: green
-    #     bar
+    #     & bar
     #       color: red
-    #     baz
+    #     & baz
     #       color: blue
-    # 
-    def nest_rules(root)
+    #
+    def parent_ref_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)
+        first, rest = child.rule.scan(/^(&?(?: .|[^ ])[^.#: \[]*)([.#: \[].*)?$/).first
         rules[first] ||= Tree::RuleNode.new(first, nil)
         if rest
-          child.rule = rest
+          child.rule = "&" + rest
           rules[first] << child
         else
           rules[first].children += child.children
         end
       end
 
-      rules.values.each { |v| nest_rules(v) }
+      rules.values.each { |v| parent_ref_rules(v) }
       root.children += rules.values
     end
 
+    # Remove useless parent refs so that
+    #
+    #   foo
+    #     & bar
+    #       color: blue
+    #
+    # becomes
+    #
+    #   foo
+    #     bar
+    #       color: blue
+    #
+    def remove_parent_refs(root)
+      root.children.each do |child|
+        if child.is_a?(Tree::RuleNode)
+          child.rule.gsub! /^& /, ''
+          remove_parent_refs child
+        end
+      end
+    end
+
     # Flatten rules so that
     #
     #   foo
@@ -271,7 +328,18 @@ module Sass
     #
     #   foo bar baz
     #     color: red
-    # 
+    #
+    # and
+    #
+    #   foo
+    #     &.bar
+    #       color: blue
+    #
+    # becomes
+    #
+    #   foo.bar
+    #     color: blue
+    #
     def flatten_rules(root)
       root.children.each { |child| flatten_rule(child) if child.is_a?(Tree::RuleNode) }
     end
@@ -279,7 +347,13 @@ module Sass
     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}"
+
+        if child.rule[0] == ?&
+          rule.rule = child.rule.gsub /^&/, rule.rule
+        else
+          rule.rule = "#{rule.rule} #{child.rule}"
+        end
+
         rule.children = child.children
       end
 

data/lib/sass/engine.rb

@@ -6,7 +6,6 @@ require 'sass/tree/attr_node'
 require 'sass/tree/directive_node'
 require 'sass/constant'
 require 'sass/error'
-require 'haml/util'
 
 module Sass
   # This is the class where all the parsing and processing of the Sass
@@ -39,10 +38,16 @@ module Sass
 
     # The character used to denote a compiler directive.
     DIRECTIVE_CHAR = ?@
-    
+
     # Designates a non-parsed rule.
     ESCAPE_CHAR    = ?\\
 
+    # Designates block as mixin definition rather than CSS rules to output
+    MIXIN_DEFINITION_CHAR = ?=
+
+    # Includes named mixin declared using MIXIN_DEFINITION_CHAR
+    MIXIN_INCLUDE_CHAR    = ?+
+
     # The regex that matches and extracts data from
     # attributes of the form <tt>:name attr</tt>.
     ATTRIBUTE = /^:([^\s=:]+)\s*(=?)(?:\s+|$)(.*)/
@@ -56,14 +61,14 @@ module Sass
 
     # Creates a new instace of Sass::Engine that will compile the given
     # template string when <tt>render</tt> is called.
-    # See README for available options.
+    # See README.rdoc for available options.
     #
     #--
     #
     # TODO: Add current options to REFRENCE. Remember :filename!
     #
     # When adding options, remember to add information about them
-    # to README!
+    # to README.rdoc!
     #++
     #
     def initialize(template, options={})
@@ -71,9 +76,10 @@ module Sass
         :style => :nested,
         :load_paths => ['.']
       }.merge! options
-      @template = template.split(/\n\r|\n/)
+      @template = template.split(/\r\n|\r|\n/)
       @lines = []
       @constants = {"important" => "!important"}
+      @mixins = {}
     end
 
     # Processes the template and returns the result as a string.
@@ -96,16 +102,21 @@ module Sass
       @constants
     end
 
+    def mixins
+      @mixins
+    end
+
     def render_to_tree
       split_lines
 
       root = Tree::Node.new(@options[:style])
       index = 0
       while @lines[index]
+        old_index = index
         child, index = build_tree(index)
 
         if child.is_a? Tree::Node
-          child.line = index
+          child.line = old_index + 1
           root << child
         elsif child.is_a? Array
           child.each do |c|
@@ -113,7 +124,7 @@ module Sass
           end
         end
       end
-      @line = nil
+      @lines.clear
 
       root
     end
@@ -124,7 +135,7 @@ module Sass
     # and computes the tabulation of the line.
     def split_lines
       @line = 0
-      old_tabs = 0
+      old_tabs = nil
       @template.each_with_index do |line, index|
         @line += 1
 
@@ -135,14 +146,16 @@ module Sass
         end
 
         if tabs # if line isn't blank
-          if tabs - old_tabs > 1
-            raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.", @line)
+          raise SyntaxError.new("Indenting at the beginning of the document is illegal.", @line) if old_tabs.nil? && tabs > 0
+
+          if old_tabs && tabs - old_tabs > 1
+            raise SyntaxError.new("#{tabs * 2} spaces were used for indentation. Sass must be indented using two spaces.", @line)
           end
           @lines << [line.strip, tabs]
 
           old_tabs = tabs
         else
-          @lines << ['//', old_tabs]
+          @lines << ['//', old_tabs || 0]
         end
       end
 
@@ -151,18 +164,20 @@ module Sass
 
     # Counts the tabulation of a line.
     def count_tabs(line)
-      spaces = line.index(/[^ ]/)
-      if spaces
-        if spaces % 2 == 1 || line[spaces] == ?\t
-          # Make sure a line with just tabs isn't an error
-          return nil if line.strip.empty?
-
-          raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.", @line)
-        end
-        spaces / 2
-      else
-        nil
+      return nil if line.strip.empty?
+      return nil unless spaces = line.index(/[^ ]/)
+
+      if spaces % 2 == 1
+          raise SyntaxError.new(<<END.strip, @line)
+#{spaces} space#{spaces == 1 ? ' was' : 's were'} used for indentation. Sass must be indented using two spaces.
+END
+      elsif line[spaces] == ?\t
+        raise SyntaxError.new(<<END.strip, @line)
+A tab character was used for indentation. Sass must be indented using two spaces.
+Are you sure you have soft tabs enabled in your editor?
+END
       end
+      spaces / 2
     end
 
     def build_tree(index)
@@ -177,15 +192,23 @@ module Sass
       unless node.is_a? Tree::Node
         if has_children
           if node == :constant
-            raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath constants.", @line)
+            raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath constants.", @line + 1)
           elsif node.is_a? Array
-            raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.", @line)
+            # arrays can either be full of import statements
+            # or attributes from mixin includes
+            # in either case they shouldn't have children.
+            # Need to peek into the array in order to give meaningful errors
+            directive_type = (node.first.is_a?(Tree::DirectiveNode) ? "import" : "mixin")
+            raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath #{directive_type} directives.", @line + 1)
           end
         end
 
+        index = @line if node == :mixin
         return node, index
       end
 
+      node.line = @line
+
       if node.is_a? Tree::CommentNode
         while has_children
           line, index = raw_next_line(index)
@@ -193,26 +216,52 @@ module Sass
 
           has_children = has_children?(index, tabs)
         end
-      else
-        while has_children
-          child, index = build_tree(index)
 
-          if child == :constant
-            raise SyntaxError.new("Constants may only be declared at the root of a document.", @line)
-          elsif child.is_a? Array
-            raise SyntaxError.new("Import directives may only be used at the root of a document.", @line)
-          elsif child.is_a? Tree::Node
-            child.line = @line
-            node << child
+        return node, index
+      end
+
+      # Resolve multiline rules
+      if node.is_a?(Tree::RuleNode)
+        if node.continued?
+          child, index = build_tree(index) if @lines[old_index = index]
+          if @lines[old_index].nil? || has_children?(old_index, tabs) || !child.is_a?(Tree::RuleNode)
+            raise SyntaxError.new("Rules can't end in commas.", @line)
           end
 
-          has_children = has_children?(index, tabs)
+          node.add_rules child
         end
+        node.children = child.children if child
+      end
+
+      while has_children
+        child, index = build_tree(index)
+
+        validate_and_append_child(node, child)
+
+        has_children = has_children?(index, tabs)
       end
 
       return node, index
     end
 
+    def validate_and_append_child(parent, child)
+      case child
+      when :constant
+        raise SyntaxError.new("Constants may only be declared at the root of a document.", @line)
+      when :mixin
+        raise SyntaxError.new("Mixins may only be defined at the root of a document.", @line)
+      when Array
+        child.each do |c|
+          if c.is_a?(Tree::DirectiveNode)
+            raise SyntaxError.new("Import directives may only be used at the root of a document.", @line)
+          end
+          parent << c
+        end
+      when Tree::Node
+        parent << child
+      end
+    end
+
     def has_children?(index, tabs)
       next_line = ['//', 0]
       while !next_line.nil? && next_line[0] == '//' && next_line[1] = 0
@@ -238,6 +287,14 @@ module Sass
         parse_directive(line)
       when ESCAPE_CHAR
         Tree::RuleNode.new(line[1..-1], @options[:style])
+      when MIXIN_DEFINITION_CHAR
+        parse_mixin_definition(line)
+      when MIXIN_INCLUDE_CHAR
+        if line[1].nil? || line[1] == ?\s
+          Tree::RuleNode.new(line, @options[:style])
+        else
+          parse_mixin_include(line)
+        end
       else
         if line =~ ATTRIBUTE_ALTERNATE_MATCHER
           parse_attribute(line, ATTRIBUTE_ALTERNATE)
@@ -259,7 +316,7 @@ module Sass
       name, eq, value = line.scan(attribute_regx)[0]
 
       if name.nil? || value.nil?
-        raise SyntaxError.new("Invalid attribute: \"#{line}\"", @line)
+        raise SyntaxError.new("Invalid attribute: \"#{line}\".", @line)
       end
 
       if eq.strip[0] == SCRIPT_CHAR
@@ -270,11 +327,18 @@ module Sass
     end
 
     def parse_constant(line)
-      name, value = line.scan(Sass::Constant::MATCH)[0]
+      name, op, value = line.scan(Sass::Constant::MATCH)[0]
       unless name && value
-        raise SyntaxError.new("Invalid constant: \"#{line}\"", @line)
+        raise SyntaxError.new("Invalid constant: \"#{line}\".", @line)
+      end
+
+      constant = Sass::Constant.parse(value, @constants, @line)
+      if op == '||='
+        @constants[name] ||= constant
+      else
+        @constants[name] = constant
       end
-      @constants[name] = Sass::Constant.parse(value, @constants, @line)
+
       :constant
     end
 
@@ -291,14 +355,36 @@ module Sass
     def parse_directive(line)
       directive, value = line[1..-1].split(/\s+/, 2)
 
-      case directive
-      when "import"
+      # If value begins with url( or ",
+      # it's a CSS @import rule and we don't want to touch it.
+      if directive == "import" && value !~ /^(url\(|")/
         import(value)
       else
         Tree::DirectiveNode.new(line, @options[:style])
       end
     end
 
+    def parse_mixin_definition(line)
+      mixin_name = line[1..-1]
+      @mixins[mixin_name] =  []
+      index = @line
+      line, tabs = @lines[index]
+      while !line.nil? && tabs > 0
+        child, index = build_tree(index)
+        validate_and_append_child(@mixins[mixin_name], child)
+        line, tabs = @lines[index]
+      end
+      :mixin
+    end
+
+    def parse_mixin_include(line)
+      mixin_name = line[1..-1]
+      unless @mixins.has_key?(mixin_name)
+        raise SyntaxError.new("Undefined mixin '#{mixin_name}'.", @line)
+      end
+      @mixins[mixin_name]
+    end
+
     def import(files)
       nodes = []
 
@@ -312,7 +398,7 @@ module Sass
         end
 
         if filename =~ /\.css$/
-          nodes << Tree::ValueNode.new("@import url(#{filename});", @options[:style])
+          nodes << Tree::DirectiveNode.new("@import url(#{filename})", @options[:style])
         else
           File.open(filename) do |file|
             new_options = @options.dup
@@ -321,6 +407,7 @@ module Sass
           end
 
           engine.constants.merge! @constants
+          engine.mixins.merge! @mixins
 
           begin
             root = engine.render_to_tree
@@ -333,6 +420,7 @@ module Sass
             nodes << child
           end
           @constants = engine.constants
+          @mixins = engine.mixins
         end
       end
 
@@ -354,7 +442,7 @@ module Sass
 
       if new_filename.nil?
         if was_sass
-          raise Exception.new("File to import not found or unreadable: #{original_filename}")
+          raise Exception.new("File to import not found or unreadable: #{original_filename}.")
         else
           return filename + '.css'
         end