drnic-haml 2.3.0

data/lib/sass/tree/mixin_node.rb

@@ -0,0 +1,48 @@
+require 'sass/tree/node'
+
+module Sass::Tree
+  # A dynamic node representing a mixin include.
+  #
+  # @see Sass::Tree
+  class MixinNode < Node
+    # @param name [String] The name of the mixin
+    # @param args [Array<Script::Node>] The arguments to the mixin
+    def initialize(name, args)
+      @name = name
+      @args = args
+      super()
+    end
+
+    protected
+
+    # Runs the mixin.
+    #
+    # @param environment [Sass::Environment] The lexical environment containing
+    #   variable and mixin values
+    # @return [Array<Tree::Node>] The resulting static nodes
+    # @raise [Sass::SyntaxError] if there is no mixin with the given name
+    # @raise [Sass::SyntaxError] if an incorrect number of arguments was passed
+    # @see Sass::Tree
+    def _perform(environment)
+      raise Sass::SyntaxError.new("Undefined mixin '#{@name}'.") unless mixin = environment.mixin(@name)
+
+      raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < @args.size
+Mixin #{@name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
+ but #{@args.size} #{@args.size == 1 ? 'was' : 'were'} passed.
+END
+
+      environment = mixin.args.zip(@args).
+        inject(Sass::Environment.new(mixin.environment)) do |env, ((var, default), value)|
+        env.set_local_var(var.name,
+          if value
+            value.perform(environment)
+          elsif default
+            default.perform(env)
+          end)
+        raise Sass::SyntaxError.new("Mixin #{@name} is missing parameter #{var.inspect}.") unless env.var(var.name)
+        env
+      end
+      mixin.tree.map {|c| c.perform(environment)}.flatten
+    end
+  end
+end

data/lib/sass/tree/node.rb

@@ -0,0 +1,252 @@
+module Sass
+  # A namespace for nodes in the Sass parse tree.
+  #
+  # The Sass parse tree has two states.
+  # When it's first parsed, it has nodes for mixin definitions
+  # and for loops and so forth,
+  # in addition to nodes for CSS rules and properties.
+  #
+  # However, {Tree::Node#perform} returns a different sort of tree.
+  # This tree maps more closely to the resulting CSS document
+  # than it does to the original Sass document.
+  # It still has nodes for CSS rules and properties,
+  # but it doesn't have any dynamic-generation-related nodes.
+  #
+  # Nodes that only appear in the pre-perform state are called **dynamic nodes**;
+  # those that appear in both states are called **static nodes**.
+  module Tree
+    # The abstract superclass of all parse-tree nodes.
+    class Node
+      # The child nodes of this node.
+      #
+      # @return [Array<Tree::Node>]
+      attr_accessor :children
+
+      # The line of the document on which this node appeared.
+      #
+      # @return [Fixnum]
+      attr_accessor :line
+
+      # The name of the document on which this node appeared.
+      #
+      # @return [String]
+      attr_writer :filename
+
+      # The options hash for the node.
+      # See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      #
+      # @return [Hash<Symbol, Object>]
+      attr_reader :options
+
+      def initialize
+        @children = []
+      end
+
+      # Sets the options hash for the node and all its children.
+      #
+      # @param options [Hash<Symbol, Object>] The options
+      # @see #options
+      def options=(options)
+        children.each {|c| c.options = options}
+        @options = options
+      end
+
+      # The name of the document on which this node appeared.
+      #
+      # @return [String]
+      def filename
+        @filename || @options[:filename]
+      end
+
+      # Appends a child to the node.
+      #
+      # @param child [Tree::Node] The child node
+      # @raise [Sass::SyntaxError] if `child` is invalid
+      # @see #invalid_child?
+      def <<(child)
+        if msg = invalid_child?(child)
+          raise Sass::SyntaxError.new(msg, :line => child.line)
+        end
+        @children << child
+      end
+
+      # Return the last child node.
+      #
+      # We need this because {Tree::Node} duck types as an Array for {Sass::Engine}.
+      #
+      # @return [Tree::Node] The last child node
+      def last
+        children.last
+      end
+
+      # Compares this node and another object (only other {Tree::Node}s will be equal).
+      # This does a structural comparison;
+      # if the contents of the nodes and all the child nodes are equivalent,
+      # then the nodes are as well.
+      #
+      # Only static nodes need to override this.
+      #
+      # @param other [Object] The object to compare with
+      # @return [Boolean] Whether or not this node and the other object
+      #   are the same
+      # @see Sass::Tree
+      def ==(other)
+        self.class == other.class && other.children == children
+      end
+
+      # Runs the dynamic Sass code *and* computes the CSS for the tree.
+      #
+      # @see #perform
+      # @see #to_s
+      def render
+        perform(Environment.new).to_s
+      end
+
+      # True if \{#to\_s} will return `nil`;
+      # that is, if the node shouldn't be rendered.
+      # Should only be called in a static tree.
+      #
+      # @return [Boolean]
+      def invisible?; false; end
+
+      # The output style. See {file:SASS_REFERENCE.md#sass_options the Sass options documentation}.
+      #
+      # @return [Symbol]
+      def style
+        @options[:style]
+      end
+
+      # Computes the CSS corresponding to this Sass tree.
+      #
+      # Only static-node subclasses need to implement \{#to\_s}.
+      #
+      # This may return `nil`, but it will only do so if \{#invisible?} is true.
+      #
+      # @param args [Array] Passed on to \{#\_to\_s}
+      # @return [String, nil] The resulting CSS
+      # @raise [Sass::SyntaxError] if some element of the tree is invalid
+      # @see Sass::Tree
+      def to_s(*args)
+        _to_s(*args)
+      rescue Sass::SyntaxError => e
+        e.modify_backtrace(:filename => filename, :line => line)
+        raise e
+      end
+
+      # Runs the dynamic Sass code:
+      # mixins, variables, control directives, and so forth.
+      # This doesn't modify this node or any of its children.
+      #
+      # \{#perform} shouldn't be overridden directly;
+      # if you want to return a new node (or list of nodes),
+      # override \{#\_perform};
+      # if you want to destructively modify this node,
+      # override \{#perform!}.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @return [Tree::Node] The resulting tree of static nodes
+      # @raise [Sass::SyntaxError] if some element of the tree is invalid
+      # @see Sass::Tree
+      def perform(environment)
+        environment.options = @options if self.class == Tree::Node
+        _perform(environment)
+      rescue Sass::SyntaxError => e
+        e.modify_backtrace(:filename => filename, :line => line)
+        raise e
+      end
+
+      protected
+
+      # Computes the CSS corresponding to this particular Sass node.
+      #
+      # @param args [Array] ignored
+      # @return [String, nil] The resulting CSS
+      # @raise [Sass::SyntaxError] if some element of the tree is invalid
+      # @see #to_s
+      # @see Sass::Tree
+      def _to_s
+        raise NotImplementedError.new("All static-node subclasses of Sass::Tree::Node must override #_to_s or #to_s.")
+      end
+
+      # Runs any dynamic Sass code in this particular node.
+      # This doesn't modify this node or any of its children.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @return [Tree::Node, Array<Tree::Node>] The resulting static nodes
+      # @see #perform
+      # @see Sass::Tree
+      def _perform(environment)
+        node = dup
+        node.perform!(environment)
+        node
+      end
+
+      # Destructively runs dynamic Sass code in this particular node.
+      # This *does* modify this node,
+      # but will be run non-destructively by \{#\_perform\}.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @see #perform
+      def perform!(environment)
+        self.children = perform_children(Environment.new(environment))
+      end
+
+      # Non-destructively runs \{#perform} on all children of the current node.
+      #
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @return [Array<Tree::Node>] The resulting static nodes
+      def perform_children(environment)
+        children.map {|c| c.perform(environment)}.flatten
+      end
+
+      # Replaces SassScript in a chunk of text (via `#{}`)
+      # with the resulting value.
+      #
+      # @param text [String] The text to interpolate
+      # @param environment [Sass::Environment] The lexical environment containing
+      #   variable and mixin values
+      # @return [String] The interpolated text
+      def interpolate(text, environment)
+        res = ''
+        rest = Haml::Shared.handle_interpolation text do |scan|
+          escapes = scan[2].size
+          res << scan.matched[0...-2 - escapes]
+          if escapes % 2 == 1
+            res << "\\" * (escapes - 1) << '#{'
+          else
+            res << "\\" * [0, escapes - 1].max
+            res << Script::Parser.new(scan, line, scan.pos - scan.matched_size, filename).
+              parse_interpolated.perform(environment).to_s
+          end
+        end
+        res + rest
+      end
+
+      # @see Haml::Shared.balance
+      # @raise [Sass::SyntaxError] if the brackets aren't balanced
+      def balance(*args)
+        res = Haml::Shared.balance(*args)
+        return res if res
+        raise Sass::SyntaxError.new("Unbalanced brackets.", :line => line)
+      end
+
+      # Returns an error message if the given child node is invalid,
+      # and false otherwise.
+      #
+      # By default, all child nodes are valid.
+      # This is expected to be overriden by subclasses
+      # for which some children are invalid.
+      #
+      # @param child [Tree::Node] A potential child node
+      # @return [Boolean, String] Whether or not the child node is valid,
+      #   as well as the error message to display if it is invalid
+      def invalid_child?(child)
+        false
+      end
+    end
+  end
+end

