aliddle-sass 1.0

data/lib/sass/selector/simple.rb

@@ -0,0 +1,119 @@
+module Sass
+  module Selector
+    # The abstract superclass for simple selectors
+    # (that is, those that don't compose multiple selectors).
+    class Simple
+      # The line of the Sass template on which this selector was declared.
+      #
+      # @return [Fixnum]
+      attr_accessor :line
+
+      # The name of the file in which this selector was declared,
+      # or `nil` if it was not declared in a file (e.g. on stdin).
+      #
+      # @return [String, nil]
+      attr_accessor :filename
+
+      # Returns a representation of the node
+      # as an array of strings and potentially {Sass::Script::Node}s
+      # (if there's interpolation in the selector).
+      # When the interpolation is resolved and the strings are joined together,
+      # this will be the string representation of this node.
+      #
+      # @return [Array<String, Sass::Script::Node>]
+      def to_a
+        Sass::Util.abstract(self)
+      end
+
+      # Returns a string representation of the node.
+      # This is basically the selector string.
+      #
+      # @return [String]
+      def inspect
+        to_a.map {|e| e.is_a?(Sass::Script::Node) ? "\#{#{e.to_sass}}" : e}.join
+      end
+
+      # @see \{#inspect}
+      # @return [String]
+      def to_s
+        inspect
+      end
+
+      # Returns a hash code for this selector object.
+      #
+      # By default, this is based on the value of \{#to\_a},
+      # so if that contains information irrelevant to the identity of the selector,
+      # this should be overridden.
+      #
+      # @return [Fixnum]
+      def hash
+        @_hash ||= to_a.hash
+      end
+
+      # Checks equality between this and another object.
+      #
+      # By default, this is based on the value of \{#to\_a},
+      # so if that contains information irrelevant to the identity of the selector,
+      # this should be overridden.
+      #
+      # @param other [Object] The object to test equality against
+      # @return [Boolean] Whether or not this is equal to `other`
+      def eql?(other)
+        other.class == self.class && other.hash == self.hash && other.to_a.eql?(to_a)
+      end
+      alias_method :==, :eql?
+
+      # Unifies this selector with a {SimpleSequence}'s {SimpleSequence#members members array},
+      # returning another `SimpleSequence` members array
+      # that matches both this selector and the input selector.
+      #
+      # By default, this just appends this selector to the end of the array
+      # (or returns the original array if this selector already exists in it).
+      #
+      # @param sels [Array<Simple>] A {SimpleSequence}'s {SimpleSequence#members members array}
+      # @return [Array<Simple>, nil] A {SimpleSequence} {SimpleSequence#members members array}
+      #   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 sels if sels.any? {|sel2| eql?(sel2)}
+        sels_with_ix = Sass::Util.enum_with_index(sels)
+        _, i =
+          if self.is_a?(Pseudo) || self.is_a?(SelectorPseudoClass)
+            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) && (sels.last.type == :element)}
+          else
+            sels_with_ix.find {|sel, _| sel.is_a?(Pseudo) || sel.is_a?(SelectorPseudoClass)}
+          end
+        return sels + [self] unless i
+        return sels[0...i] + [self] + sels[i..-1]
+      end
+
+      protected
+
+      # Unifies two namespaces,
+      # returning a namespace that works for both of them if possible.
+      #
+      # @param ns1 [String, nil] The first namespace.
+      #   `nil` means none specified, e.g. `foo`.
+      #   The empty string means no namespace specified, e.g. `|foo`.
+      #   `"*"` means any namespace is allowed, e.g. `*|foo`.
+      # @param ns2 [String, nil] The second namespace. See `ns1`.
+      # @return [Array(String or nil, Boolean)]
+      #   The first value is the unified namespace, or `nil` for no namespace.
+      #   The second value is whether or not a namespace that works for both inputs
+      #   could be found at all.
+      #   If the second value is `false`, the first should be ignored.
+      def unify_namespaces(ns1, ns2)
+        return nil, false unless ns1 == ns2 || ns1.nil? || ns1 == ['*'] || ns2.nil? || ns2 == ['*']
+        return ns2, true if ns1 == ['*']
+        return ns1, true if ns2 == ['*']
+        return ns1 || ns2, true
+      end
+    end
+  end
+end

data/lib/sass/selector/simple_sequence.rb

