haml 1.5.2 → 1.7.0

data/lib/sass/css.rb

@@ -0,0 +1,197 @@
+require File.dirname(__FILE__) + '/../sass'
+require 'sass/tree/node'
+require 'strscan'
+
+module Sass
+  # :stopdoc:
+  module Tree
+    class Node
+      def to_sass
+        result = ''
+
+        children.each do |child|
+          result << "#{child.to_sass(0)}\n"
+        end
+
+        result
+      end
+    end
+
+    class ValueNode
+      def to_sass(tabs)
+        "#{value}\n"
+      end
+    end
+
+    class RuleNode
+      def to_sass(tabs)
+        str = "#{'  ' * tabs}#{rule}\n"
+
+        children.each do |child|
+          str << "#{child.to_sass(tabs + 1)}"
+        end
+
+        str
+      end
+    end
+
+    class AttrNode
+      def to_sass(tabs)
+        "#{'  ' * tabs}:#{name} #{value}\n"
+      end
+    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.
+    def initialize(template)
+      if template.is_a? IO
+        template = template.read
+      end
+
+      @template = StringScanner.new(template)
+    end
+
+    # Processes the document and returns the result as a string
+    # containing the CSS template.
+    def render
+      begin
+        build_tree.to_sass
+      rescue Exception => err
+        line = @template.string[0...@template.pos].split("\n").size
+        
+        err.backtrace.unshift "(css):#{line}"
+        raise err
+      end
+    end
+
+    private
+
+    def build_tree
+      root = Tree::Node.new(nil)
+      whitespace
+      directives(root)
+      rules(root)
+      sort_rules(root)
+      root
+    end
+
+    def directives(root)
+      while @template.scan(/@/)
+        name = @template.scan /[^\s;]+/
+        whitespace
+        value = @template.scan /[^;]+/
+        assert_match /;/
+        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
+
+        if @template.scan(/\{/)
+          result = Tree::RuleNode.new(rules.join(' '), nil)
+          root << result
+          rules = []
+
+          whitespace
+          attributes(result)
+        end
+      end
+    end
+
+    def attributes(rule)
+      while @template.scan(/[^:\}\s]+/)
+        name = @template[0]
+        whitespace
+
+        assert_match /:/
+        
+        value = ''
+        while @template.scan(/[^;\s]+/)
+          value << @template[0] << whitespace
+        end
+        
+        assert_match /;/        
+        rule << Tree::AttrNode.new(name, value, nil)
+      end
+
+      assert_match /\}/
+    end
+
+    def whitespace
+      space = @template.scan(/\s*/) || ''
+
+      # If we've hit a comment,
+      # go past it and look for more whitespace
+      if @template.scan(/\/\*/)
+        @template.scan_until(/\*\//)
+        return space + whitespace
+      end
+      return space
+    end
+
+    def assert_match(re)
+      if !@template.scan(re)
+        raise Exception.new("Invalid CSS!")
+      end
+      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
+        else
+          1
+        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
+        end
+      end
+    end
+  end
+end

data/lib/sass/engine.rb

@@ -1,8 +1,11 @@
 require 'sass/tree/node'
 require 'sass/tree/value_node'
 require 'sass/tree/rule_node'
+require 'sass/tree/comment_node'
+require 'sass/tree/attr_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
@@ -16,17 +19,37 @@ module Sass
   class Engine
     # The character that begins a CSS attribute.
     ATTRIBUTE_CHAR  = ?:
-    
+
     # The character that designates that
     # an attribute should be assigned to the result of constant arithmetic.
     SCRIPT_CHAR     = ?=
-    
-    # The string that begins one-line comments.
-    COMMENT_STRING  = '//'
 
-    # The regex that matches attributes.
-    ATTRIBUTE = /:([^\s=]+)\s*(=?)\s*(.*)/
-  
+    # The character that designates the beginning of a comment,
+    # either Sass or CSS.
+    COMMENT_CHAR = ?/
+
+    # The character that follows the general COMMENT_CHAR and designates a Sass comment,
+    # which is not output as a CSS comment.
+    SASS_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 = ?*
+
+    # The character used to denote a compiler directive.
+    DIRECTIVE_CHAR = ?@
+
+    # The regex that matches and extracts data from
+    # attributes of the form <tt>:name attr</tt>.
+    ATTRIBUTE = /^:([^\s=:]+)\s*(=?)(?:\s+|$)(.*)/
+
+    # The regex that matches attributes of the form <tt>name: attr</tt>.
+    ATTRIBUTE_ALTERNATE_MATCHER = /^[^\s:]+\s*[=:](\s|$)/
+
+    # The regex that matches and extracts data from
+    # attributes of the form <tt>name: attr</tt>.
+    ATTRIBUTE_ALTERNATE = /^([^\s=:]+)(\s*=|:)(?:\s+|$)(.*)/
+
     # 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.
@@ -41,139 +64,287 @@ module Sass
     #
     def initialize(template, options={})
       @options = {
-        :style => :nested
+        :style => :nested,
+        :load_paths => ['.']
       }.merge! options
-      @template = template.split("\n")
+      @template = template.split(/\n\r|\n/)
       @lines = []
       @constants = {}
     end
-  
+
     # Processes the template and returns the result as a string.
     def render
       begin
-        split_lines
-      
-        root = Tree::Node.new(@options[:style])
-        index = 0
-        while @lines[index]
-          child, index = build_tree(index)
-          child.line = index if child
-          root << child if child
-        end
-        @line = nil
-
-        root.to_s
+        render_to_tree.to_s
       rescue SyntaxError => err
-        err.add_backtrace_entry(@options[:filename])
+        unless err.sass_filename
+          err.add_backtrace_entry(@options[:filename])
+        end
         raise err
       end
     end
 
     alias_method :to_css, :render
-    
+
+    protected
+
+    def constants
+      @constants
+    end
+
+    def render_to_tree
+      split_lines
+
+      root = Tree::Node.new(@options[:style])
+      index = 0
+      while @lines[index]
+        child, index = build_tree(index)
+
+        if child.is_a? Tree::Node
+          child.line = index
+          root << child
+        elsif child.is_a? Array
+          child.each do |c|
+            root << c
+          end
+        end
+      end
+      @line = nil
+
+      root
+    end
+
     private
-    
+
     # Readies each line in the template for parsing,
     # and computes the tabulation of the line.
     def split_lines
+      @line = 0
       old_tabs = 0
       @template.each_with_index do |line, index|
-        @line = index + 1
-      
-        # TODO: Allow comments appended to the end of lines,
-        # find some way to make url(http://www.google.com/) work
-        unless line[0..1] == COMMENT_STRING # unless line is a comment
-          tabs = count_tabs(line)
-          
-          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) 
-            end
-            @lines << [line.strip, tabs]
-
-            old_tabs = tabs
+        @line += 1
+
+        tabs = count_tabs(line)
+
+        if line[0] == COMMENT_CHAR && line[1] == SASS_COMMENT_CHAR && tabs == 0
+          tabs = old_tabs
+        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)
           end
