brakeman 4.4.0 → 4.5.0

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/script/tree/list_literal.rb

@@ -1,104 +0,0 @@
-module Sass::Script::Tree
-  # A parse tree node representing a list literal. When resolved, this returns a
-  # {Sass::Tree::Value::List}.
-  class ListLiteral < Node
-    # The parse nodes for members of this list.
-    #
-    # @return [Array<Node>]
-    attr_reader :elements
-
-    # The operator separating the values of the list. Either `:comma` or
-    # `:space`.
-    #
-    # @return [Symbol]
-    attr_reader :separator
-
-    # Creates a new list literal.
-    #
-    # @param elements [Array<Node>] See \{#elements}
-    # @param separator [Symbol] See \{#separator}
-    def initialize(elements, separator)
-      @elements = elements
-      @separator = separator
-    end
-
-    # @see Node#children
-    def children; elements; end
-
-    # @see Value#to_sass
-    def to_sass(opts = {})
-      return "()" if elements.empty?
-      members = elements.map do |v|
-        if element_needs_parens?(v)
-          "(#{v.to_sass(opts)})"
-        else
-          v.to_sass(opts)
-        end
-      end
-
-      return "(#{members.first},)" if separator == :comma && members.length == 1
-
-      members.join(sep_str(nil))
-    end
-
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@elements', elements.map {|e| e.deep_copy})
-      node
-    end
-
-    def inspect
-      "(#{elements.map {|e| e.inspect}.join(separator == :space ? ' ' : ', ')})"
-    end
-
-    def force_division!
-      # Do nothing. Lists prevent division propagation.
-    end
-
-    protected
-
-    def _perform(environment)
-      list = Sass::Script::Value::List.new(
-        elements.map {|e| e.perform(environment)},
-        separator)
-      list.source_range = source_range
-      list.options = options
-      list
-    end
-
-    private
-
-    # Returns whether an element in the list should be wrapped in parentheses
-    # when serialized to Sass.
-    def element_needs_parens?(element)
-      if element.is_a?(ListLiteral)
-        return Sass::Script::Parser.precedence_of(element.separator) <=
-               Sass::Script::Parser.precedence_of(separator)
-      end
-
-      return false unless separator == :space
-
-      if element.is_a?(UnaryOperation)
-        return element.operator == :minus || element.operator == :plus
-      end
-
-      return false unless element.is_a?(Operation)
-      return true unless element.operator == :div
-      !(is_literal_number?(element.operand1) && is_literal_number?(element.operand2))
-    end
-
-    # Returns whether a value is a number literal that shouldn't be divided.
-    def is_literal_number?(value)
-      value.is_a?(Literal) &&
-        value.value.is_a?((Sass::Script::Value::Number)) &&
-        !value.value.original.nil?
-    end
-
-    def sep_str(opts = options)
-      return ' ' if separator == :space
-      return ',' if opts && opts[:style] == :compressed
-      ', '
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/script/tree/literal.rb

@@ -1,49 +0,0 @@
-module Sass::Script::Tree
-  # The parse tree node for a literal scalar value. This wraps an instance of
-  # {Sass::Script::Value::Base}.
-  #
-  # List literals should use {ListLiteral} instead.
-  class Literal < Node
-    # The wrapped value.
-    #
-    # @return [Sass::Script::Value::Base]
-    attr_reader :value
-
-    # Creates a new literal value.
-    #
-    # @param value [Sass::Script::Value::Base]
-    # @see #value
-    def initialize(value)
-      @value = value
-    end
-
-    # @see Node#children
-    def children; []; end
-
-    # @see Node#to_sass
-    def to_sass(opts = {}); value.to_sass(opts); end
-
-    # @see Node#deep_copy
-    def deep_copy; dup; end
-
-    # @see Node#options=
-    def options=(options)
-      value.options = options
-    end
-
-    def inspect
-      value.inspect
-    end
-
-    def force_division!
-      value.original = nil if value.is_a?(Sass::Script::Value::Number)
-    end
-
-    protected
-
-    def _perform(environment)
-      value.source_range = source_range
-      value
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/script/tree/map_literal.rb

