haml 3.2.0.alpha.10 → 3.2.0.alpha.13

data/vendor/sass/lib/sass/tree/function_node.rb

@@ -1,27 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing a function definition.
-    #
-    # @see Sass::Tree
-    class FunctionNode < Node
-      # The name of the function.
-      # @return [String]
-      attr_reader :name
-
-      # The arguments to the function. Each element is a tuple
-      # containing the variable for argument and the parse tree for
-      # the default value of the argument
-      #
-      # @return [Array<Script::Node>]
-      attr_accessor :args
-
-      # @param name [String] The function name
-      # @param args [Array<(Script::Node, Script::Node)>] The arguments for the function.
-      def initialize(name, args)
-        @name = name
-        @args = args
-        super()
-      end
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/if_node.rb

@@ -1,52 +0,0 @@
-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 conditional expression.
-    # If this is nil, this is an `@else` node, not an `@else if`.
-    #
-    # @return [Script::Expr]
-    attr_accessor :expr
-
-    # The next {IfNode} in the if-else list, or `nil`.
-    #
-    # @return [IfNode]
-    attr_accessor :else
-
-    # @param expr [Script::Expr] See \{#expr}
-    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 _dump(f)
-      Marshal.dump([self.expr, self.else, self.children])
-    end
-
-    def self._load(data)
-      expr, else_, children = Marshal.load(data)
-      node = IfNode.new(expr)
-      node.else = else_
-      node.children = children
-      node.instance_variable_set('@last_else',
-        node.else ? node.else.instance_variable_get('@last_else') : node)
-      node
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/import_node.rb

@@ -1,68 +0,0 @@
-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
-      # The name of the imported file as it appears in the Sass document.
-      #
-      # @return [String]
-      attr_reader :imported_filename
-
-      # @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
-
-      # Returns the imported file.
-      #
-      # @return [Sass::Engine]
-      # @raise [Sass::SyntaxError] If no file could be found to import.
-      def imported_file
-        @imported_file ||= import
-      end
-
-      # Returns whether or not this import should emit a CSS @import declaration
-      #
-      # @return [Boolean] Whether or not this is a simple CSS @import declaration.
-      def css_import?
-        if @imported_filename =~ /\.css$/
-          @imported_filename
-        elsif imported_file.is_a?(String) && imported_file =~ /\.css$/
-          imported_file
-        end
-      end
-
-      private
-
-      def import
-        paths = @options[:load_paths]
-
-        if @options[:importer]
-          f = @options[:importer].find_relative(
-            @imported_filename, @options[:filename], @options.dup)
-          return f if f
-        end
-
-        paths.each do |p|
-          if f = p.find(@imported_filename, @options.dup)
-            return f
-          end
-        end
-
-        message = "File to import not found or unreadable: #{@imported_filename}.\n"
-        if paths.size == 1
-          message << "Load path: #{paths.first}"
-        else
-          message << "Load paths:\n  " << paths.join("\n  ")
-        end
-        raise SyntaxError.new(message)
-      rescue SyntaxError => e
-        raise SyntaxError.new(e.message, :line => self.line, :filename => @filename)
-      end
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/media_node.rb

@@ -1,32 +0,0 @@
-module Sass::Tree
-  # A static node representing a `@media` rule.
-  # `@media` rules behave differently from other directives
-  # in that when they're nested within rules,
-  # they bubble up to top-level.
-  #
-  # @see Sass::Tree
-  class MediaNode < DirectiveNode
-    # The media query (e.g. `print` or `screen`).
-    #
-    # @return [String]
-    attr_accessor :query
-
-    # @see RuleNode#tabs
-    attr_accessor :tabs
-
-    # @see RuleNode#group_end
-    attr_accessor :group_end
-
-    # @param query [String] See \{#query}
-    def initialize(query)
-      @query = query
-      @tabs = 0
-      super('')
-    end
-
-    # @see DirectiveNode#value
-    def value
-      "@media #{query}"
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/mixin_def_node.rb

@@ -1,27 +0,0 @@
-module Sass
-  module Tree
-    # A dynamic node representing a mixin definition.
-    #
-    # @see Sass::Tree
-    class MixinDefNode < Node
-      # The mixin name.
-      # @return [String]
-      attr_reader :name
-
-      # 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.
-      #
-      # @return [Array<(Script::Node, Script::Node)>]
-      attr_accessor :args
-
-      # @param name [String] The mixin name
-      # @param args [Array<(Script::Node, Script::Node)>] See \{#args}
-      def initialize(name, args)
-        @name = name
-        @args = args
-        super()
-      end
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/mixin_node.rb

@@ -1,32 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A static node representing a mixin include.
-  # When in a static tree, the sole purpose is to wrap exceptions
-  # to add the mixin to the backtrace.
-  #
-  # @see Sass::Tree
-  class MixinNode < Node
-    # The name of the mixin.
-    # @return [String]
-    attr_reader :name
-
-    # The arguments to the mixin.
-    # @return [Array<Script::Node>]
-    attr_accessor :args
-
-    # A hash from keyword argument names to values.
-    # @return [{String => Script::Node}]
-    attr_accessor :keywords
-
-    # @param name [String] The name of the mixin
-    # @param args [Array<Script::Node>] See \{#args}
-    # @param keywords [{String => Script::Node}] See \{#keywords}
-    def initialize(name, args, keywords)
-      @name = name
-      @args = args
-      @keywords = keywords
-      super()
-    end
-  end
-end