@@ -0,0 +1,212 @@
+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_accessor :members
+
+      # The extending selectors that caused this selector sequence to be
+      # generated. For example:
+      #
+      #     a.foo { ... }
+      #     b.bar {@extend a}
+      #     c.baz {@extend b}
+      #
+      # The generated selector `b.foo.bar` has `{b.bar}` as its `sources` set,
+      # and the generated selector `c.foo.bar.baz` has `{b.bar, c.baz}` as its
+      # `sources` set.
+      #
+      # This is populated during the {#do_extend} process.
+      #
+      # @return {Set<Sequence>}
+      attr_accessor :sources
+
+      # @see \{#subject?}
+      attr_writer :subject
+
+      # 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
+
+      def pseudo_elements
+        @pseudo_elements ||= (members - [base]).
+          select {|sel| sel.is_a?(Pseudo) && sel.type == :element}
+      end
+
+      # Returns the non-base, non-pseudo-class selectors in this sequence.
+      #
+      # @return [Set<Simple>]
+      def rest
+        @rest ||= Set.new(members - [base] - pseudo_elements)
+      end
+
+      # Whether or not this compound selector is the subject of the parent
+      # selector; that is, whether it is prepended with `$` and represents the
+      # actual element that will be selected.
+      #
+      # @return [Boolean]
+      def subject?
+        @subject
+      end
+
+      # @param selectors [Array<Simple>] See \{#members}
+      # @param subject [Boolean] See \{#subject?}
+      # @param sources [Set<Sequence>]
+      def initialize(selectors, subject, sources = Set.new)
+        @members = selectors
+        @subject = subject
+        @sources = sources
+      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], subject?)]
+      end
+
+      # Non-destrucively extends this selector with the extensions specified in a hash
+      # (which should come from {Sass::Tree::Visitors::Cssize}).
+      #
+      # @overload def do_extend(extends, parent_directives)
+      # @param extends [{Selector::Simple =>
+      #                  Sass::Tree::Visitors::Cssize::Extend}]
+      #   The extensions to perform on this selector
+      # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
+      #   The directives containing this selector.
+      # @return [Array<Sequence>] A list of selectors generated
+      #   by extending this selector with `extends`.
+      # @see CommaSequence#do_extend
+      def do_extend(extends, parent_directives, seen = Set.new)
+        Sass::Util.group_by_to_a(extends.get(members.to_set)) {|ex, _| ex.extender}.map do |seq, group|
+          sels = group.map {|_, s| s}.flatten
+          # If A {@extend B} and C {...},
+          # seq is A, sels is B, and self is C
+
+          self_without_sel = Sass::Util.array_minus(self.members, sels)
+          group.each {|e, _| e.result = :failed_to_unify unless e.result == :succeeded}
+          next unless unified = seq.members.last.unify(self_without_sel, subject?)
+          group.each {|e, _| e.result = :succeeded}
+          next if group.map {|e, _| check_directives_match!(e, parent_directives)}.none?
+          new_seq = Sequence.new(seq.members[0...-1] + [unified])
+          new_seq.add_sources!(sources + [seq])
+          [sels, new_seq]
+        end.compact.map do |sels, seq|
+          seen.include?(sels) ? [] : seq.do_extend(extends, parent_directives, 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}
+      # @param subject [Boolean] Whether the {SimpleSequence} being merged is a subject.
+      # @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, other_subject)
+        return unless sseq = members.inject(sels) do |member, sel|
+          return unless member
+          sel.unify(member)
+        end
+        SimpleSequence.new(sseq, other_subject || subject?)
+      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)) &&
+          pseudo_elements.eql?(sseq.pseudo_elements) &&
+          rest.subset?(sseq.rest)
+      end
+
+      # @see Simple#to_a
+      def to_a
+        res = @members.map {|sel| sel.to_a}.flatten
+        res << '!' if subject?
+        res
+      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
+
+      # Return a copy of this simple sequence with `sources` merged into the
+      # {#sources} set.
+      #
+      # @param sources [Set<Sequence>]
+      # @return [SimpleSequence]
+      def with_more_sources(sources)
+        sseq = dup
+        sseq.members = members.dup
+        sseq.sources = self.sources | sources
+        sseq
+      end
+
+      private
+
+      def check_directives_match!(extend, parent_directives)
+        dirs1 = extend.directives.map {|d| d.resolved_value}
+        dirs2 = parent_directives.map {|d| d.resolved_value}
+        return true if Sass::Util.subsequence?(dirs1, dirs2)
+
+        Sass::Util.sass_warn <<WARNING
+DEPRECATION WARNING on line #{extend.node.line}#{" of #{extend.node.filename}" if extend.node.filename}:
+  @extending an outer selector from within #{extend.directives.last.name} is deprecated.
+  You may only @extend selectors within the same directive.
+  This will be an error in Sass 3.3.
+  It can only work once @extend is supported natively in the browser.
+WARNING
+        return false
+      end
+
+      def _hash
+        [base, Sass::Util.set_hash(rest)].hash
+      end
+
+      def _eql?(other)
+        other.base.eql?(self.base) && other.pseudo_elements == pseudo_elements &&
+          Sass::Util.set_eql?(other.rest, self.rest) && other.subject? == self.subject?
+      end
+    end
+  end
+end