+          @lines << [line.strip, tabs]
+
+          old_tabs = tabs
+        else
+          @lines << ['//', old_tabs]
         end
       end
+
       @line = nil
     end
-    
+
     # Counts the tabulation of a line.
     def count_tabs(line)
       spaces = line.index(/[^ ]/)
       if spaces
         if spaces % 2 == 1 || line[spaces] == ?\t
-          raise SyntaxError.new("Illegal Indentation: Only two space characters are allowed as tabulation.", @line) 
+          # 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
       end
     end
-    
+
     def build_tree(index)
       line, tabs = @lines[index]
       index += 1
       @line = index
       node = parse_line(line)
 
-      # Node is nil if it's non-outputting, like a constant assignment
-      return nil, index unless node
-
       has_children = has_children?(index, tabs)
-      
-      while has_children
-        child, index = build_tree(index)
 
-        if child.nil?
-          raise SyntaxError.new("Constants may only be declared at the root of a document.", @line)
+      # Node is a symbol if it's non-outputting, like a constant assignment
+      unless node.is_a? Tree::Node
+        if has_children
+          if node == :constant
+            raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath constants.", @line)
+          elsif node.is_a? Array
+            raise SyntaxError.new("Illegal nesting: Nothing may be nested beneath import directives.", @line)
+          end
+        end
+
+        return node, index
+      end
+
+      if node.is_a? Tree::CommentNode
+        while has_children
+          line, index = raw_next_line(index)
+          node << line
+
+          has_children = has_children?(index, tabs)
         end