data/lib/sass/tree/prop_node.rb

@@ -0,0 +1,106 @@
+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
+
+    protected
+
+    # 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.")
+      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.")
+      elsif value[-1] == ?;
+        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no \";\" required at end-of-line).")
+      elsif value.empty? && children.empty?
+        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no value).")
+      end
+
+      real_name = name
+      real_name = "#{parent_name}-#{real_name}" if parent_name
+
+      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
+
+    # 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}"
+    end
+  end
+end

data/lib/sass/tree/root_node.rb

@@ -0,0 +1,56 @@
+module Sass
+  module Tree
+    # A static node that is the root node of the Sass document.
+    class RootNode < Node
+      # The Sass template from which this node was created
+      #
+      # @param template [String]
+      attr_reader :template
+
+      # @param template [String] The Sass template from which this node was created
+      def initialize(template)
+        super()
+        @template = template
+      end
+
+      # @see \{Node#to\_s}
+      def to_s(*args)
+        super
+      rescue Sass::SyntaxError => e
+        e.sass_template = @template
+        raise e
+      end
+
+      # @see \{Node#perform}
+      def perform(*args)
+        super
+      rescue Sass::SyntaxError => e
+        e.sass_template = @template
+        raise e
+      end
+
+      protected
+
+      # Computes the CSS corresponding to this Sass tree.
+      #
+      # @param args [Array] ignored
+      # @return [String] The resulting CSS
+      # @raise [Sass::SyntaxError] if some element of the tree is invalid
+      # @see Sass::Tree
+      def _to_s(*args)
+        result = String.new
+        children.each do |child|
+          raise Sass::SyntaxError.new('Properties aren\'t allowed at the root of a document.',
+            :line => child.line) if child.is_a? PropNode
+
+          next if child.invisible?
+          child_str = child.to_s(1)
+          result << child_str + (style == :compressed ? '' : "\n")
+        end
+        result.rstrip!
+        return "" if result.empty?
+        return result + "\n"
+      end
+    end
+  end
+end