haml 3.0.25 → 3.1.0.alpha.2

data/lib/sass/selector/simple_sequence.rb

@@ -1,136 +0,0 @@
-module Sass
-  module Selector
-    # A unseparated sequence of selectors
-    # that all apply to a single element.
-    # For example, `.foo#bar[attr=baz]` is a simple sequence
-    # of the selectors `.foo`, `#bar`, and `[attr=baz]`.
-    class SimpleSequence < AbstractSequence
-      # The array of individual selectors.
-      #
-      # @return [Array<Simple>]
-      attr_reader :members
-
-      # Returns the element or universal selector in this sequence,
-      # if it exists.
-      #
-      # @return [Element, Universal, nil]
-      def base
-        @base ||= (members.first if members.first.is_a?(Element) || members.first.is_a?(Universal))
-      end
-
-      # Returns the non-base selectors in this sequence.
-      #
-      # @return [Set<Simple>]
-      def rest
-        @rest ||= Set.new(base ? members[1..-1] : members)
-      end
-
-      # @param selectors [Array<Simple>] See \{#members}
-      def initialize(selectors)
-        @members = selectors
-      end
-
-      # Resolves the {Parent} selectors within this selector
-      # by replacing them with the given parent selector,
-      # handling commas appropriately.
-      #
-      # @param super_seq [Sequence] The parent selector sequence
-      # @return [Array<SimpleSequence>] This selector, with parent references resolved.
-      #   This is an array because the parent selector is itself a {Sequence}
-      # @raise [Sass::SyntaxError] If a parent selector is invalid
-      def resolve_parent_refs(super_seq)
-        # Parent selector only appears as the first selector in the sequence
-        return [self] unless @members.first.is_a?(Parent)
-
-        return super_seq.members if @members.size == 1
-        unless super_seq.members.last.is_a?(SimpleSequence)
-          raise Sass::SyntaxError.new("Invalid parent selector: " + super_seq.to_a.join)
-        end
-
-        super_seq.members[0...-1] +
-          [SimpleSequence.new(super_seq.members.last.members + @members[1..-1])]
-      end
-
-      # Non-destrucively extends this selector
-      # with the extensions specified in a hash
-      # (which should be populated via {Sass::Tree::Node#cssize}).
-      #
-      # @overload def do_extend(extends)
-      # @param extends [{Selector::Simple => Selector::Sequence}]
-      #   The extensions to perform on this selector
-      # @return [Array<Sequence>] A list of selectors generated
-      #   by extending this selector with `extends`.
-      # @see CommaSequence#do_extend
-      def do_extend(extends, seen = Set.new)
-        extends.get(members.to_set).map do |seq, sels|
-          # If A {@extend B} and C {...},
-          # seq is A, sels is B, and self is C
-
-          self_without_sel = self.members - sels
-          next unless unified = seq.members.last.unify(self_without_sel)
-          [sels, seq.members[0...-1] + [unified]]
-        end.compact.map do |sels, seq|
-          seq = Sequence.new(seq)
-          seen.include?(sels) ? [] : seq.do_extend(extends, seen + [sels])
-        end.flatten.uniq
-      end
-
-      # Unifies this selector with another {SimpleSequence}'s {SimpleSequence#members members array},
-      # returning another `SimpleSequence`
-      # that matches both this selector and the input selector.
-      #
-      # @param sels [Array<Simple>] A {SimpleSequence}'s {SimpleSequence#members members array}
-      # @return [SimpleSequence, nil] A {SimpleSequence} matching both `sels` and this selector,
-      #   or `nil` if this is impossible (e.g. unifying `#foo` and `#bar`)
-      # @raise [Sass::SyntaxError] If this selector cannot be unified.
-      #   This will only ever occur when a dynamic selector,
-      #   such as {Parent} or {Interpolation}, is used in unification.
-      #   Since these selectors should be resolved
-      #   by the time extension and unification happen,
-      #   this exception will only ever be raised as a result of programmer error
-      def unify(sels)
-        return unless sseq = members.inject(sels) do |sseq, sel|
-          return unless sseq
-          sel.unify(sseq)
-        end
-        SimpleSequence.new(sseq)
-      end
-
-      # Returns whether or not this selector matches all elements
-      # that the given selector matches (as well as possibly more).
-      #
-      # @example
-      # (.foo).superselector?(.foo.bar) #=> true
-      # (.foo).superselector?(.bar) #=> false
-      #
-      # @param sseq [SimpleSequence]
-      # @return [Boolean]
-      def superselector?(sseq)
-        (base.nil? || base.eql?(sseq.base)) && rest.subset?(sseq.rest)
-      end
-
-      # @see Simple#to_a
-      def to_a
-        @members.map {|sel| sel.to_a}.flatten
-      end
-
-      # Returns a string representation of the sequence.
-      # This is basically the selector string.
-      #
-      # @return [String]
-      def inspect
-        members.map {|m| m.inspect}.join
-      end
-
-      private
-
-      def _hash
-        [base, Haml::Util.set_hash(rest)].hash
-      end
-
-      def _eql?(other)
-        other.base.eql?(self.base) && Haml::Util.set_eql?(other.rest, self.rest)
-      end
-    end
-  end
-end

