haml 2.0.10 → 2.2.0

data/lib/sass/script/operation.rb

@@ -0,0 +1,45 @@
+require 'set'
+require 'sass/script/string'
+require 'sass/script/number'
+require 'sass/script/color'
+require 'sass/script/functions'
+require 'sass/script/unary_operation'
+
+module Sass::Script
+  # A SassScript parse node representing a binary operation,
+  # such as `!a + !b` or `"foo" + 1`.
+  class Operation < Node
+    # @param operand1 [Script::Node] The parse-tree node
+    #   for the right-hand side of the operator
+    # @param operand2 [Script::Node] The parse-tree node
+    #   for the left-hand side of the operator
+    # @param operator [Symbol] The operator to perform.
+    #   This should be one of the binary operator names in {Lexer::OPERATORS}
+    def initialize(operand1, operand2, operator)
+      @operand1 = operand1
+      @operand2 = operand2
+      @operator = operator
+    end
+
+    # @return [String] A human-readable s-expression representation of the operation
+    def inspect
+      "(#{@operator.inspect} #{@operand1.inspect} #{@operand2.inspect})"
+    end
+
+    # Evaluates the operation.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Literal] The SassScript object that is the value of the operation
+    # @raise [Sass::SyntaxError] if the operation is undefined for the operands
+    def perform(environment)
+      literal1 = @operand1.perform(environment)
+      literal2 = @operand2.perform(environment)
+      begin
+        literal1.send(@operator, literal2)
+      rescue NoMethodError => e
+        raise e unless e.name.to_s == @operator.to_s
+        raise Sass::SyntaxError.new("Undefined operation: \"#{literal1} #{@operator} #{literal2}\".")
+      end
+    end
+  end
+end

data/lib/sass/script/parser.rb