data/vendor/sass/lib/sass/tree/node.rb

@@ -1,201 +0,0 @@
-module Sass
-  # A namespace for nodes in the Sass parse tree.
-  #
-  # The Sass parse tree has three states: dynamic, static Sass, and static CSS.
-  #
-  # When it's first parsed, a Sass document is in the dynamic state.
-  # It has nodes for mixin definitions and `@for` loops and so forth,
-  # in addition to nodes for CSS rules and properties.
-  # Nodes that only appear in this state are called **dynamic nodes**.
-  #
-  # {Tree::Visitors::Perform} creates a static Sass tree, which is different.
-  # It still has nodes for CSS rules and properties
-  # but it doesn't have any dynamic-generation-related nodes.
-  # The nodes in this state are in the same structure as the Sass document:
-  # rules and properties are nested beneath one another.
-  # Nodes that can be in this state or in the dynamic state
-  # are called **static nodes**.
-  #
-  # {Tree::Visitors::Cssize} is then used to create a static CSS tree.
-  # This is like a static Sass tree,
-  # but the structure exactly mirrors that of the generated CSS.
-  # Rules and properties can't be nested beneath one another in this state.
-  #
-  # Finally, {Tree::Visitors::ToCss} can be called on a static CSS tree
-  # to get the actual CSS code as a string.
-  module Tree
-    # The abstract superclass of all parse-tree nodes.
-    class Node
-      include Enumerable
-
-      # The child nodes of this node.
-      #
-      # @return [Array<Tree::Node>]
-      attr_accessor :children
-
-      # Whether or not this node has child nodes.
-      # This may be true even when \{#children} is empty,
-      # in which case this node has an empty block (e.g. `{}`).
-      #
-      # @return [Boolean]
-      attr_accessor :has_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 [{Symbol => Object}]
-      attr_reader :options
-
-      def initialize
-        @children = []
-      end
-
-      # Sets the options hash for the node and all its children.
-      #
-      # @param options [{Symbol => Object}] The options
-      # @see #options
-      def options=(options)
-        Sass::Tree::Visitors::SetOptions.visit(self, options)
-      end
-
-      # @private
-      def children=(children)
-        self.has_children ||= !children.empty?
-        @children = children
-      end
-
-      # The name of the document on which this node appeared.
-      #
-      # @return [String]
-      def filename
-        @filename || (@options && @options[:filename])
-      end
-
-      # Appends a child to the node.
-      #
-      # @param child [Tree::Node, Array<Tree::Node>] The child node or nodes
-      # @raise [Sass::SyntaxError] if `child` is invalid
-      def <<(child)
-        return if child.nil?
-        if child.is_a?(Array)
-          child.each {|c| self << c}
-        else
-          self.has_children = true
-          @children << child
-        end
-      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
-
-      # 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 static CSS tree.
-      #
-      # @return [String, nil] The resulting CSS
-      # @see Sass::Tree
-      def to_s
-        Sass::Tree::Visitors::ToCss.visit(self)
-      end
-
-      # Converts a static CSS tree (e.g. the output of \{Tree::Visitors::Cssize})
-      # into another static CSS tree,
-      # with the given extensions applied to all relevant {RuleNode}s.
-      #
-      # @todo Link this to the reference documentation on `@extend`
-      #   when such a thing exists.
-      #
-      # @param extends [Sass::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
-      #   The extensions to perform on this tree
-      # @return [Tree::Node] The resulting tree of static CSS nodes.
-      # @raise [Sass::SyntaxError] Only if there's a programmer error
-      #   and this is not a static CSS tree
-      def do_extend(extends)
-        node = dup
-        node.children = children.map {|c| c.do_extend(extends)}
-        node
-      rescue Sass::SyntaxError => e
-        e.modify_backtrace(:filename => filename, :line => line)
-        raise e
-      end
-
-      # Iterates through each node in the tree rooted at this node
-      # in a pre-order walk.
-      #
-      # @yield node
-      # @yieldparam node [Node] a node in the tree
-      def each(&block)
-        yield self
-        children.each {|c| c.each(&block)}
-      end
-
-      # Converts a node to Sass code that will generate it.
-      #
-      # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
-      # @return [String] The Sass code corresponding to the node
-      def to_sass(options = {})
-        Sass::Tree::Visitors::Convert.visit(self, options, :sass)
-      end
-
-      # Converts a node to SCSS code that will generate it.
-      #
-      # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize})
-      # @return [String] The Sass code corresponding to the node
-      def to_scss(options = {})
-        Sass::Tree::Visitors::Convert.visit(self, options, :scss)
-      end
-
-      # Return a deep clone of this node.
-      # The child nodes are cloned, but options are not.
-      #
-      # @return [Node]
-      def deep_copy
-        Sass::Tree::Visitors::DeepCopy.visit(self)
-      end
-
-      protected
-
-      # @see Sass::Shared.balance
-      # @raise [Sass::SyntaxError] if the brackets aren't balanced
-      def balance(*args)
-        res = Sass::Shared.balance(*args)
-        return res if res
-        raise Sass::SyntaxError.new("Unbalanced brackets.", :line => line)
-      end
-    end
-  end
-end

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

