brakeman 4.4.0 → 4.5.0

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/selector.rb

@@ -1,323 +0,0 @@
-require 'sass/selector/simple'
-require 'sass/selector/abstract_sequence'
-require 'sass/selector/comma_sequence'
-require 'sass/selector/pseudo'
-require 'sass/selector/sequence'
-require 'sass/selector/simple_sequence'
-
-module Sass
-  # A namespace for nodes in the parse tree for selectors.
-  #
-  # {CommaSequence} is the toplevel selector,
-  # representing a comma-separated sequence of {Sequence}s,
-  # such as `foo bar, baz bang`.
-  # {Sequence} is the next level,
-  # representing {SimpleSequence}s separated by combinators (e.g. descendant or child),
-  # such as `foo bar` or `foo > bar baz`.
-  # {SimpleSequence} is a sequence of selectors that all apply to a single element,
-  # such as `foo.bar[attr=val]`.
-  # Finally, {Simple} is the superclass of the simplest selectors,
-  # such as `.foo` or `#bar`.
-  module Selector
-    # The base used for calculating selector specificity. The spec says this
-    # should be "sufficiently high"; it's extremely unlikely that any single
-    # selector sequence will contain 1,000 simple selectors.
-    SPECIFICITY_BASE = 1_000
-
-    # A parent-referencing selector (`&` in Sass).
-    # The function of this is to be replaced by the parent selector
-    # in the nested hierarchy.
-    class Parent < Simple
-      # The identifier following the `&`. `nil` indicates no suffix.
-      #
-      # @return [String, nil]
-      attr_reader :suffix
-
-      # @param name [String, nil] See \{#suffix}
-      def initialize(suffix = nil)
-        @suffix = suffix
-      end
-
-      # @see Selector#to_s
-      def to_s(opts = {})
-        "&" + (@suffix || '')
-      end
-
-      # Always raises an exception.
-      #
-      # @raise [Sass::SyntaxError] Parent selectors should be resolved before unification
-      # @see Selector#unify
-      def unify(sels)
-        raise Sass::SyntaxError.new("[BUG] Cannot unify parent selectors.")
-      end
-    end
-
-    # A class selector (e.g. `.foo`).
-    class Class < Simple
-      # The class name.
-      #
-      # @return [String]
-      attr_reader :name
-
-      # @param name [String] The class name
-      def initialize(name)
-        @name = name
-      end
-
-      # @see Selector#to_s
-      def to_s(opts = {})
-        "." + @name
-      end
-
-      # @see AbstractSequence#specificity
-      def specificity
-        SPECIFICITY_BASE
-      end
-    end
-
-    # An id selector (e.g. `#foo`).
-    class Id < Simple
-      # The id name.
-      #
-      # @return [String]
-      attr_reader :name
-
-      # @param name [String] The id name
-      def initialize(name)
-        @name = name
-      end
-
-      # @see Selector#to_s
-      def to_s(opts = {})
-        "#" + @name
-      end
-
-      # Returns `nil` if `sels` contains an {Id} selector
-      # with a different name than this one.
-      #
-      # @see Selector#unify
-      def unify(sels)
-        return if sels.any? {|sel2| sel2.is_a?(Id) && name != sel2.name}
-        super
-      end
-
-      # @see AbstractSequence#specificity
-      def specificity
-        SPECIFICITY_BASE**2
-      end
-    end
-
-    # A placeholder selector (e.g. `%foo`).
-    # This exists to be replaced via `@extend`.
-    # Rulesets using this selector will not be printed, but can be extended.
-    # Otherwise, this acts just like a class selector.
-    class Placeholder < Simple
-      # The placeholder name.
-      #
-      # @return [String]
-      attr_reader :name
-
-      # @param name [String] The placeholder name
-      def initialize(name)
-        @name = name
-      end
-
-      # @see Selector#to_s
-      def to_s(opts = {})
-        "%" + @name
-      end
-
-      # @see AbstractSequence#specificity
-      def specificity
-        SPECIFICITY_BASE
-      end
-    end
-
-    # A universal selector (`*` in CSS).
-    class Universal < Simple
-      # The selector namespace. `nil` means the default namespace, `""` means no
-      # namespace, `"*"` means any namespace.
-      #
-      # @return [String, nil]
-      attr_reader :namespace
-
-      # @param namespace [String, nil] See \{#namespace}
-      def initialize(namespace)
-        @namespace = namespace
-      end
-
-      # @see Selector#to_s
-      def to_s(opts = {})
-        @namespace ? "#{@namespace}|*" : "*"
-      end
-
-      # Unification of a universal selector is somewhat complicated,
-      # especially when a namespace is specified.
-      # If there is no namespace specified
-      # or any namespace is specified (namespace `"*"`),
-      # then `sel` is returned without change
-      # (unless it's empty, in which case `"*"` is required).
-      #
-      # If a namespace is specified
-      # but `sel` does not specify a namespace,
-      # then the given namespace is applied to `sel`,
-      # either by adding this {Universal} selector
-      # or applying this namespace to an existing {Element} selector.
-      #
-      # If both this selector *and* `sel` specify namespaces,
-      # those namespaces are unified via {Simple#unify_namespaces}
-      # and the unified namespace is used, if possible.
-      #
-      # @todo There are lots of cases that this documentation specifies;
-      #   make sure we thoroughly test **all of them**.
-      # @todo Keep track of whether a default namespace has been declared
-      #   and handle namespace-unspecified selectors accordingly.
-      # @todo If any branch of a CommaSequence ends up being just `"*"`,
-      #   then all other branches should be eliminated
-      #
-      # @see Selector#unify
-      def unify(sels)
-        name =
-          case sels.first
-          when Universal; :universal
-          when Element; sels.first.name
-          else
-            return [self] + sels unless namespace.nil? || namespace == '*'
-            return sels unless sels.empty?
-            return [self]
-          end
-
-        ns, accept = unify_namespaces(namespace, sels.first.namespace)
-        return unless accept
-        [name == :universal ? Universal.new(ns) : Element.new(name, ns)] + sels[1..-1]
-      end
-
-      # @see AbstractSequence#specificity
-      def specificity
-        0
-      end
-    end
-
-    # An element selector (e.g. `h1`).
-    class Element < Simple
-      # The element name.
-      #
-      # @return [String]
-      attr_reader :name
-
-      # The selector namespace. `nil` means the default namespace, `""` means no
-      # namespace, `"*"` means any namespace.
-      #
-      # @return [String, nil]
-      attr_reader :namespace
-
-      # @param name [String] The element name
-      # @param namespace [String, nil] See \{#namespace}
-      def initialize(name, namespace)
-        @name = name
-        @namespace = namespace
-      end
-
-      # @see Selector#to_s
-      def to_s(opts = {})
-        @namespace ? "#{@namespace}|#{@name}" : @name
-      end
-
-      # Unification of an element selector is somewhat complicated,
-      # especially when a namespace is specified.
-      # First, if `sel` contains another {Element} with a different \{#name},
-      # then the selectors can't be unified and `nil` is returned.
-      #
-      # Otherwise, if `sel` doesn't specify a namespace,
-      # or it specifies any namespace (via `"*"`),
-      # then it's returned with this element selector
-      # (e.g. `.foo` becomes `a.foo` or `svg|a.foo`).
-      # Similarly, if this selector doesn't specify a namespace,
-      # the namespace from `sel` is used.
-      #
-      # If both this selector *and* `sel` specify namespaces,
-      # those namespaces are unified via {Simple#unify_namespaces}
-      # and the unified namespace is used, if possible.
-      #
-      # @todo There are lots of cases that this documentation specifies;
-      #   make sure we thoroughly test **all of them**.
-      # @todo Keep track of whether a default namespace has been declared
-      #   and handle namespace-unspecified selectors accordingly.
-      #
-      # @see Selector#unify
-      def unify(sels)
-        case sels.first
-        when Universal;
-        when Element; return unless name == sels.first.name
-        else return [self] + sels
-        end
-
-        ns, accept = unify_namespaces(namespace, sels.first.namespace)
-        return unless accept
-        [Element.new(name, ns)] + sels[1..-1]
-      end
-
-      # @see AbstractSequence#specificity
-      def specificity
-        1
-      end
-    end
-
-    # An attribute selector (e.g. `[href^="http://"]`).
-    class Attribute < Simple
-      # The attribute name.
-      #
-      # @return [Array<String, Sass::Script::Tree::Node>]
-      attr_reader :name
-
-      # The attribute namespace. `nil` means the default namespace, `""` means
-      # no namespace, `"*"` means any namespace.
-      #
-      # @return [String, nil]
-      attr_reader :namespace
-
-      # The matching operator, e.g. `"="` or `"^="`.
-      #
-      # @return [String]
-      attr_reader :operator
-
-      # The right-hand side of the operator.
-      #
-      # @return [String]
-      attr_reader :value
-
-      # Flags for the attribute selector (e.g. `i`).
-      #
-      # @return [String]
-      attr_reader :flags
-
-      # @param name [String] The attribute name
-      # @param namespace [String, nil] See \{#namespace}
-      # @param operator [String] The matching operator, e.g. `"="` or `"^="`
-      # @param value [String] See \{#value}
-      # @param flags [String] See \{#flags}
-      def initialize(name, namespace, operator, value, flags)
-        @name = name
-        @namespace = namespace
-        @operator = operator
-        @value = value
-        @flags = flags
-      end
-
-      # @see Selector#to_s
-      def to_s(opts = {})
-        res = "["
-        res << @namespace << "|" if @namespace
-        res << @name
-        res << @operator << @value if @value
-        res << " " << @flags if @flags
-        res << "]"
-      end
-
-      # @see AbstractSequence#specificity
-      def specificity
-        SPECIFICITY_BASE
-      end
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/selector/abstract_sequence.rb