@@ -1,64 +0,0 @@
-module Sass::Script::Tree
-  # A class representing a map literal. When resolved, this returns a
-  # {Sass::Script::Node::Map}.
-  class MapLiteral < Node
-    # The key/value pairs that make up this map node. This isn't a Hash so that
-    # we can detect key collisions once all the keys have been performed.
-    #
-    # @return [Array<(Node, Node)>]
-    attr_reader :pairs
-
-    # Creates a new map literal.
-    #
-    # @param pairs [Array<(Node, Node)>] See \{#pairs}
-    def initialize(pairs)
-      @pairs = pairs
-    end
-
-    # @see Node#children
-    def children
-      @pairs.flatten
-    end
-
-    # @see Node#to_sass
-    def to_sass(opts = {})
-      return "()" if pairs.empty?
-
-      to_sass = lambda do |value|
-        if value.is_a?(ListLiteral) && value.separator == :comma
-          "(#{value.to_sass(opts)})"
-        else
-          value.to_sass(opts)
-        end
-      end
-
-      "(" + pairs.map {|(k, v)| "#{to_sass[k]}: #{to_sass[v]}"}.join(', ') + ")"
-    end
-    alias_method :inspect, :to_sass
-
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@pairs',
-        pairs.map {|(k, v)| [k.deep_copy, v.deep_copy]})
-      node
-    end
-
-    protected
-
-    # @see Node#_perform
-    def _perform(environment)
-      keys = Set.new
-      map = Sass::Script::Value::Map.new(Sass::Util.to_hash(pairs.map do |(k, v)|
-        k, v = k.perform(environment), v.perform(environment)
-        if keys.include?(k)
-          raise Sass::SyntaxError.new("Duplicate key #{k.inspect} in map #{to_sass}.")
-        end
-        keys << k
-        [k, v]
-      end))
-      map.options = options
-      map
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/script/tree/node.rb

@@ -1,127 +0,0 @@
-module Sass::Script::Tree
-  # The abstract superclass for SassScript parse tree nodes.
-  #
-  # Use \{#perform} to evaluate a parse tree.
-  class Node
-    # The options hash for this node.
-    #
-    # @return [{Symbol => Object}]
-    attr_reader :options
-
-    # The line of the document on which this node appeared.
-    #
-    # @return [Integer]
-    attr_accessor :line
-
-    # The source range in the document on which this node appeared.
-    #
-    # @return [Sass::Source::Range]
-    attr_accessor :source_range
-
-    # The file name of the document on which this node appeared.
-    #
-    # @return [String]
-    attr_accessor :filename
-
-    # The warning that this node should emit if it executes in a way that's not
-    # safe for a CSS variable value.
-    #
-    # This is `nil` if this is not in a CSS variable value.
-    #
-    # @return [Sass::Script::CssVariableWarning]
-    attr_accessor :css_variable_warning
-
-    # Sets the options hash for this node,
-    # as well as for all child nodes.
-    # See {file:SASS_REFERENCE.md#Options the Sass options documentation}.
-    #
-    # @param options [{Symbol => Object}] The options
-    def options=(options)
-      @options = options
-      children.each do |c|
-        if c.is_a? Hash
-          c.values.each {|v| v.options = options}
-        else
-          c.options = options
-        end
-      end
-    end
-
-    # Evaluates the node.
-    #
-    # \{#perform} shouldn't be overridden directly;
-    # instead, override \{#\_perform}.
-    #
-    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-    # @return [Sass::Script::Value] The SassScript object that is the value of the SassScript
-    def perform(environment)
-      _perform(environment)
-    rescue Sass::SyntaxError => e
-      e.modify_backtrace(:line => line)
-      raise e
-    end
-
-    # Returns all child nodes of this node.
-    #
-    # @return [Array<Node>]
-    def children
-      Sass::Util.abstract(self)
-    end
-
-    # Returns the text of this SassScript expression.
-    #
-    # @options opts :quote [String]
-    #   The preferred quote style for quoted strings. If `:none`, strings are
-    #   always emitted unquoted.
-    #
-    # @return [String]
-    def to_sass(opts = {})
-      Sass::Util.abstract(self)
-    end
-
-    # Returns a deep clone of this node.
-    # The child nodes are cloned, but options are not.
-    #
-    # @return [Node]
-    def deep_copy
-      Sass::Util.abstract(self)
-    end
-
-    # Forces any division operations with number literals in this expression to
-    # do real division, rather than returning strings.
-    def force_division!
-      children.each {|c| c.force_division!}
-    end
-
-    protected
-
-    # Converts underscores to dashes if the :dasherize option is set.
-    def dasherize(s, opts)
-      if opts[:dasherize]
-        s.tr('_', '-')
-      else
-        s
-      end
-    end
-
-    # Evaluates this node.
-    # Note that all {Sass::Script::Value} objects created within this method
-    # should have their \{#options} attribute set, probably via \{#opts}.
-    #
-    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-    # @return [Sass::Script::Value] The SassScript object that is the value of the SassScript
-    # @see #perform
-    def _perform(environment)
-      Sass::Util.abstract(self)
-    end
-
-    # Sets the \{#options} field on the given value and returns it.
-    #
-    # @param value [Sass::Script::Value]
-    # @return [Sass::Script::Value]
-    def opts(value)
-      value.options = options
-      value
-    end
-  end
-end

