brakeman 4.3.1 → 5.4.0

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

@@ -1,313 +0,0 @@
-require 'sass/script/functions'
-require 'sass/util'
-
-module Sass::Script::Tree
-  # A SassScript parse node representing a function call.
-  #
-  # A function call either calls one of the functions in
-  # {Sass::Script::Functions}, or if no function with the given name exists it
-  # returns a string representation of the function call.
-  class Funcall < Node
-    # The name of the function.
-    #
-    # @return [String]
-    attr_reader :name
-
-    # The arguments to the function.
-    #
-    # @return [Array<Node>]
-    attr_reader :args
-
-    # The keyword arguments to the function.
-    #
-    # @return [Sass::Util::NormalizedMap<Node>]
-    attr_reader :keywords
-
-    # The first splat argument for this function, if one exists.
-    #
-    # This could be a list of positional arguments, a map of keyword
-    # arguments, or an arglist containing both.
-    #
-    # @return [Node?]
-    attr_accessor :splat
-
-    # The second splat argument for this function, if one exists.
-    #
-    # If this exists, it's always a map of keyword arguments, and
-    # \{#splat} is always either a list or an arglist.
-    #
-    # @return [Node?]
-    attr_accessor :kwarg_splat
-
-    # @param name [String] See \{#name}
-    # @param args [Array<Node>] See \{#args}
-    # @param keywords [Sass::Util::NormalizedMap<Node>] See \{#keywords}
-    # @param splat [Node] See \{#splat}
-    # @param kwarg_splat [Node] See \{#kwarg_splat}
-    def initialize(name, args, keywords, splat, kwarg_splat)
-      @name = name
-      @args = args
-      @keywords = keywords
-      @splat = splat
-      @kwarg_splat = kwarg_splat
-      super()
-    end
-
-    # @return [String] A string representation of the function call
-    def inspect
-      args = @args.map {|a| a.inspect}.join(', ')
-      keywords = Sass::Util.hash_to_a(@keywords.as_stored).
-          map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
-      # rubocop:disable RedundantSelf
-      if self.splat
-        splat = args.empty? && keywords.empty? ? "" : ", "
-        splat = "#{splat}#{self.splat.inspect}..."
-        splat = "#{splat}, #{kwarg_splat.inspect}..." if kwarg_splat
-      end
-      # rubocop:enable RedundantSelf
-      "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
-    end
-
-    # @see Node#to_sass
-    def to_sass(opts = {})
-      arg_to_sass = lambda do |arg|
-        sass = arg.to_sass(opts)
-        sass = "(#{sass})" if arg.is_a?(Sass::Script::Tree::ListLiteral) && arg.separator == :comma
-        sass
-      end
-
-      args = @args.map(&arg_to_sass)
-      keywords = Sass::Util.hash_to_a(@keywords.as_stored).
-        map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}
-
-      # rubocop:disable RedundantSelf
-      if self.splat
-        splat = "#{arg_to_sass[self.splat]}..."
-        kwarg_splat = "#{arg_to_sass[self.kwarg_splat]}..." if self.kwarg_splat
-      end
-      # rubocop:enable RedundantSelf
-
-      arglist = [args, splat, keywords, kwarg_splat].flatten.compact.join(', ')
-      "#{dasherize(name, opts)}(#{arglist})"
-    end
-
-    # Returns the arguments to the function.
-    #
-    # @return [Array<Node>]
-    # @see Node#children
-    def children
-      res = @args + @keywords.values
-      res << @splat if @splat
-      res << @kwarg_splat if @kwarg_splat
-      res
-    end
-
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@args', args.map {|a| a.deep_copy})
-      copied_keywords = Sass::Util::NormalizedMap.new
-      @keywords.as_stored.each {|k, v| copied_keywords[k] = v.deep_copy}
-      node.instance_variable_set('@keywords', copied_keywords)
-      node
-    end
-
-    protected
-
-    # Evaluates the function call.
-    #
-    # @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 function call
-    # @raise [Sass::SyntaxError] if the function call raises an ArgumentError
-    def _perform(environment)
-      args = Sass::Util.enum_with_index(@args).
-        map {|a, i| perform_arg(a, environment, signature && signature.args[i])}
-      keywords = Sass::Util.map_hash(@keywords) do |k, v|
-        [k, perform_arg(v, environment, k.tr('-', '_'))]
-      end
-      splat = Sass::Tree::Visitors::Perform.perform_splat(
-        @splat, keywords, @kwarg_splat, environment)
-      if (fn = environment.function(@name))
-        css_variable_warning.warn! if css_variable_warning
-        return without_original(perform_sass_fn(fn, args, splat, environment))
-      end
-
-      args = construct_ruby_args(ruby_name, args, splat, environment)
-
-      if Sass::Script::Functions.callable?(ruby_name)
-        css_variable_warning.warn! if css_variable_warning
-
-        local_environment = Sass::Environment.new(environment.global_env, environment.options)
-        local_environment.caller = Sass::ReadOnlyEnvironment.new(environment, environment.options)
-        result = opts(Sass::Script::Functions::EvaluationContext.new(
-          local_environment).send(ruby_name, *args))
-        without_original(result)
-      else
-        opts(to_literal(args))
-      end
-    rescue ArgumentError => e
-      reformat_argument_error(e)
-    end
-
-    # Compass historically overrode this before it changed name to {Funcall#to_value}.
-    # We should get rid of it in the future.
-    def to_literal(args)
-      to_value(args)
-    end
-
-    # This method is factored out from `_perform` so that compass can override
-    # it with a cross-browser implementation for functions that require vendor prefixes
-    # in the generated css.
-    def to_value(args)
-      Sass::Script::Value::String.new("#{name}(#{args.join(', ')})")
-    end
-
-    private
-
-    def ruby_name
-      @ruby_name ||= @name.tr('-', '_')
-    end
-
-    def perform_arg(argument, environment, name)
-      return argument if signature && signature.delayed_args.include?(name)
-      argument.perform(environment)
-    end
-
-    def signature
-      @signature ||= Sass::Script::Functions.signature(name.to_sym, @args.size, @keywords.size)
-    end
-
-    def without_original(value)
-      return value unless value.is_a?(Sass::Script::Value::Number)
-      value = value.dup
-      value.original = nil
-      value
-    end
-
-    def construct_ruby_args(name, args, splat, environment)
-      args += splat.to_a if splat
-
-      # All keywords are contained in splat.keywords for consistency,
-      # even if there were no splats passed in.
-      old_keywords_accessed = splat.keywords_accessed
-      keywords = splat.keywords
-      splat.keywords_accessed = old_keywords_accessed
-
-      unless (signature = Sass::Script::Functions.signature(name.to_sym, args.size, keywords.size))
-        return args if keywords.empty?
-        raise Sass::SyntaxError.new("Function #{name} doesn't support keyword arguments")
-      end
-
-      # If the user passes more non-keyword args than the function expects,
-      # but it does expect keyword args, Ruby's arg handling won't raise an error.
-      # Since we don't want to make functions think about this,
-      # we'll handle it for them here.
-      if signature.var_kwargs && !signature.var_args && args.size > signature.args.size
-        raise Sass::SyntaxError.new(
-          "#{args[signature.args.size].inspect} is not a keyword argument for `#{name}'")
-      elsif keywords.empty?
-        return args
-      end
-
-      argnames = signature.args[args.size..-1] || []
-      deprecated_argnames = (signature.deprecated && signature.deprecated[args.size..-1]) || []
-      args += argnames.zip(deprecated_argnames).map do |(argname, deprecated_argname)|
-        if keywords.has_key?(argname)
-          keywords.delete(argname)
-        elsif deprecated_argname && keywords.has_key?(deprecated_argname)
-          deprecated_argname = keywords.denormalize(deprecated_argname)
-          Sass::Util.sass_warn("DEPRECATION WARNING: The `$#{deprecated_argname}' argument for " +
-            "`#{@name}()' has been renamed to `$#{argname}'.")
-          keywords.delete(deprecated_argname)
-        else
-          raise Sass::SyntaxError.new("Function #{name} requires an argument named $#{argname}")
-        end
-      end
-
-      if keywords.size > 0
-        if signature.var_kwargs
-          # Don't pass a NormalizedMap to a Ruby function.
-          args << keywords.to_hash
-        else
-          argname = keywords.keys.sort.first
-          if signature.args.include?(argname)
-            raise Sass::SyntaxError.new(
-              "Function #{name} was passed argument $#{argname} both by position and by name")
-          else
-            raise Sass::SyntaxError.new(
-              "Function #{name} doesn't have an argument named $#{argname}")
-          end
-        end
-      end
-
-      args
-    end
-
-    def perform_sass_fn(function, args, splat, environment)
-      Sass::Tree::Visitors::Perform.perform_arguments(function, args, splat, environment) do |env|
-        env.caller = Sass::Environment.new(environment)
-
-        val = catch :_sass_return do
-          function.tree.each {|c| Sass::Tree::Visitors::Perform.visit(c, env)}
-          raise Sass::SyntaxError.new("Function #{@name} finished without @return")
-        end
-        val
-      end
-    end
-
-    def reformat_argument_error(e)
-      message = e.message
-
-      # If this is a legitimate Ruby-raised argument error, re-raise it.
-      # Otherwise, it's an error in the user's stylesheet, so wrap it.
-      if Sass::Util.rbx?
-        # Rubinius has a different error report string than vanilla Ruby. It
-        # also doesn't put the actual method for which the argument error was
-        # thrown in the backtrace, nor does it include `send`, so we look for
-        # `_perform`.
-        if e.message =~ /^method '([^']+)': given (\d+), expected (\d+)/
-          error_name, given, expected = $1, $2, $3
-          raise e if error_name != ruby_name || e.backtrace[0] !~ /:in `_perform'$/
-          message = "wrong number of arguments (#{given} for #{expected})"
-        end
-      elsif Sass::Util.jruby?
-        if Sass::Util.jruby1_6?
-          should_maybe_raise = e.message =~ /^wrong number of arguments \((\d+) for (\d+)\)/ &&
-            # The one case where JRuby does include the Ruby name of the function
-            # is manually-thrown ArgumentErrors, which are indistinguishable from
-            # legitimate ArgumentErrors. We treat both of these as
-            # Sass::SyntaxErrors even though it can hide Ruby errors.
-            e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
-        else
-          should_maybe_raise =
-            e.message =~ /^wrong number of arguments calling `[^`]+` \((\d+) for (\d+)\)/
-          given, expected = $1, $2
-        end
-
-        if should_maybe_raise
-          # JRuby 1.7 includes __send__ before send and _perform.
-          trace = e.backtrace.dup
-          raise e if !Sass::Util.jruby1_6? && trace.shift !~ /:in `__send__'$/
-
-          # JRuby (as of 1.7.2) doesn't put the actual method
-          # for which the argument error was thrown in the backtrace, so we
-          # detect whether our send threw an argument error.
-          if !(trace[0] =~ /:in `send'$/ && trace[1] =~ /:in `_perform'$/)
-            raise e
-          elsif !Sass::Util.jruby1_6?
-            # JRuby 1.7 doesn't use standard formatting for its ArgumentErrors.
-            message = "wrong number of arguments (#{given} for #{expected})"
-          end
-        end
-      elsif (md = /^wrong number of arguments \(given (\d+), expected (\d+)\)/.match(e.message)) &&
-            e.backtrace[0] =~ /:in `#{ruby_name}'$/
-        # Handle ruby 2.3 error formatting
-        message = "wrong number of arguments (#{md[1]} for #{md[2]})"
-      elsif e.message =~ /^wrong number of arguments/ &&
-            e.backtrace[0] !~ /:in `(block in )?#{ruby_name}'$/
-        raise e
-      end
-      raise Sass::SyntaxError.new("#{message} for `#{name}'")
-    end
-  end
-end

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

