radiant 0.8.2 → 0.9.0.rc2

data/vendor/plugins/haml/lib/sass/tree/prop_node.rb

@@ -0,0 +1,121 @@
+module Sass::Tree
+  # A static node reprenting a CSS property.
+  #
+  # @see Sass::Tree
+  class PropNode < Node
+    # The name of the property.
+    #
+    # @return [String]
+    attr_accessor :name
+
+    # The value of the property,
+    # either a plain string or a SassScript parse tree.
+    #
+    # @return [String, Script::Node]
+    attr_accessor :value
+
+    # @param name [String] See \{#name}
+    # @param value [String] See \{#value}
+    # @param prop_syntax [Symbol] `:new` if this property uses `a: b`-style syntax,
+    #   `:old` if it uses `:a b`-style syntax
+    def initialize(name, value, prop_syntax)
+      @name = name
+      @value = value
+      @prop_syntax = prop_syntax
+      super()
+    end
+
+    # Compares the names and values of two properties.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] Whether or not this node and the other object
+    #   are the same
+    def ==(other)
+      self.class == other.class && name == other.name && value == other.value && super
+    end
+
+    # Computes the CSS for the property.
+    #
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @param parent_name [String] The name of the parent property (e.g. `text`) or nil
+    # @return [String] The resulting CSS
+    # @raise [Sass::SyntaxError] if the property uses invalid syntax
+    def to_s(tabs, parent_name = nil)
+      if @options[:property_syntax] == :old && @prop_syntax == :new
+        raise Sass::SyntaxError.new("Illegal property syntax: can't use new syntax when :property_syntax => :old is set.", @line)
+      elsif @options[:property_syntax] == :new && @prop_syntax == :old
+        raise Sass::SyntaxError.new("Illegal property syntax: can't use old syntax when :property_syntax => :new is set.", @line)
+      end
+
+      if value[-1] == ?;
+        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no \";\" required at end-of-line).", @line)
+      end
+      real_name = name
+      real_name = "#{parent_name}-#{real_name}" if parent_name
+      
+      if value.empty? && children.empty?
+        message = "Invalid property: #{declaration.dump} (no value)." +
+          pseudo_class_selector_message
+        raise Sass::SyntaxError.new(message, @line)
+      end
+      
+      join_string = case style
+                    when :compact; ' '
+                    when :compressed; ''
+                    else "\n"
+                    end
+      spaces = '  ' * (tabs - 1)
+      to_return = ''
+      if !value.empty?
+        to_return << "#{spaces}#{real_name}:#{style == :compressed ? '' : ' '}#{value};#{join_string}"
+      end
+      
+      children.each do |kid|
+        next if kid.invisible?
+        to_return << kid.to_s(tabs, real_name) << join_string
+      end
+      
+      (style == :compressed && parent_name) ? to_return : to_return[0...-1]
+    end
+
+    # Returns a appropriate message indicating how to escape pseudo-class selectors.
+    # This only applies for old-style properties with no value,
+    # so returns the empty string if this is new-style.
+    #
+    # @return [String] The message
+    def pseudo_class_selector_message
+      return "" if @prop_syntax == :new || !value.empty?
+      "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
+    end
+
+    protected
+
+    # Runs any SassScript that may be embedded in the property.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    def perform!(environment)
+      @name = interpolate(@name, environment)
+      @value = @value.is_a?(String) ? interpolate(@value, environment) : @value.perform(environment).to_s
+      super
+    end
+
+    # Returns an error message if the given child node is invalid,
+    # and false otherwise.
+    #
+    # {PropNode} only allows other {PropNode}s and {CommentNode}s as children.
+    # @param child [Tree::Node] A potential child node
+    # @return [String] An error message if the child is invalid, or nil otherwise
+    def invalid_child?(child)
+      if !child.is_a?(PropNode) && !child.is_a?(CommentNode)
+        "Illegal nesting: Only properties may be nested beneath properties."
+      end
+    end
+
+    private
+
+    def declaration
+      (@prop_syntax == :new ? "#{name}: #{value}" : ":#{name} #{value}").strip
+    end
+  end
+end

data/vendor/plugins/haml/lib/sass/tree/rule_node.rb

@@ -1,93 +1,224 @@
-require 'sass/tree/node'
-require 'sass/tree/attr_node'
+require 'pathname'
 
 module Sass::Tree
-  class RuleNode < ValueNode
+  # A static node reprenting a CSS rule.
+  #
+  # @see Sass::Tree
+  class RuleNode < Node
     # The character used to include the parent selector
+    # @private
     PARENT = '&'
 
-    alias_method :rule, :value
-    alias_method :rule=, :value=
+    # The CSS selectors for this rule.
+    # Each string is a selector line, and the lines are meant to be separated by commas.
+    # For example,
+    #
+    #     foo, bar, baz,
+    #     bip, bop, bup
+    #
+    # would be
+    #
+    #     ["foo, bar, baz",
+    #      "bip, bop, bup"]
+    #
+    # @return [Array<String>]
+    attr_accessor :rules
 