@@ -1,111 +0,0 @@
-module Sass
-  module Selector
-    # The abstract parent class of the various selector sequence classes.
-    #
-    # All subclasses should implement a `members` method that returns an array
-    # of object that respond to `#line=` and `#filename=`, as well as a `to_s`
-    # method that returns the string representation of the selector.
-    class AbstractSequence
-      # The line of the Sass template on which this selector was declared.
-      #
-      # @return [Integer]
-      attr_reader :line
-
-      # The name of the file in which this selector was declared.
-      #
-      # @return [String, nil]
-      attr_reader :filename
-
-      # Sets the line of the Sass template on which this selector was declared.
-      # This also sets the line for all child selectors.
-      #
-      # @param line [Integer]
-      # @return [Integer]
-      def line=(line)
-        members.each {|m| m.line = line}
-        @line = line
-      end
-
-      # Sets 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).
-      # This also sets the filename for all child selectors.
-      #
-      # @param filename [String, nil]
-      # @return [String, nil]
-      def filename=(filename)
-        members.each {|m| m.filename = filename}
-        @filename = filename
-      end
-
-      # Returns a hash code for this sequence.
-      #
-      # Subclasses should define `#_hash` rather than overriding this method,
-      # which automatically handles memoizing the result.
-      #
-      # @return [Integer]
-      def hash
-        @_hash ||= _hash
-      end
-
-      # Checks equality between this and another object.
-      #
-      # Subclasses should define `#_eql?` rather than overriding this method,
-      # which handles checking class equality and hash equality.
-      #
-      # @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 == hash && _eql?(other)
-      end
-      alias_method :==, :eql?
-
-      # Whether or not this selector sequence contains a placeholder selector.
-      # Checks recursively.
-      def has_placeholder?
-        @has_placeholder ||= members.any? do |m|
-          next m.has_placeholder? if m.is_a?(AbstractSequence)
-          next m.selector && m.selector.has_placeholder? if m.is_a?(Pseudo)
-          m.is_a?(Placeholder)
-        end
-      end
-
-      # Returns the selector string.
-      #
-      # @param opts [Hash] rendering options.
-      # @option opts [Symbol] :style The css rendering style.
-      # @return [String]
-      def to_s(opts = {})
-        Sass::Util.abstract(self)
-      end
-
-      # Returns the specificity of the selector.
-      #
-      # The base is given by {Sass::Selector::SPECIFICITY_BASE}. This can be a
-      # number or a range representing possible specificities.
-      #
-      # @return [Integer, Range]
-      def specificity
-        _specificity(members)
-      end
-
-      protected
-
-      def _specificity(arr)
-        min = 0
-        max = 0
-        arr.each do |m|
-          next if m.is_a?(String)
-          spec = m.specificity
-          if spec.is_a?(Range)
-            min += spec.begin
-            max += spec.end
-          else
-            min += spec
-            max += spec
-          end
-        end
-        min == max ? min : (min..max)
-      end
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/selector/comma_sequence.rb