@@ -1,223 +0,0 @@
-module Sass::Script::Tree
-  # A SassScript object representing `#{}` interpolation outside a string.
-  #
-  # @see StringInterpolation
-  class Interpolation < Node
-    # @return [Node] The SassScript before the interpolation
-    attr_reader :before
-
-    # @return [Node] The SassScript within the interpolation
-    attr_reader :mid
-
-    # @return [Node] The SassScript after the interpolation
-    attr_reader :after
-
-    # @return [Boolean] Whether there was whitespace between `before` and `#{`
-    attr_reader :whitespace_before
-
-    # @return [Boolean] Whether there was whitespace between `}` and `after`
-    attr_reader :whitespace_after
-
-    # @return [Boolean] Whether the original format of the interpolation was
-    #   plain text, not an interpolation. This is used when converting back to
-    #   SassScript.
-    attr_reader :originally_text
-
-    # @return [Boolean] Whether a color value passed to the interpolation should
-    #   generate a warning.
-    attr_reader :warn_for_color
-
-    # The type of interpolation deprecation for this node.
-    #
-    # This can be `:none`, indicating that the node doesn't use deprecated
-    # interpolation; `:immediate`, indicating that a deprecation warning should
-    # be emitted as soon as possible; or `:potential`, indicating that a
-    # deprecation warning should be emitted if the resulting string is used in a
-    # way that would distinguish it from a list.
-    #
-    # @return [Symbol]
-    attr_reader :deprecation
-
-    # Interpolation in a property is of the form `before #{mid} after`.
-    #
-    # @param before [Node] See {Interpolation#before}
-    # @param mid [Node] See {Interpolation#mid}
-    # @param after [Node] See {Interpolation#after}
-    # @param wb [Boolean] See {Interpolation#whitespace_before}
-    # @param wa [Boolean] See {Interpolation#whitespace_after}
-    # @param originally_text [Boolean] See {Interpolation#originally_text}
-    # @param warn_for_color [Boolean] See {Interpolation#warn_for_color}
-    # @comment
-    #   rubocop:disable ParameterLists
-    def initialize(before, mid, after, wb, wa, opts = {})
-      # rubocop:enable ParameterLists
-      @before = before
-      @mid = mid
-      @after = after
-      @whitespace_before = wb
-      @whitespace_after = wa
-      @originally_text = opts[:originally_text] || false
-      @warn_for_color = opts[:warn_for_color] || false
-      @deprecation = opts[:deprecation] || :none
-    end
-
-    # @return [String] A human-readable s-expression representation of the interpolation
-    def inspect
-      "(interpolation #{@before.inspect} #{@mid.inspect} #{@after.inspect})"
-    end
-
-    # @see Node#to_sass
-    def to_sass(opts = {})
-      return to_quoted_equivalent.to_sass if deprecation == :immediate
-
-      res = ""
-      res << @before.to_sass(opts) if @before
-      res << ' ' if @before && @whitespace_before
-      res << '#{' unless @originally_text
-      res << @mid.to_sass(opts)
-      res << '}' unless @originally_text
-      res << ' ' if @after && @whitespace_after
-      res << @after.to_sass(opts) if @after
-      res
-    end
-
-    # Returns an `unquote()` expression that will evaluate to the same value as
-    # this interpolation.
-    #
-    # @return [Sass::Script::Tree::Node]
-    def to_quoted_equivalent
-      Funcall.new(
-        "unquote",
-        [to_string_interpolation(self)],
-        Sass::Util::NormalizedMap.new,
-        nil,
-        nil)
-    end
-
-    # Returns the three components of the interpolation, `before`, `mid`, and `after`.
-    #
-    # @return [Array<Node>]
-    # @see #initialize
-    # @see Node#children
-    def children
-      [@before, @mid, @after].compact
-    end
-
-    # @see Node#deep_copy
-    def deep_copy
-      node = dup
-      node.instance_variable_set('@before', @before.deep_copy) if @before
-      node.instance_variable_set('@mid', @mid.deep_copy)
-      node.instance_variable_set('@after', @after.deep_copy) if @after
-      node
-    end
-
-    protected
-
-    # Converts a script node into a corresponding string interpolation
-    # expression.
-    #
-    # @param node_or_interp [Sass::Script::Tree::Node]
-    # @return [Sass::Script::Tree::StringInterpolation]
-    def to_string_interpolation(node_or_interp)
-      unless node_or_interp.is_a?(Interpolation)
-        node = node_or_interp
-        return string_literal(node.value.to_s) if node.is_a?(Literal)
-        if node.is_a?(StringInterpolation)
-          return concat(string_literal(node.quote), concat(node, string_literal(node.quote)))
-        end
-        return StringInterpolation.new(string_literal(""), node, string_literal(""))
-      end
-
-      interp = node_or_interp
-      after_string_or_interp =
-        if interp.after
-          to_string_interpolation(interp.after)
-        else
-          string_literal("")
-        end
-      if interp.after && interp.whitespace_after
-        after_string_or_interp = concat(string_literal(' '), after_string_or_interp)
-      end
-
-      mid_string_or_interp = to_string_interpolation(interp.mid)
-
-      before_string_or_interp =
-        if interp.before
-          to_string_interpolation(interp.before)
-        else
-          string_literal("")
-        end
-      if interp.before && interp.whitespace_before
-        before_string_or_interp = concat(before_string_or_interp, string_literal(' '))
-      end
-
-      concat(before_string_or_interp, concat(mid_string_or_interp, after_string_or_interp))
-    end
-
-    private
-
-    # Evaluates the interpolation.
-    #
-    # @param environment [Sass::Environment] The environment in which to evaluate the SassScript
-    # @return [Sass::Script::Value::String]
-    #   The SassScript string that is the value of the interpolation
-    def _perform(environment)
-      res = ""
-      res << @before.perform(environment).to_s if @before
-      res << " " if @before && @whitespace_before
-
-      val = @mid.perform(environment)
-      if @warn_for_color && val.is_a?(Sass::Script::Value::Color) && val.name
-        alternative = Operation.new(Sass::Script::Value::String.new("", :string), @mid, :plus)
-        Sass::Util.sass_warn <<MESSAGE
-WARNING on line #{line}, column #{source_range.start_pos.offset}#{" of #{filename}" if filename}:
-You probably don't mean to use the color value `#{val}' in interpolation here.
-It may end up represented as #{val.inspect}, which will likely produce invalid CSS.
-Always quote color names when using them as strings (for example, "#{val}").
-If you really want to use the color value here, use `#{alternative.to_sass}'.
-MESSAGE
-      end
-
-      res << val.to_s(:quote => :none)
-      res << " " if @after && @whitespace_after
-      res << @after.perform(environment).to_s if @after
-      str = Sass::Script::Value::String.new(
-        res, :identifier,
-        (to_quoted_equivalent.to_sass if deprecation == :potential))
-      str.source_range = source_range
-      opts(str)
-    end
-
-    # Concatenates two string literals or string interpolation expressions.
-    #
-    # @param string_or_interp1 [Sass::Script::Tree::Literal|Sass::Script::Tree::StringInterpolation]
-    # @param string_or_interp2 [Sass::Script::Tree::Literal|Sass::Script::Tree::StringInterpolation]
-    # @return [Sass::Script::Tree::StringInterpolation]
-    def concat(string_or_interp1, string_or_interp2)
-      if string_or_interp1.is_a?(Literal) && string_or_interp2.is_a?(Literal)
-        return string_literal(string_or_interp1.value.value + string_or_interp2.value.value)
-      end
-
-      if string_or_interp1.is_a?(Literal)
-        string = string_or_interp1
-        interp = string_or_interp2
-        before = string_literal(string.value.value + interp.before.value.value)
-        return StringInterpolation.new(before, interp.mid, interp.after)
-      end
-
-      StringInterpolation.new(
-        string_or_interp1.before,
-        string_or_interp1.mid,
-        concat(string_or_interp1.after, string_or_interp2))
-    end
-
-    # Returns a string literal with the given contents.
-    #
-    # @param string [String]
-    # @return string [Sass::Script::Tree::Literal]
-    def string_literal(string)
-      Literal.new(Sass::Script::Value::String.new(string, :string))
-    end
-  end
-end

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