-    def ==(other)
-      self.class == other.class && rules == other.rules && super
+    # The CSS selectors for this rule,
+    # parsed for commas and parent-references.
+    # It's only set once {Tree::Node#perform} has been called.
+    #
+    # It's an array of arrays of arrays.
+    # The first level of arrays represents distinct lines in the Sass file;
+    # the second level represents comma-separated selectors;
+    # the third represents structure within those selectors,
+    # currently only parent-refs (represented by `:parent`).
+    # For example,
+    #
+    #     &.foo, bar, baz,
+    #     bip, &.bop, bup
+    #
+    # would be
+    #
+    #     [[[:parent, "foo"], ["bar"], ["baz"]],
+    #      [["bip"], [:parent, "bop"], ["bup"]]]
+    #
+    # @return [Array<Array<Array<String|Symbol>>>]
+    attr_accessor :parsed_rules
+
+    # @param rule [String] The first CSS rule. See \{#rules}
+    def initialize(rule)
+      @rules = [rule]
+      super()
     end
 
-    def rules
-      Array(rule)
+    # Compares the contents of two rules.
+    #
+    # @param other [Object] The object to compare with
+    # @return [Boolean] Whether or not this node and the other object
+    #   are the same
+    def ==(other)
+      self.class == other.class && rules == other.rules && super
     end
 
+    # Adds another {RuleNode}'s rules to this one's.
+    #
+    # @param node [RuleNode] The other node
     def add_rules(node)
-      self.rule = rules
-      self.rule += node.rules
+      @rules += node.rules
     end
 
+    # @return [Boolean] Whether or not this rule is continued on the next line
     def continued?
-      rule[-1] == ?,
+      @rules.last[-1] == ?,
     end
 
+    # Computes the CSS for the rule.
+    #
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @param super_rules [Array<Array<String>>] The rules for the parent node
+    #   (see \{#rules}), or `nil` if there are no parents
+    # @return [String] The resulting CSS
+    # @raise [Sass::SyntaxError] if the rule has no parents but uses `&`
     def to_s(tabs, super_rules = nil)
-      attributes = []
+      resolved_rules = resolve_parent_refs(super_rules)
+
+      properties = []
       sub_rules = []
 
-      rule_split = /\s*,\s*/
-      rule_separator = @style == :compressed ? ',' : ', '
-      line_separator = [:nested, :expanded].include?(@style) ? ",\n" : rule_separator
+      rule_separator = style == :compressed ? ',' : ', '
+      line_separator = [:nested, :expanded].include?(style) ? ",\n" : rule_separator
       rule_indent = '  ' * (tabs - 1)
-      total_rule = if super_rules
-        super_rules.split(",\n").map do |super_line|
-          super_line.strip.split(rule_split).map do |super_rule|
-            self.rules.map do |line|
-              rule_indent + line.gsub(/,$/, '').split(rule_split).map do |rule|
-                if rule.include?(PARENT)
-                  rule.gsub(PARENT, super_rule)
-                else
-                  "#{super_rule} #{rule}"
-                end
-              end.join(rule_separator)
-            end.join(line_separator)
-          end.join(rule_separator)
-        end.join(line_separator)
-      elsif self.rules.any? { |r| r.include?(PARENT) }
-        raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.", line)
-      else
-        per_rule_indent, total_indent = [:nested, :expanded].include?(@style) ? [rule_indent, ''] : ['', rule_indent]
-        total_indent + self.rules.map do |r|
-          per_rule_indent + r.gsub(/,$/, '').gsub(rule_split, rule_separator).rstrip
-        end.join(line_separator)
-      end
+      per_rule_indent, total_indent = [:nested, :expanded].include?(style) ? [rule_indent, ''] : ['', rule_indent]
+
+      total_rule = total_indent + resolved_rules.map do |line|
+        per_rule_indent + line.join(rule_separator)
+      end.join(line_separator)
 
       children.each do |child|
+        next if child.invisible?
         if child.is_a? RuleNode
           sub_rules << child
         else
-          attributes << child
+          properties << child
         end
       end
 
       to_return = ''
-      if !attributes.empty?
+      if !properties.empty?
         old_spaces = '  ' * (tabs - 1)
         spaces = '  ' * tabs
-        if @style == :compact
-          attributes = attributes.map { |a| a.to_s(1) }.join(' ')
-          to_return << "#{total_rule} { #{attributes} }\n"
-        elsif @style == :compressed
-          attributes = attributes.map { |a| a.to_s(1) }.join(';')
-          to_return << "#{total_rule}{#{attributes}}"
+        if @options[:line_comments] && style != :compressed
+          to_return << "#{old_spaces}/* line #{line}"
+
+          if filename
+            relative_filename = if @options[:css_filename]
+              begin
+                Pathname.new(filename).relative_path_from(  
+                  Pathname.new(File.dirname(@options[:css_filename]))).to_s
+              rescue ArgumentError
+                nil
+              end
+            end
+            relative_filename ||= filename
+            to_return << ", #{relative_filename}"
+          end
+
+          to_return << " */\n"
+        end
+
+        if style == :compact
+          properties = properties.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(' ')
+          to_return << "#{total_rule} { #{properties} }\n"
+        elsif style == :compressed
+          properties = properties.map { |a| a.to_s(1) }.select{|a| a && a.length > 0}.join(';')
+          to_return << "#{total_rule}{#{properties}}"
         else