+      else
+        while has_children
+          child, index = build_tree(index)
 
-        child.line = @line
-        node << child if child
-        has_children = has_children?(index, tabs)
+          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
+          end
+
+          has_children = has_children?(index, tabs)
+        end
       end
-      
+
       return node, index
     end
-    
+
     def has_children?(index, tabs)
       next_line = @lines[index]
       next_line && next_line[1] > tabs
     end
-    
+
+    def raw_next_line(index)
+      [@lines[index][0], index + 1]
+    end
+
     def parse_line(line)
       case line[0]
-        when ATTRIBUTE_CHAR
-          parse_attribute(line)
-        when Constant::CONSTANT_CHAR
-          parse_constant(line)
+      when ATTRIBUTE_CHAR
+        parse_attribute(line, ATTRIBUTE)
+      when Constant::CONSTANT_CHAR
+        parse_constant(line)
+      when COMMENT_CHAR
+        parse_comment(line)
+      when DIRECTIVE_CHAR
+        parse_directive(line)
+      else
+        if line =~ ATTRIBUTE_ALTERNATE_MATCHER
+          parse_attribute(line, ATTRIBUTE_ALTERNATE)
         else
           Tree::RuleNode.new(line, @options[:style])
+        end
       end
     end
-    
-    def parse_attribute(line)
-      name, eq, value = line.scan(ATTRIBUTE)[0]
+
+    def parse_attribute(line, attribute_regx)
+      name, eq, value = line.scan(attribute_regx)[0]
 
       if name.nil? || value.nil?
         raise SyntaxError.new("Invalid attribute: \"#{line}\"", @line)
       end
-      
-      if eq[0] == SCRIPT_CHAR
+
+      if eq.strip[0] == SCRIPT_CHAR
         value = Sass::Constant.parse(value, @constants, @line).to_s
       end
-      
+
       Tree::AttrNode.new(name, value, @options[:style])
     end
-    
+
     def parse_constant(line)
       name, value = line.scan(Sass::Constant::MATCH)[0]
       unless name && value
         raise SyntaxError.new("Invalid constant: \"#{line}\"", @line)
       end
       @constants[name] = Sass::Constant.parse(value, @constants, @line)
-      nil
+      :constant
+    end
+
+    def parse_comment(line)
+      if line[1] == SASS_COMMENT_CHAR
+        :comment
+      elsif line[1] == CSS_COMMENT_CHAR
+        Tree::CommentNode.new(line, @options[:style])
+      else
+        Tree::RuleNode.new(line, @options[:style])
+      end
+    end
+
+    def parse_directive(line)
+      directive, value = line[1..-1].split(/\s+/, 2)
+
+      case directive
+      when "import"
+        import(value)
+      else
+        raise SyntaxError.new("Unknown compiler directive: #{"@#{directive} #{value}".dump}", @line)
+      end
+    end
+
+    def import(files)
+      nodes = []
+
+      files.split(/,\s*/).each do |filename|
+        engine = nil
+        filename = find_file_to_import(filename)
+        if filename =~ /\.css$/
+          nodes << Tree::ValueNode.new("@import #{filename}", @options[:style])
+        else
+          File.open(filename) do |file|
+            new_options = @options.dup
+            new_options[:filename] = filename
+            engine = Sass::Engine.new(file.read, @options)
+          end
+
+          engine.constants.merge! @constants
+
+          begin
+            root = engine.render_to_tree
+          rescue Sass::SyntaxError => err
+            err.add_backtrace_entry(filename)
+            raise err
+          end
+          root.children.each do |child|
+            child.filename = filename
+            nodes << child
+          end
+          @constants = engine.constants
+        end
+      end
+
+      nodes
+    end
+
+    def find_file_to_import(filename)
+      was_sass = false
+      original_filename = filename
+      new_filename = nil
+
+      if filename[-5..-1] == ".sass"
+        filename = filename[0...-5]
+        was_sass = true
+      elsif filename[-4..-1] == ".css"
+        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
+
+      if new_filename.nil?
+        if was_sass
+          raise SyntaxError.new("File to import not found or unreadable: #{original_filename}", @line)
+        else
+          return filename + '.css'
+        end
+      else
+        new_filename
+      end
     end
   end
 end