data/lib/sass/tree/charset_node.rb

@@ -1,37 +0,0 @@
-module Sass::Tree
-  # A static node representing an unproccessed Sass `@charset` directive.
-  #
-  # @see Sass::Tree
-  class CharsetNode < Node
-    # The name of the charset.
-    #
-    # @return [String]
-    attr_accessor :name
-
-    # @param name [String] see \{#name}
-    def initialize(name)
-      @name = name
-      super()
-    end
-
-    # @see Node#invisible?
-    def invisible?
-      !Haml::Util.ruby1_8?
-    end
-
-    protected
-
-    # @see Node#to_src
-    def to_src(tabs, opts, fmt)
-      "#{'  ' * tabs}@charset \"#{name}\"#{semi fmt}\n"
-    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)
-      "@charset \"#{name}\";"
-    end
-  end
-end

data/lib/sass/tree/comment_node.rb

@@ -1,128 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A static node representing a Sass comment (silent or loud).
-  #
-  # @see Sass::Tree
-  class CommentNode < Node
-    # The text of the comment, not including `/*` and `*/`.
-    #
-    # @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 = normalize_indentation value
-      @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
-    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
-
-    # @see Node#to_sass
-    def to_sass(tabs, opts = {})
-      content = value.gsub(/\*\/$/, '').rstrip
-      if content =~ /\A[ \t]/
-        # Re-indent SCSS comments like this:
-        #     /* foo
-        #   bar
-        #       baz */
-        content.gsub!(/^/, '   ')
-        content.sub!(/\A([ \t]*)\/\*/, '/*\1')
-      end
-
-      content =
-        unless content.include?("\n")
-          content
-        else
-          content.gsub!(/\n( \*|\/\/)/, "\n  ")
-          spaces = content.scan(/\n( *)/).map {|s| s.first.size}.min
-          sep = silent ? "\n//" : "\n *"
-          if spaces >= 2
-            content.gsub(/\n  /, sep)
-          else
-            content.gsub(/\n#{' ' * spaces}/, sep)
-          end
-        end
-
-      content.gsub!(/\A\/\*/, '//') if silent
-      content.gsub!(/^/, '  ' * tabs)
-      content.rstrip + "\n"
-    end
-
-    # @see Node#to_scss
-    def to_scss(tabs, opts = {})
-      spaces = ('  ' * [tabs - value[/^ */].size, 0].max)
-      if silent
-        value.gsub(/^[\/ ]\*/, '//').gsub(/ *\*\/$/, '')
-      else
-        value
-      end.gsub(/^/, spaces) + "\n"
-    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 - value[/^ */].size, 0].max)
-
-      content = value.gsub(/^/, spaces)
-      content.gsub!(/\n +(\* *(?!\/))?/, ' ') if style == :compact
-      content
-    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
-
-    private
-
-    def normalize_indentation(str)
-      pre = str.split("\n").inject(str[/^[ \t]*/].split("")) do |pre, line|
-        line[/^[ \t]*/].split("").zip(pre).inject([]) do |arr, (a, b)|
-          break arr if a != b
-          arr + [a]
-        end
-      end.join
-      str.gsub(/^#{pre}/, '')
-    end
-  end
-end

data/lib/sass/tree/debug_node.rb

@@ -1,36 +0,0 @@
-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
-
-      # @see Node#to_src
-      def to_src(tabs, opts, fmt)
-        "#{'  ' * tabs}@debug #{@expr.to_sass(opts)}#{semi fmt}\n"
-      end
-
-      # Prints the expression to STDERR.
-      #
-      # @param environment [Sass::Environment] The lexical environment containing
-      #   variable and mixin values
-      def _perform(environment)
-        res = @expr.perform(environment)
-        res = res.value if res.is_a?(Sass::Script::String)
-        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,75 +0,0 @@
-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` and `@charset` are special cases;
-  # they become {ImportNode}s and {CharsetNode}s, respectively.
-  #
-  # @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
-
-    # @see Node#to_src
-    def to_src(tabs, opts, fmt)
-      res = "#{'  ' * tabs}#{value}"
-      return res + "#{semi fmt}\n" unless has_children
-      res + children_to_src(tabs, opts, fmt) + "\n"
-    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)
-      return value + ";" unless has_children
-      return value + " {}" if children.empty?
-      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).dup
-            rendered = rendered.lstrip if first
-            result << rendered.rstrip + "\n"
-          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

data/lib/sass/tree/extend_node.rb

@@ -1,65 +0,0 @@
-require 'sass/tree/node'
-
-module Sass::Tree
-  # A static node reprenting an `@extend` directive.
-  #
-  # @see Sass::Tree
-  class ExtendNode < Node
-    # @param selector [Array<String, Sass::Script::Node>]
-    #   The CSS selector to extend,
-    #   interspersed with {Sass::Script::Node}s
-    #   representing `#{}`-interpolation.
-    def initialize(selector)
-      @selector = selector
-      super()
-    end
-
-    # Registers this extension in the `extends` subset map.
-    #
-    # @param extends [Haml::Util::SubsetMap{Selector::Simple => Selector::Sequence}]
-    #   The extensions defined for this tree
-    # @param parent [RuleNode] The parent node of this node
-    # @see Node#cssize
-    def cssize(extends, parent)
-      @resolved_selector.members.each do |seq|
-        if seq.members.size > 1
-          raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: can't extend nested selectors")
-        end
-
-        sseq = seq.members.first
-        if !sseq.is_a?(Sass::Selector::SimpleSequence)
-          raise Sass::SyntaxError.new("Can't extend #{seq.to_a.join}: invalid selector")
-        end
-
-        sel = sseq.members
-        parent.resolved_rules.members.each do |seq|
-          if !seq.members.last.is_a?(Sass::Selector::SimpleSequence)
-            raise Sass::SyntaxError.new("#{seq} can't extend: invalid selector")
-          end
-
-          extends[sel] = seq
-        end
-      end
-
-      []
-    end
-
-    protected
-
-    # @see Node#to_src
-    def to_src(tabs, opts, fmt)
-      "#{'  ' * tabs}@extend #{selector_to_src(@selector, tabs, opts, fmt).lstrip}#{semi fmt}\n"
-    end
-
-    # Runs SassScript interpolation in the selector,
-    # and then parses the result into a {Sass::Selector::CommaSequence}.
-    #
-    # @param environment [Sass::Environment] The lexical environment containing
-    #   variable and mixin values
-    def perform!(environment)
-      @resolved_selector = Sass::SCSS::CssParser.new(run_interp(@selector, environment), self.line).
-        parse_selector(self.filename)
-      super
-    end
-  end
-end