drnic-haml 2.3.0

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

@@ -0,0 +1,84 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # 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
+
+    # 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
+
+    # 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
+
+    # 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?
+      spaces = '  ' * (tabs - 1)
+
+      content = (value.split("\n") + lines.map {|l| l.text})
+      return spaces + "/* */" if content.empty?
+      content.map! {|l| (l.empty? ? "" : " ") + l}
+      content.first.gsub!(/^ /, '')
+      content.last.gsub!(%r{ ?\*/ *$}, '')
+
+      spaces + "/* " + content.join(style == :compact ? '' : "\n#{spaces} *") + " */"
+    end
+
+    # 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

@@ -0,0 +1,70 @@
+module Sass::Tree
+  # 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;
+  # it becomes an {ImportNode}.
+  #
+  # @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
+
+    protected
+
+    # 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
+                   "#{value}{"
+                 else
+                   "#{'  ' * (tabs - 1)}#{value} {" + (style == :compact ? ' ' : "\n")
+                 end
+        was_prop = false
+        first = true
+        children.each do |child|
+          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_prop
+                result[-1] = "\n"
+              end
+              rendered = child.to_s(tabs + 1)
+              rendered.lstrip! if first
+              result << rendered
+            end
+            was_prop = child.is_a?(PropNode)
+            first = false
+          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
+                          "}"
+                        else
+                          (style == :expanded ? "\n" : " ") + "}\n"
+                        end
+      end
+    end
+  end
+end

data/lib/sass/tree/for_node.rb

@@ -0,0 +1,48 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@for` loop.
+  #
+  # @see Sass::Tree
+  class ForNode < Node
+    # @param var [String] The name of the loop variable
+    # @param from [Script::Node] The parse tree for the initial expression
+    # @param to [Script::Node] The parse tree for the final expression
+    # @param exclusive [Boolean] Whether to include `to` in the loop
+    #   or stop just before
+    def initialize(var, from, to, exclusive)
+      @var = var
+      @from = from
+      @to = to
+      @exclusive = exclusive
+      super()
+    end
+
+    protected
+
+    # Runs the child nodes once for each time through the loop,
+    # varying the variable each time.
+    #
+    # @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)
+      from = @from.perform(environment)
+      to = @to.perform(environment)
+      from.assert_int!
+      to.assert_int!
+
+      to = to.coerce(from.numerator_units, from.denominator_units)
+      range = Range.new(from.to_i, to.to_i, @exclusive)
+
+      children = []
+      environment = Sass::Environment.new(environment)
+      range.each do |i|
+        environment.set_local_var(@var, Sass::Script::Number.new(i, from.numerator_units, from.denominator_units))
+        children += perform_children(environment)
+      end
+      children
+    end
+  end
+end

data/lib/sass/tree/if_node.rb

@@ -0,0 +1,54 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a Sass `@if` statement.
+  #
+  # {IfNode}s are a little odd, in that they also represent `@else` and `@else if`s.
+  # This is done as a linked list:
+  # each {IfNode} has a link (\{#else}) to the next {IfNode}.
+  #
+  # @see Sass::Tree
+  class IfNode < Node
+    # The next {IfNode} in the if-else list, or `nil`.
+    #
+    # @return [IfNode]
+    attr_accessor :else
+
+    # @param expr [Script::Expr] The conditional expression.
+    #   If this is nil, this is an `@else` node, not an `@else if`
+    def initialize(expr)
+      @expr = expr
+      @last_else = self
+      super()
+    end
+
+    # Append an `@else` node to the end of the list.
+    #
+    # @param node [IfNode] The `@else` node to append
+    def add_else(node)
+      @last_else.else = node
+      @last_else = node
+    end
+
+    def options=(options)
+      super
+      self.else.options = options if self.else
+    end
+
+    protected
+
+    # Runs the child nodes if the conditional expression is true;
+    # otherwise, tries the \{#else} nodes.
+    #
+    # @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)
+      environment = Sass::Environment.new(environment)
+      return perform_children(environment) if @expr.nil? || @expr.perform(environment).to_bool
+      return @else.perform(environment) if @else
+      []
+    end
+  end
+end

data/lib/sass/tree/import_node.rb

@@ -0,0 +1,69 @@
+module Sass
+  module Tree
+    # A static node that wraps the {Sass::Tree} for an `@import`ed file.
+    # It doesn't have a functional purpose other than to add the `@import`ed file
+    # to the backtrace if an error occurs.
+    class ImportNode < RootNode
+      # @param imported_filename [String] The name of the imported file
+      def initialize(imported_filename)
+        @imported_filename = imported_filename
+        super(nil)
+      end
+
+      def invisible?; to_s.empty?; end
+
+      protected
+
+      # Computes the CSS for the imported file.
+      #
+      # @param args [Array] Ignored
+      def _to_s(*args)
+        @to_s ||= (style == :compressed ? super.strip : super)
+      rescue Sass::SyntaxError => e
+        e.modify_backtrace(:filename => children.first.filename)
+        e.add_backtrace(:filename => @filename, :line => @line)
+        raise e
+      end
+
+      # Parses the imported file
+      # and runs the dynamic Sass for it.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      def perform!(environment)
+        return unless full_filename = import
+        root = Sass::Files.tree_for(full_filename, @options)
+        @template = root.template
+        self.children = root.children
+        self.children = perform_children(environment)
+      rescue Sass::SyntaxError => e
+        e.modify_backtrace(:filename => full_filename)
+        e.add_backtrace(:filename => @filename, :line => @line)
+        raise e
+      end
+
+      private
+
+      def import_paths
+        paths = (@options[:load_paths] || []).dup
+        paths.unshift(File.dirname(@options[:filename])) if @options[:filename]
+        paths
+      end
+
+      def import
+        begin
+          full_filename = Sass::Files.find_file_to_import(@imported_filename, import_paths)
+        rescue Exception => e
+          raise SyntaxError.new(e.message, :line => self.line, :filename => @filename)
+        end
+
+        if full_filename =~ /\.css$/
+          @to_s = "@import url(#{full_filename});"
+          return false
+        end
+
+        return full_filename
+      end
+    end
+  end
+end

data/lib/sass/tree/mixin_def_node.rb

@@ -0,0 +1,29 @@
+module Sass
+  module Tree
+    # A dynamic node representing a mixin definition.
+    #
+    # @see Sass::Tree
+    class MixinDefNode < Node
+      # @param name [String] The mixin name
+      # @param args [Array<(Script::Node, Script::Node)>] The arguments for the mixin.
+      #   Each element is a tuple containing the variable for argument
+      #   and the parse tree for the default value of the argument
+      def initialize(name, args)
+        @name = name
+        @args = args
+        super()
+      end
+
+      protected
+
+      # Loads the mixin into the environment.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      def _perform(environment)
+        environment.set_mixin(@name, Sass::Mixin.new(@name, @args, environment, children))
+        []
+      end
+    end
+  end
+end