-          attributes = attributes.map { |a| a.to_s(tabs + 1) }.join("\n")
-          end_attrs = (@style == :expanded ? "\n" + old_spaces : ' ')
-          to_return << "#{total_rule} {\n#{attributes}#{end_attrs}}\n"
+          properties = properties.map { |a| a.to_s(tabs + 1) }.select{|a| a && a.length > 0}.join("\n")
+          end_props = (style == :expanded ? "\n" + old_spaces : ' ')
+          to_return << "#{total_rule} {\n#{properties}#{end_props}}\n"
         end
       end
 
-      tabs += 1 unless attributes.empty? || @style != :nested
+      tabs += 1 unless properties.empty? || style != :nested
       sub_rules.each do |sub|
-        to_return << sub.to_s(tabs, total_rule)
+        to_return << sub.to_s(tabs, resolved_rules)
       end
 
       to_return
     end
+
+    protected
+
+    # Runs any SassScript that may be embedded in the rule,
+    # and parses the selectors for commas.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    def perform!(environment)
+      @parsed_rules = @rules.map {|r| parse_selector(interpolate(r, environment))}
+      super
+    end
+
+    private
+
+    def resolve_parent_refs(super_rules)
+      if super_rules.nil?
+        return @parsed_rules.map do |line|
+          line.map do |rule|
+            if rule.include?(:parent)
+              raise Sass::SyntaxError.new("Base-level rules cannot contain the parent-selector-referencing character '#{PARENT}'.", self.line)
+            end
+
+            rule.join
+          end.compact
+        end
+      end
+
+      new_rules = []
+      super_rules.each do |super_line|
+        @parsed_rules.each do |line|
+          new_rules << []
+
+          super_line.each do |super_rule|
+            line.each do |rule|
+              rule = [:parent, " ", *rule] unless rule.include?(:parent)
+
+              new_rules.last << rule.map do |segment|
+                next segment unless segment == :parent
+                super_rule
+              end.join
+            end
+          end
+        end
+      end
+      new_rules
+    end
+
+    def parse_selector(text)
+      scanner = StringScanner.new(text)
+      rules = [[]]
+
+      while scanner.rest?
+        rules.last << scanner.scan(/[^",&]*/)
+        case scanner.scan(/./)
+        when '&'; rules.last << :parent
+        when ','
+          scanner.scan(/\s*/)
+          rules << [] if scanner.rest?
+        when '"'
+          rules.last << '"' << scanner.scan(/([^"\\]|\\.)*/)
+          # We don't want to enforce that strings are closed,
+          # but we do want to consume quotes or trailing backslashes.
+          rules.last << scanner.scan(/./) if scanner.rest?
+        end
+      end
+
+      rules.map! do |l|
+        Haml::Util.merge_adjacent_strings(l).reject {|r| r.is_a?(String) && r.empty?}
+      end
+
+      rules
+    end
   end
 end

data/vendor/plugins/haml/lib/sass/tree/variable_node.rb

@@ -0,0 +1,34 @@
+module Sass
+  module Tree
+    # A dynamic node representing a variable definition.
+    #
+    # @see Sass::Tree
+    class VariableNode < Node
+      # @param name [String] The name of the variable
+      # @param expr [Script::Node] The parse tree for the initial variable value
+      # @param guarded [Boolean] Whether this is a guarded variable assignment (`||=`)
+      def initialize(name, expr, guarded)
+        @name = name
+        @expr = expr
+        @guarded = guarded
+        super()
+      end
+
+      protected
+
+      # Loads the new variable value into the environment.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      def _perform(environment)
+        if @guarded && environment.var(@name).nil?
+          environment.set_var(@name, @expr.perform(environment))
+        elsif !@guarded
+          environment.set_var(@name, @expr.perform(environment))
+        end
+
+        []
+      end
+    end
+  end
+end

data/vendor/plugins/haml/lib/sass/tree/while_node.rb

@@ -0,0 +1,31 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@while` loop.
+  #
+  # @see Sass::Tree
+  class WhileNode < Node
+    # @param expr [Script::Node] The parse tree for the continue expression
+    def initialize(expr)
+      @expr = expr
+      super()
+    end
+
+    protected
+
+    # Runs the child nodes until the continue expression becomes false.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    # @return [Array<Tree::Node>] The resulting static nodes
+    # @see Sass::Tree
+    def _perform(environment)
+      children = []
+      new_environment = Sass::Environment.new(environment)
+      while @expr.perform(environment).to_bool
+        children += perform_children(new_environment)
+      end
+      children
+    end
+  end
+end