data/bundle/ruby/2.5.0/gems/sass-3.4.25/lib/sass/script/tree/operation.rb

@@ -1,156 +0,0 @@
-module Sass::Script::Tree
-  # A SassScript parse node representing a binary operation,
-  # such as `$a + $b` or `"foo" + 1`.
-  class Operation < Node
-    @@color_arithmetic_deprecation = Sass::Deprecation.new
-    @@unitless_equals_deprecation = Sass::Deprecation.new
-
-    attr_reader :operand1
-    attr_reader :operand2
-    attr_reader :operator
-
-    # @param operand1 [Sass::Script::Tree::Node] The parse-tree node
-    #   for the right-hand side of the operator
-    # @param operand2 [Sass::Script::Tree::Node] The parse-tree node
-    #   for the left-hand side of the operator
-    # @param operator [Symbol] The operator to perform.
-    #   This should be one of the binary operator names in {Sass::Script::Lexer::OPERATORS}
-    def initialize(operand1, operand2, operator)
-      @operand1 = operand1
-      @operand2 = operand2
-      @operator = operator
-      super()
-    end
-
-    # @return [String] A human-readable s-expression representation of the operation
-    def inspect
-      "(#{@operator.inspect} #{@operand1.inspect} #{@operand2.inspect})"
-    end
-
-    # @see Node#to_sass
-    def to_sass(opts = {})
-      o1 = operand_to_sass @operand1, :left, opts
-      o2 = operand_to_sass @operand2, :right, opts
-      sep =
-        case @operator
-        when :comma; ", "
-        when :space; " "
-        else; " #{Sass::Script::Lexer::OPERATORS_REVERSE[@operator]} "
-        end
-      "#{o1}#{sep}#{o2}"
-    end
-
-    # Returns the operands for this operation.
-    #
-    # @return [Array<Node>]
-    # @see Node#children
-    def children
-      [@operand1, @operand2]
-    end
-
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@operand1', @operand1.deep_copy)
-      node.instance_variable_set('@operand2', @operand2.deep_copy)
-      node
-    end
-
-    protected
-
-    # Evaluates the operation.
-    #
-    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-    # @return [Sass::Script::Value] The SassScript object that is the value of the operation
-    # @raise [Sass::SyntaxError] if the operation is undefined for the operands
-    def _perform(environment)
-      value1 = @operand1.perform(environment)
-
-      # Special-case :and and :or to support short-circuiting.
-      if @operator == :and
-        return value1.to_bool ? @operand2.perform(environment) : value1
-      elsif @operator == :or
-        return value1.to_bool ? value1 : @operand2.perform(environment)
-      end
-
-      value2 = @operand2.perform(environment)
-
-      if (value1.is_a?(Sass::Script::Value::Null) || value2.is_a?(Sass::Script::Value::Null)) &&
-          @operator != :eq && @operator != :neq
-        raise Sass::SyntaxError.new(
-          "Invalid null operation: \"#{value1.inspect} #{@operator} #{value2.inspect}\".")
-      end
-
-      if css_variable_warning && @operator == :div &&
-         !(value1.is_a?(Sass::Script::Value::Number) && value1.original &&
-           value2.is_a?(Sass::Script::Value::Number) && value2.original) &&
-         !(value1.is_a?(Sass::Script::Value::String) && value2.is_a?(Sass::Script::Value::String))
-        css_variable_warning.warn!
-      end
-
-      begin
-        result = opts(value1.send(@operator, value2))
-      rescue NoMethodError => e
-        raise e unless e.name.to_s == @operator.to_s
-        raise Sass::SyntaxError.new("Undefined operation: \"#{value1} #{@operator} #{value2}\".")
-      end
-
-      warn_for_color_arithmetic(value1, value2)
-      warn_for_unitless_equals(value1, value2, result)
-
-      result
-    end
-
-    private
-
-    def warn_for_color_arithmetic(value1, value2)
-      return unless @operator == :plus || @operator == :times || @operator == :minus ||
-                    @operator == :div || @operator == :mod
-
-      if value1.is_a?(Sass::Script::Value::Number)
-        return unless value2.is_a?(Sass::Script::Value::Color)
-      elsif value1.is_a?(Sass::Script::Value::Color)
-        return unless value2.is_a?(Sass::Script::Value::Color) || value2.is_a?(Sass::Script::Value::Number)
-      else
-        return
-      end
-
-      @@color_arithmetic_deprecation.warn(filename, line, <<WARNING)
-The operation `#{value1} #{@operator} #{value2}` is deprecated and will be an error in future versions.
-Consider using Sass's color functions instead.
-http://sass-lang.com/documentation/Sass/Script/Functions.html#other_color_functions
-WARNING
-    end
-
-    def warn_for_unitless_equals(value1, value2, result)
-      return unless @operator == :eq || @operator == :neq
-      return unless value1.is_a?(Sass::Script::Value::Number)
-      return unless value2.is_a?(Sass::Script::Value::Number)
-      return unless value1.unitless? != value2.unitless?
-      return unless result == (if @operator == :eq
-                                 Sass::Script::Value::Bool::TRUE
-                               else
-                                 Sass::Script::Value::Bool::FALSE
-                               end)
-
-      operation = "#{value1.to_sass} #{@operator == :eq ? '==' : '!='} #{value2.to_sass}"
-      future_value = @operator == :neq
-      @@unitless_equals_deprecation.warn(filename, line, <<WARNING)
-The result of `#{operation}` will be `#{future_value}` in future releases of Sass.
-Unitless numbers will no longer be equal to the same numbers with units.
-WARNING
-    end
-
-    def operand_to_sass(op, side, opts)
-      return "(#{op.to_sass(opts)})" if op.is_a?(Sass::Script::Tree::ListLiteral)
-      return op.to_sass(opts) unless op.is_a?(Operation)
-
-      pred = Sass::Script::Parser.precedence_of(@operator)
-      sub_pred = Sass::Script::Parser.precedence_of(op.operator)
-      assoc = Sass::Script::Parser.associative?(@operator)
-      return "(#{op.to_sass(opts)})" if sub_pred < pred ||
-        (side == :right && sub_pred == pred && !assoc)
-      op.to_sass(opts)
-    end
-  end
-end