@@ -1,148 +0,0 @@
-module Sass::Tree
-  # A static node reprenting a CSS property.
-  #
-  # @see Sass::Tree
-  class PropNode < Node
-    # The name of the property,
-    # interspersed with {Sass::Script::Node}s
-    # representing `#{}`-interpolation.
-    # Any adjacent strings will be merged together.
-    #
-    # @return [Array<String, Sass::Script::Node>]
-    attr_accessor :name
-
-    # The name of the property
-    # after any interpolated SassScript has been resolved.
-    # Only set once \{Tree::Visitors::Perform} has been run.
-    #
-    # @return [String]
-    attr_accessor :resolved_name
-
-    # The value of the property.
-    #
-    # @return [Sass::Script::Node]
-    attr_accessor :value
-
-    # The value of the property
-    # after any interpolated SassScript has been resolved.
-    # Only set once \{Tree::Visitors::Perform} has been run.
-    #
-    # @return [String]
-    attr_accessor :resolved_value
-
-    # How deep this property is indented
-    # relative to a normal property.
-    # This is only greater than 0 in the case that:
-    #
-    # * This node is in a CSS tree
-    # * The style is :nested
-    # * This is a child property of another property
-    # * The parent property has a value, and thus will be rendered
-    #
-    # @return [Fixnum]
-    attr_accessor :tabs
-
-    # @param name [Array<String, Sass::Script::Node>] See \{#name}
-    # @param value [Sass::Script::Node] 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 = Sass::Util.strip_string_array(
-        Sass::Util.merge_adjacent_strings(name))
-      @value = value
-      @tabs = 0
-      @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
-
-    # 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.is_a?(Sass::Script::String) || !value.value.empty?
-      "\nIf #{declaration.dump} should be a selector, use \"\\#{declaration}\" instead."
-    end
-
-    # Computes the Sass or SCSS code for the variable declaration.
-    # This is like \{#to\_scss} or \{#to\_sass},
-    # except it doesn't print any child properties or a trailing semicolon.
-    #
-    # @param opts [{Symbol => Object}] The options hash for the tree.
-    # @param fmt [Symbol] `:scss` or `:sass`.
-    def declaration(opts = {:old => @prop_syntax == :old}, fmt = :sass)
-      name = self.name.map {|n| n.is_a?(String) ? n : "\#{#{n.to_sass(opts)}}"}.join
-      if name[0] == ?:
-        raise Sass::SyntaxError.new("The \"#{name}: #{self.class.val_to_sass(value, opts)}\" hack is not allowed in the Sass indented syntax")
-      end
-
-      old = opts[:old] && fmt == :sass
-      initial = old ? ':' : ''
-      mid = old ? '' : ':'
-      "#{initial}#{name}#{mid} #{self.class.val_to_sass(value, opts)}".rstrip
-    end
-
-    private
-
-    def check!
-      if @options[:property_syntax] && @options[:property_syntax] != @prop_syntax
-        raise Sass::SyntaxError.new(
-          "Illegal property syntax: can't use #{@prop_syntax} syntax when :property_syntax => #{@options[:property_syntax].inspect} is set.")
-      elsif resolved_value.empty?
-        raise Sass::SyntaxError.new("Invalid property: #{declaration.dump} (no value)." +
-          pseudo_class_selector_message)
-      end
-    end
-
-    class << self
-      # @private
-      def val_to_sass(value, opts)
-        val_to_sass_comma(value, opts).to_sass(opts)
-      end
-
-      private
-
-      def val_to_sass_comma(node, opts)
-        return node unless node.is_a?(Sass::Script::Operation)
-        return val_to_sass_concat(node, opts) unless node.operator == :comma
-
-        Sass::Script::Operation.new(
-          val_to_sass_concat(node.operand1, opts),
-          val_to_sass_comma(node.operand2, opts),
-          node.operator)
-      end
-
-      def val_to_sass_concat(node, opts)
-        return node unless node.is_a?(Sass::Script::Operation)
-        return val_to_sass_div(node, opts) unless node.operator == :space
-
-        Sass::Script::Operation.new(
-          val_to_sass_div(node.operand1, opts),
-          val_to_sass_concat(node.operand2, opts),
-          node.operator)
-      end
-
-      def val_to_sass_div(node, opts)
-        unless node.is_a?(Sass::Script::Operation) && node.operator == :div &&
-            node.operand1.is_a?(Sass::Script::Number) &&
-            node.operand2.is_a?(Sass::Script::Number) &&
-            (!node.operand1.original || !node.operand2.original)
-          return node
-        end
-
-        Sass::Script::String.new("(#{node.to_sass(opts)})")
-      end
-
-    end
-  end
-end