data/lib/sass/shared.rb

@@ -0,0 +1,76 @@
+module Sass
+  # This module contains functionality that's shared between Haml and Sass.
+  module Shared
+    extend self
+
+    # Scans through a string looking for the interoplation-opening `#{`
+    # and, when it's found, yields the scanner to the calling code
+    # so it can handle it properly.
+    #
+    # The scanner will have any backslashes immediately in front of the `#{`
+    # as the second capture group (`scan[2]`),
+    # and the text prior to that as the first (`scan[1]`).
+    #
+    # @yieldparam scan [StringScanner] The scanner scanning through the string
+    # @return [String] The text remaining in the scanner after all `#{`s have been processed
+    def handle_interpolation(str)
+      scan = Sass::Util::MultibyteStringScanner.new(str)
+      yield scan while scan.scan(/(.*?)(\\*)\#\{/m)
+      scan.rest
+    end
+
+    # Moves a scanner through a balanced pair of characters.
+    # For example:
+    #
+    #     Foo (Bar (Baz bang) bop) (Bang (bop bip))
+    #     ^                       ^
+    #     from                    to
+    #
+    # @param scanner [StringScanner] The string scanner to move
+    # @param start [Character] The character opening the balanced pair.
+    #   A `Fixnum` in 1.8, a `String` in 1.9
+    # @param finish [Character] The character closing the balanced pair.
+    #   A `Fixnum` in 1.8, a `String` in 1.9
+    # @param count [Fixnum] The number of opening characters matched
+    #   before calling this method
+    # @return [(String, String)] The string matched within the balanced pair
+    #   and the rest of the string.
+    #   `["Foo (Bar (Baz bang) bop)", " (Bang (bop bip))"]` in the example above.
+    def balance(scanner, start, finish, count = 0)
+      str = ''
+      scanner = Sass::Util::MultibyteStringScanner.new(scanner) unless scanner.is_a? StringScanner
+      regexp = Regexp.new("(.*?)[\\#{start.chr}\\#{finish.chr}]", Regexp::MULTILINE)
+      while scanner.scan(regexp)
+        str << scanner.matched
+        count += 1 if scanner.matched[-1] == start
+        count -= 1 if scanner.matched[-1] == finish
+        return [str.strip, scanner.rest] if count == 0
+      end
+    end
+
+    # Formats a string for use in error messages about indentation.
+    #
+    # @param indentation [String] The string used for indentation
+    # @param was [Boolean] Whether or not to add `"was"` or `"were"`
+    #   (depending on how many characters were in `indentation`)
+    # @return [String] The name of the indentation (e.g. `"12 spaces"`, `"1 tab"`)
+    def human_indentation(indentation, was = false)
+      if !indentation.include?(?\t)
+        noun = 'space'
+      elsif !indentation.include?(?\s)
+        noun = 'tab'
+      else
+        return indentation.inspect + (was ? ' was' : '')
+      end
+
+      singular = indentation.length == 1
+      if was
+        was = singular ? ' was' : ' were'
+      else
+        was = ''
+      end
+
+      "#{indentation.length} #{noun}#{'s' unless singular}#{was}"
+    end
+  end
+end

data/lib/sass/supports.rb

@@ -0,0 +1,229 @@
+# A namespace for the `@supports` condition parse tree.
+module Sass::Supports
+  # The abstract superclass of all Supports conditions.
+  class Condition
+    # Runs the SassScript in the supports condition.
+    #
+    # @param env [Sass::Environment] The environment in which to run the script.
+    def perform(environment); Sass::Util.abstract(self); end
+
+    # Returns the CSS for this condition.
+    #
+    # @return [String]
+    def to_css; Sass::Util.abstract(self); end
+
+    # Returns the Sass/CSS code for this condition.
+    #
+    # @param options [{Symbol => Object}] An options hash (see {Sass::CSS#initialize}).
+    # @return [String]
+    def to_src(options); Sass::Util.abstract(self); end
+
+    # Returns a deep copy of this condition and all its children.
+    #
+    # @return [Condition]
+    def deep_copy; Sass::Util.abstract(self); end
+
+    # Sets the options hash for the script nodes in the supports condition.
+    #
+    # @param options [{Symbol => Object}] The options has to set.
+    def options=(options); Sass::Util.abstract(self); end
+  end
+
+  # An operator condition (e.g. `CONDITION1 and CONDITION2`).
+  class Operator < Condition
+    # The left-hand condition.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :left
+
+    # The right-hand condition.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :right
+
+    # The operator ("and" or "or").
+    #
+    # @return [String]
+    attr_accessor :op
+
+    def initialize(left, right, op)
+      @left = left
+      @right = right
+      @op = op
+    end
+
+    def perform(env)
+      @left.perform(env)
+      @right.perform(env)
+    end
+
+    def to_css
+      "#{left_parens @left.to_css} #{op} #{right_parens @right.to_css}"
+    end
+
+    def to_src(options)
+      "#{left_parens @left.to_src(options)} #{op} #{right_parens @right.to_src(options)}"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.left = @left.deep_copy
+      copy.right = @right.deep_copy
+      copy
+    end
+
+    def options=(options)
+      @left.options = options
+      @right.options = options
+    end
+
+    private
+
+    def left_parens(str)
+      return "(#{str})" if @left.is_a?(Negation)
+      return str
+    end
+
+    def right_parens(str)
+      return "(#{str})" if @right.is_a?(Negation) || @right.is_a?(Operator)
+      return str
+    end
+  end
+
+  # A negation condition (`not CONDITION`).
+  class Negation < Condition
+    # The condition being negated.
+    #
+    # @return [Sass::Supports::Condition]
+    attr_accessor :condition
+
+    def initialize(condition)
+      @condition = condition
+    end
+
+    def perform(env)
+      @condition.perform(env)
+    end
+
+    def to_css
+      "not #{parens @condition.to_css}"
+    end
+
+    def to_src(options)
+      "not #{parens @condition.to_src(options)}"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.condition = condition.deep_copy
+      copy
+    end
+
+    def options=(options)
+      condition.options = options
+    end
+
+    private
+
+    def parens(str)
+      return "(#{str})" if @condition.is_a?(Negation) || @condition.is_a?(Operator)
+      return str
+    end
+  end
+
+  # A declaration condition (e.g. `(feature: value)`).
+  class Declaration < Condition
+    # The feature name.
+    #
+    # @param [Sass::Script::Node]
+    attr_accessor :name
+
+    # The name of the feature after any SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_name
+
+    # The feature value.
+    #
+    # @param [Sass::Script::Node]
+    attr_accessor :value
+
+    # The value of the feature after any SassScript has been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    def initialize(name, value)
+      @name = name
+      @value = value
+    end
+
+    def perform(env)
+      @resolved_name = name.perform(env)
+      @resolved_value = value.perform(env)
+    end
+
+    def to_css
+      "(#{@resolved_name}: #{@resolved_value})"
+    end
+
+    def to_src(options)
+      "(#{@name.to_sass(options)}: #{@value.to_sass(options)})"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.name = @name.deep_copy
+      copy.value = @value.deep_copy
+      copy
+    end
+
+    def options=(options)
+      @name.options = options
+      @value.options = options
+    end
+  end
+
+  # An interpolation condition (e.g. `#{$var}`).
+  class Interpolation < Condition
+    # The SassScript expression in the interpolation.
+    #
+    # @param [Sass::Script::Node]
+    attr_accessor :value
+
+    # The value of the expression after it's been resolved.
+    # Only set once \{Tree::Visitors::Perform} has been run.
+    #
+    # @return [String]
+    attr_accessor :resolved_value
+
+    def initialize(value)
+      @value = value
+    end
+
+    def perform(env)
+      val = value.perform(env)
+      @resolved_value = val.is_a?(Sass::Script::String) ? val.value : val.to_s
+    end
+
+    def to_css
+      @resolved_value
+    end
+
+    def to_src(options)
+      "\#{#{@value.to_sass(options)}}"
+    end
+
+    def deep_copy
+      copy = dup
+      copy.value = @value.deep_copy
+      copy
+    end
+
+    def options=(options)
+      @value.options = options
+    end
+  end
+end