@@ -0,0 +1,172 @@
+require 'sass/script/lexer'
+
+module Sass
+  module Script
+    # The parser for SassScript.
+    # It parses a string of code into a tree of {Script::Node}s.
+    class Parser
+      # @param str [String, StringScanner] The source text to parse
+      # @param line [Fixnum] The line on which the SassScript appears.
+      #   Used for error reporting
+      # @param offset [Fixnum] The number of characters in on which the SassScript appears.
+      #   Used for error reporting
+      # @param filename [String] The name of the file in which the SassScript appears.
+      #   Used for error reporting
+      def initialize(str, line, offset, filename = nil)
+        @filename = filename
+        @lexer = Lexer.new(str, line, offset)
+      end
+
+      # Parses a SassScript expression within an interpolated segment (`#{}`).
+      # This means that it stops when it comes across an unmatched `}`,
+      # which signals the end of an interpolated segment,
+      # it returns rather than throwing an error.
+      #
+      # @return [Script::Node] The root node of the parse tree
+      # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
+      def parse_interpolated
+        expr = assert_expr :expr
+        assert_tok :end_interpolation
+        expr
+      end
+
+      # Parses a SassScript expression.
+      #
+      # @return [Script::Node] The root node of the parse tree
+      # @raise [Sass::SyntaxError] if the expression isn't valid SassScript
+      def parse
+        expr = assert_expr :expr
+        raise Sass::SyntaxError.new("Unexpected #{@lexer.peek.type} token.") unless @lexer.done?
+        expr
+      end
+
+      # Parses a SassScript expression.
+      #
+      # @overload parse(str, line, offset, filename = nil)
+      # @return [Script::Node] The root node of the parse tree
+      # @see Parser#initialize
+      # @see Parser#parse
+      def self.parse(*args)
+        new(*args).parse
+      end
+
+      class << self
+        private
+
+        # Defines a simple left-associative production.
+        # name is the name of the production,
+        # sub is the name of the production beneath it,
+        # and ops is a list of operators for this precedence level
+        def production(name, sub, *ops)
+          class_eval <<RUBY
+            def #{name}
+              return unless e = #{sub}
+              while tok = try_tok(#{ops.map {|o| o.inspect}.join(', ')})
+                e = Operation.new(e, assert_expr(#{sub.inspect}), tok.type)
+              end
+              e
+            end
+RUBY
+        end
+
+        def unary(op, sub)
+          class_eval <<RUBY
+            def unary_#{op}
+              return #{sub} unless try_tok(:#{op})
+              UnaryOperation.new(assert_expr(:unary_#{op}), :#{op})
+            end
+RUBY
+        end
+      end
+
+      private
+
+      production :expr, :concat, :comma
+
+      def concat
+        return unless e = or_expr
+        while sub = or_expr
+          e = Operation.new(e, sub, :concat)
+        end
+        e
+      end
+
+      production :or_expr, :and_expr, :or
+      production :and_expr, :eq_or_neq, :and
+      production :eq_or_neq, :relational, :eq, :neq
+      production :relational, :plus_or_minus, :gt, :gte, :lt, :lte
+      production :plus_or_minus, :times_div_or_mod, :plus, :minus
+      production :times_div_or_mod, :unary_minus, :times, :div, :mod
+
+      unary :minus, :unary_div
+      unary :div, :unary_not # For strings, so /foo/bar works
+      unary :not, :funcall
+
+      def funcall
+        return paren unless name = try_tok(:ident)
+        # An identifier without arguments is just a string
+        unless try_tok(:lparen)
+          warn(<<END)
+DEPRECATION WARNING:
+On line #{name.line}, character #{name.offset}#{" of '#{@filename}'" if @filename}
+Implicit strings have been deprecated and will be removed in version 2.4.
+'#{name.value}' was not quoted. Please add double quotes (e.g. "#{name.value}").
+END
+          Script::String.new(name.value)
+        else
+          args = arglist || []
+          assert_tok(:rparen)
+          Script::Funcall.new(name.value, args)
+        end
+      end
+
+      def arglist
+        return unless e = concat
+        return [e] unless try_tok(:comma)
+        [e, *arglist]
+      end
+
+      def paren
+        return variable unless try_tok(:lparen)
+        e = assert_expr(:expr)
+        assert_tok(:rparen)
+        return e
+      end
+
+      def variable
+        return string unless c = try_tok(:const)
+        Variable.new(c.value)
+      end
+
+      def string
+        return literal unless first = try_tok(:string)
+        return first.value unless try_tok(:begin_interpolation)
+        mid = parse_interpolated
+        last = assert_expr(:string)
+        Operation.new(first.value, Operation.new(mid, last, :plus), :plus)
+      end
+
+      def literal
+        (t = try_tok(:number, :color, :bool)) && (return t.value)
+      end
+
+      # It would be possible to have unified #assert and #try methods,
+      # but detecting the method/token difference turns out to be quite expensive.
+
+      def assert_expr(name)
+        (e = send(name)) && (return e)
+        raise Sass::SyntaxError.new("Expected expression, was #{@lexer.done? ? 'end of text' : "#{@lexer.peek.type} token"}.")
+      end
+
+      def assert_tok(*names)
+        (t = try_tok(*names)) && (return t)
+        raise Sass::SyntaxError.new("Expected #{names.join(' or ')} token, was #{@lexer.done? ? 'end of text' : "#{@lexer.peek.type} token"}.")
+      end
+
+      def try_tok(*names)
+        peeked =  @lexer.peek
+        peeked && names.include?(peeked.type) && @lexer.next
+      end
+    end
+  end
+end

data/lib/sass/script/string.rb

@@ -0,0 +1,12 @@
+require 'sass/script/literal'
+
+module Sass::Script
+  # A SassScript object representing a string of text.
+  class String < Literal
+    # The Ruby value of the string.
+    #
+    # @return [String]
+    attr_reader :value
+    alias_method :to_s, :value
+  end
+end

data/lib/sass/script/unary_operation.rb

@@ -0,0 +1,34 @@
+module Sass::Script
+  # A SassScript parse node representing a unary operation,
+  # such as `-!b` or `not true`.
+  #
+  # Currently only `-`, `/`, and `not` are unary operators.
+  class UnaryOperation < Node
+    # @param operand [Script::Node] The parse-tree node
+    #   for the object of the operator
+    # @param operator [Symbol] The operator to perform
+    def initialize(operand, operator)
+      @operand = operand
+      @operator = operator
+    end
+
+    # @return [String] A human-readable s-expression representation of the operation
+    def inspect
+      "(#{@operator.inspect} #{@operand.inspect})"
+    end
+
+    # Evaluates the operation.
+    #
+    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+    # @return [Literal] The SassScript object that is the value of the operation
+    # @raise [Sass::SyntaxError] if the operation is undefined for the operand
+    def perform(environment)
+      operator = "unary_#{@operator}"
+      literal = @operand.perform(environment)
+      literal.send(operator)
+    rescue NoMethodError => e
+      raise e unless e.name.to_s == operator.to_s
+      raise Sass::SyntaxError.new("Undefined unary operation: \"#{@operator} #{literal}\".")
+    end
+  end
+end

data/lib/sass/script/variable.rb

@@ -0,0 +1,31 @@
+module Sass
+  module Script
+    # A SassScript parse node representing a variable.
+    class Variable < Node
+      # The name of the variable.
+      #
+      # @return [String]
+      attr_reader :name
+
+      # @param name [String] See \{#name}
+      def initialize(name)
+        @name = name
+      end
+
+      # @return [String] A string representation of the variable
+      def inspect
+        "!#{name}"
+      end
+
+      # Evaluates the variable.
+      #
+      # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
+      # @return [Literal] The SassScript object that is the value of the variable
+      # @raise [Sass::SyntaxError] if the variable is undefined
+      def perform(environment)
+        (val = environment.var(name)) && (return val)
+        raise SyntaxError.new("Undefined variable: \"!#{name}\".")
+      end
+    end
+  end
+end

data/lib/sass/tree/comment_node.rb

@@ -1,20 +1,83 @@
 require 'sass/tree/node'
 
 module Sass::Tree
-  class CommentNode < ValueNode
-    def initialize(value, style)
-      super(value[2..-1].strip, style)
+  # A static node representing a Sass comment (silent or loud).
+  #
+  # @see Sass::Tree
+  class CommentNode < Node
+    # The lines of text nested beneath the comment.
+    #
+    # @return [Array<Sass::Engine::Line>]
+    attr_accessor :lines
+
+    # The text on the same line as the comment starter.
+    #
+    # @return [String]
+    attr_accessor :value
+
+    # Whether or not the comment is silent (that is, doesn't output to CSS).
+    #
+    # @return [Boolean]
+    attr_accessor :silent
+
+    # @param value [String] See \{#value}
+    # @param silent [Boolean] See \{#silent}
+    def initialize(value, silent)
+      @lines = []
+      @value = value[2..-1].strip
+      @silent = silent
+      super()
     end
 
-    def to_s(tabs = 0, parent_name = nil)
-      return if @style == :compressed
+    # Compares the contents of two comments.
+    #
+    # @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 && value == other.value && silent == other.silent && lines == other.lines
+    end
+
+    # Computes the CSS for the comment.
+    #
+    # Returns `nil` if this is a silent comment
+    # or the current style doesn't render comments.
+    #
+    # @overload to_s(tabs = 0)
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @return [String, nil] The resulting CSS
+    # @see #invisible?
+    def to_s(tabs = 0, _ = nil)
+      return if invisible?
+
+      content = (value.split("\n") + lines.map {|l| l.text})
+      content.map! {|l| (l.empty? ? "" : " ") + l}
+      content.first.gsub!(/^ /, '')
+      content.last.gsub!(%r{ ?\*/ *$}, '')
 
       spaces = '  ' * (tabs - 1)
-      join_string = @style == :compact ? ' ' : "\n#{spaces} * "
-      str = "#{spaces}/* #{value}"
-      str << join_string unless children.empty?
-      str << "#{children.join join_string} */"
-      str
+      spaces + "/* " + content.join(style == :compact ? '' : "\n#{spaces} *") + " */"
+    end
+
+    # Returns `true` if this is a silent comment
+    # or the current style doesn't render comments.
+    #
+    # @return [Boolean]
+    def invisible?
+      style == :compressed || @silent
+    end
+
+    protected
+
+    # Removes this node from the tree if it's a silent comment.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    # @return [Tree::Node, Array<Tree::Node>] The resulting static nodes
+    # @see Sass::Tree
+    def _perform(environment)
+      return [] if @silent
+      self
     end
   end
 end

data/lib/sass/tree/debug_node.rb

@@ -0,0 +1,30 @@
+module Sass
+  module Tree
+    # A dynamic node representing a Sass `@debug` statement.
+    #
+    # @see Sass::Tree
+    class DebugNode < Node
+      # @param expr [Script::Node] The expression to print
+      def initialize(expr)
+        @expr = expr
+        super()
+      end
+
+      protected
+
+      # Prints the expression to STDERR.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      def _perform(environment)
+        res = @expr.perform(environment)
+        if filename
+          STDERR.puts "#{filename}:#{line} DEBUG: #{res}"
+        else
+          STDERR.puts "Line #{line} DEBUG: #{res}"
+        end
+        []
+      end
+    end
+  end
+end

data/lib/sass/tree/directive_node.rb

@@ -1,44 +1,69 @@
-require 'sass/tree/node'
-require 'sass/tree/value_node'
-
 module Sass::Tree
-  class DirectiveNode < ValueNode
+  # A static node representing an unproccessed Sass `@`-directive.
+  # Directives known to Sass, like `@for` and `@debug`,
+  # are handled by their own nodes;
+  # only CSS directives like `@media` and `@font-face` become {DirectiveNode}s.
+  #
+  # `@import` is a bit of a weird case;
+  # if it's importing a Sass file,
+  # it becomes a {FileNode},
+  # but if it's importing a plain CSS file,
+  # it becomes a {DirectiveNode}.
+  #
+  # @see Sass::Tree
+  class DirectiveNode < Node
+    # The text of the directive, `@` and all.
+    #
+    # @return [String]
+    attr_accessor :value
+
+    # @param value [String] See \{#value}
+    def initialize(value)
+      @value = value
+      super()
+    end
+
+    # Computes the CSS for the directive.
+    #
+    # @param tabs [Fixnum] The level of indentation for the CSS
+    # @return [String] The resulting CSS
     def to_s(tabs)
       if children.empty?
         value + ";"
       else
-        result = if @style == :compressed
+        result = if style == :compressed
                    "#{value}{"
                  else
-                   "#{'  ' * (tabs - 1)}#{value} {" + (@style == :compact ? ' ' : "\n")
+                   "#{'  ' * (tabs - 1)}#{value} {" + (style == :compact ? ' ' : "\n")
                  end
-        was_attr = false
+        was_prop = false
         first = true
         children.each do |child|
-          if @style == :compact
-            if child.is_a?(AttrNode)
-              result << "#{child.to_s(first || was_attr ? 1 : tabs + 1)} "
+          next if child.invisible?
+          if style == :compact
+            if child.is_a?(PropNode)
+              result << "#{child.to_s(first || was_prop ? 1 : tabs + 1)} "
             else
-              if was_attr
+              if was_prop
                 result[-1] = "\n"
               end
               rendered = child.to_s(tabs + 1)
               rendered.lstrip! if first
               result << rendered
             end
-            was_attr = child.is_a?(AttrNode)
+            was_prop = child.is_a?(PropNode)
             first = false
-          elsif @style == :compressed
-            result << (was_attr ? ";#{child.to_s(1)}" : child.to_s(1))
-            was_attr = child.is_a?(AttrNode)
+          elsif style == :compressed
+            result << (was_prop ? ";#{child.to_s(1)}" : child.to_s(1))
+            was_prop = child.is_a?(PropNode)
           else
             result << child.to_s(tabs + 1) + "\n"
           end
         end
-        result.rstrip + if @style == :compressed
+        result.rstrip + if style == :compressed
                           "}"
                         else
-                          (@style == :expanded ? "\n" : " ") + "}\n"
+                          (style == :expanded ? "\n" : " ") + "}\n"
                         end
       end
     end