@@ -1,191 +0,0 @@
-module Sass
-  module Selector
-    # A comma-separated sequence of selectors.
-    class CommaSequence < AbstractSequence
-      @@compound_extend_deprecation = Sass::Deprecation.new
-
-      # The comma-separated selector sequences
-      # represented by this class.
-      #
-      # @return [Array<Sequence>]
-      attr_reader :members
-
-      # @param seqs [Array<Sequence>] See \{#members}
-      def initialize(seqs)
-        @members = seqs
-      end
-
-      # Resolves the {Parent} selectors within this selector
-      # by replacing them with the given parent selector,
-      # handling commas appropriately.
-      #
-      # @param super_cseq [CommaSequence] The parent selector
-      # @param implicit_parent [Boolean] Whether the the parent
-      #   selector should automatically be prepended to the resolved
-      #   selector if it contains no parent refs.
-      # @return [CommaSequence] This selector, with parent references resolved
-      # @raise [Sass::SyntaxError] If a parent selector is invalid
-      def resolve_parent_refs(super_cseq, implicit_parent = true)
-        if super_cseq.nil?
-          if contains_parent_ref?
-            raise Sass::SyntaxError.new(
-              "Base-level rules cannot contain the parent-selector-referencing character '&'.")
-          end
-          return self
-        end
-
-        CommaSequence.new(Sass::Util.flatten_vertically(@members.map do |seq|
-          seq.resolve_parent_refs(super_cseq, implicit_parent).members
-        end))
-      end
-
-      # Returns whether there's a {Parent} selector anywhere in this sequence.
-      #
-      # @return [Boolean]
-      def contains_parent_ref?
-        @members.any? {|sel| sel.contains_parent_ref?}
-      end
-
-      # Non-destrucively extends this selector with the extensions specified in a hash
-      # (which should come from {Sass::Tree::Visitors::Cssize}).
-      #
-      # @todo Link this to the reference documentation on `@extend`
-      #   when such a thing exists.
-      #
-      # @param extends [Sass::Util::SubsetMap{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.
-      # @param replace [Boolean]
-      #   Whether to replace the original selector entirely or include
-      #   it in the result.
-      # @param seen [Set<Array<Selector::Simple>>]
-      #   The set of simple sequences that are currently being replaced.
-      # @param original [Boolean]
-      #   Whether this is the original selector being extended, as opposed to
-      #   the result of a previous extension that's being re-extended.
-      # @return [CommaSequence] A copy of this selector,
-      #   with extensions made according to `extends`
-      def do_extend(extends, parent_directives = [], replace = false, seen = Set.new,
-          original = true)
-        CommaSequence.new(members.map do |seq|
-          seq.do_extend(extends, parent_directives, replace, seen, original)
-        end.flatten)
-      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 cseq [CommaSequence]
-      # @return [Boolean]
-      def superselector?(cseq)
-        cseq.members.all? {|seq1| members.any? {|seq2| seq2.superselector?(seq1)}}
-      end
-
-      # Populates a subset map that can then be used to extend
-      # selectors. This registers an extension with this selector as
-      # the extender and `extendee` as the extendee.
-      #
-      # @param extends [Sass::Util::SubsetMap{Selector::Simple =>
-      #                                       Sass::Tree::Visitors::Cssize::Extend}]
-      #   The subset map representing the extensions to perform.
-      # @param extendee [CommaSequence] The selector being extended.
-      # @param extend_node [Sass::Tree::ExtendNode]
-      #   The node that caused this extension.
-      # @param parent_directives [Array<Sass::Tree::DirectiveNode>]
-      #   The parent directives containing `extend_node`.
-      # @param allow_compound_target [Boolean]
-      #   Whether `extendee` is allowed to contain compound selectors.
-      # @raise [Sass::SyntaxError] if this extension is invalid.
-      def populate_extends(extends, extendee, extend_node = nil, parent_directives = [],
-          allow_compound_target = false)
-        extendee.members.each do |seq|
-          if seq.members.size > 1
-            raise Sass::SyntaxError.new("Can't extend #{seq}: 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}: invalid selector")
-          elsif sseq.members.any? {|ss| ss.is_a?(Sass::Selector::Parent)}
-            raise Sass::SyntaxError.new("Can't extend #{seq}: can't extend parent selectors")
-          end
-
-          sel = sseq.members
-          if !allow_compound_target && sel.length > 1
-            @@compound_extend_deprecation.warn(sseq.filename, sseq.line, <<WARNING)
-Extending a compound selector, #{sseq}, is deprecated and will not be supported in a future release.
-See https://github.com/sass/sass/issues/1599 for details.
-WARNING
-          end
-
-          members.each do |member|
-            unless member.members.last.is_a?(Sass::Selector::SimpleSequence)
-              raise Sass::SyntaxError.new("#{member} can't extend: invalid selector")
-            end
-
-            extends[sel] = Sass::Tree::Visitors::Cssize::Extend.new(
-              member, sel, extend_node, parent_directives, :not_found)
-          end
-        end
-      end
-
-      # Unifies this with another comma selector to produce a selector
-      # that matches (a subset of) the intersection of the two inputs.
-      #
-      # @param other [CommaSequence]
-      # @return [CommaSequence, nil] The unified selector, or nil if unification failed.
-      # @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(other)
-        results = members.map {|seq1| other.members.map {|seq2| seq1.unify(seq2)}}.flatten.compact
-        results.empty? ? nil : CommaSequence.new(results.map {|cseq| cseq.members}.flatten)
-      end
-
-      # Returns a SassScript representation of this selector.
-      #
-      # @return [Sass::Script::Value::List]
-      def to_sass_script
-        Sass::Script::Value::List.new(members.map do |seq|
-          Sass::Script::Value::List.new(seq.members.map do |component|
-            next if component == "\n"
-            Sass::Script::Value::String.new(component.to_s)
-          end.compact, :space)
-        end, :comma)
-      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
-
-      # @see AbstractSequence#to_s
-      def to_s(opts = {})
-        @members.map {|m| m.to_s(opts)}.
-          join(opts[:style] == :compressed ? "," : ", ").
-          gsub(", \n", ",\n")
-      end
-
-      private
-
-      def _hash
-        members.hash
-      end
-
-      def _eql?(other)
-        other.class == self.class && other.members.eql?(members)
-      end
-    end
-  end
-end