brakeman 4.4.0 → 5.0.0

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

@@ -1,19 +0,0 @@
-module Sass
-  module Util
-    # Ruby 1.8 doesn't support an actual Random class with a settable seed.
-    class CrossPlatformRandom
-      def initialize(seed = nil)
-        if Sass::Util.ruby1_8?
-          srand(seed) if seed
-        else
-          @random = seed ? ::Random.new(seed) : ::Random.new
-        end
-      end
-
-      def rand(*args)
-        return @random.rand(*args) if @random
-        Kernel.rand(*args)
-      end
-    end
-  end
-end

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

@@ -1,155 +0,0 @@
-require 'strscan'
-
-if Sass::Util.ruby1_8?
-  Sass::Util::MultibyteStringScanner = StringScanner
-else
-  if Sass::Util.rbx?
-    # Rubinius's StringScanner class implements some of its methods in terms of
-    # others, which causes us to double-count bytes in some cases if we do
-    # straightforward inheritance. To work around this, we use a delegate class.
-    require 'delegate'
-    class Sass::Util::MultibyteStringScanner < DelegateClass(StringScanner)
-      def initialize(str)
-        super(StringScanner.new(str))
-        @mb_pos = 0
-        @mb_matched_size = nil
-        @mb_last_pos = nil
-      end
-
-      def is_a?(klass)
-        __getobj__.is_a?(klass) || super
-      end
-    end
-  else
-    class Sass::Util::MultibyteStringScanner < StringScanner
-      def initialize(str)
-        super
-        @mb_pos = 0
-        @mb_matched_size = nil
-        @mb_last_pos = nil
-      end
-    end
-  end
-
-  # A wrapper of the native StringScanner class that works correctly with
-  # multibyte character encodings. The native class deals only in bytes, not
-  # characters, for methods like [#pos] and [#matched_size]. This class deals
-  # only in characters, instead.
-  class Sass::Util::MultibyteStringScanner
-    def self.new(str)
-      return StringScanner.new(str) if str.ascii_only?
-      super
-    end
-
-    alias_method :byte_pos, :pos
-    alias_method :byte_matched_size, :matched_size
-
-    def check(pattern); _match super; end
-    def check_until(pattern); _matched super; end
-    def getch; _forward _match super; end
-    def match?(pattern); _size check(pattern); end
-    def matched_size; @mb_matched_size; end
-    def peek(len); string[@mb_pos, len]; end
-    alias_method :peep, :peek
-    def pos; @mb_pos; end
-    alias_method :pointer, :pos
-    def rest_size; rest.size; end
-    def scan(pattern); _forward _match super; end
-    def scan_until(pattern); _forward _matched super; end
-    def skip(pattern); _size scan(pattern); end
-    def skip_until(pattern); _matched _size scan_until(pattern); end
-
-    def get_byte
-      raise "MultibyteStringScanner doesn't support #get_byte."
-    end
-
-    def getbyte
-      raise "MultibyteStringScanner doesn't support #getbyte."
-    end
-
-    def pos=(n)
-      @mb_last_pos = nil
-
-      # We set position kind of a lot during parsing, so we want it to be as
-      # efficient as possible. This is complicated by the fact that UTF-8 is a
-      # variable-length encoding, so it's difficult to find the byte length that
-      # corresponds to a given character length.
-      #
-      # Our heuristic here is to try to count the fewest possible characters. So
-      # if the new position is close to the current one, just count the
-      # characters between the two; if the new position is closer to the
-      # beginning of the string, just count the characters from there.
-      if @mb_pos - n < @mb_pos / 2
-        # New position is close to old position
-        byte_delta = @mb_pos > n ? -string[n...@mb_pos].bytesize : string[@mb_pos...n].bytesize
-        super(byte_pos + byte_delta)
-      else
-        # New position is close to BOS
-        super(string[0...n].bytesize)
-      end
-      @mb_pos = n
-    end
-
-    def reset
-      @mb_pos = 0
-      @mb_matched_size = nil
-      @mb_last_pos = nil
-      super
-    end
-
-    def scan_full(pattern, advance_pointer_p, return_string_p)
-      res = _match super(pattern, advance_pointer_p, true)
-      _forward res if advance_pointer_p
-      return res if return_string_p
-    end
-
-    def search_full(pattern, advance_pointer_p, return_string_p)
-      res = super(pattern, advance_pointer_p, true)
-      _forward res if advance_pointer_p
-      _matched((res if return_string_p))
-    end
-
-    def string=(str)
-      @mb_pos = 0
-      @mb_matched_size = nil
-      @mb_last_pos = nil
-      super
-    end
-
-    def terminate
-      @mb_pos = string.size
-      @mb_matched_size = nil
-      @mb_last_pos = nil
-      super
-    end
-    alias_method :clear, :terminate
-
-    def unscan
-      super
-      @mb_pos = @mb_last_pos
-      @mb_last_pos = @mb_matched_size = nil
-    end
-
-    private
-
-    def _size(str)
-      str && str.size
-    end
-
-    def _match(str)
-      @mb_matched_size = str && str.size
-      str
-    end
-
-    def _matched(res)
-      _match matched
-      res
-    end
-
-    def _forward(str)
-      @mb_last_pos = @mb_pos
-      @mb_pos += str.size if str
-      str
-    end
-  end
-end

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

@@ -1,129 +0,0 @@
-require 'delegate'
-
-module Sass
-  module Util
-    # A hash that normalizes its string keys while still allowing you to get back
-    # to the original keys that were stored. If several different values normalize
-    # to the same value, whichever is stored last wins.
-    require 'sass/util/ordered_hash' if ruby1_8?
-    class NormalizedMap
-      # Create a normalized map
-      def initialize(map = nil)
-        @key_strings = {}
-        @map = Util.ruby1_8? ? OrderedHash.new : {}
-
-        map.each {|key, value| self[key] = value} if map
-      end
-
-      # Specifies how to transform the key.
-      #
-      # This can be overridden to create other normalization behaviors.
-      def normalize(key)
-        key.tr("-", "_")
-      end
-
-      # Returns the version of `key` as it was stored before
-      # normalization. If `key` isn't in the map, returns it as it was
-      # passed in.
-      #
-      # @return [String]
-      def denormalize(key)
-        @key_strings[normalize(key)] || key
-      end
-
-      # @private
-      def []=(k, v)
-        normalized = normalize(k)
-        @map[normalized] = v
-        @key_strings[normalized] = k
-        v
-      end
-
-      # @private
-      def [](k)
-        @map[normalize(k)]
-      end
-
-      # @private
-      def has_key?(k)
-        @map.has_key?(normalize(k))
-      end
-
-      # @private
-      def delete(k)
-        normalized = normalize(k)
-        @key_strings.delete(normalized)
-        @map.delete(normalized)
-      end
-
-      # @return [Hash] Hash with the keys as they were stored (before normalization).
-      def as_stored
-        Sass::Util.map_keys(@map) {|k| @key_strings[k]}
-      end
-
-      def empty?
-        @map.empty?
-      end
-
-      def values
-        @map.values
-      end
-
-      def keys
-        @map.keys
-      end
-
-      def each
-        @map.each {|k, v| yield(k, v)}
-      end
-
-      def size
-        @map.size
-      end
-
-      def to_hash
-        @map.dup
-      end
-
-      def to_a
-        @map.to_a
-      end
-
-      def map
-        @map.map {|k, v| yield(k, v)}
-      end
-
-      def dup
-        d = super
-        d.send(:instance_variable_set, "@map", @map.dup)
-        d
-      end
-
-      def sort_by
-        @map.sort_by {|k, v| yield k, v}
-      end
-
-      def update(map)
-        map = map.as_stored if map.is_a?(NormalizedMap)
-        map.each {|k, v| self[k] = v}
-      end
-
-      def method_missing(method, *args, &block)
-        if Sass.tests_running
-          raise ArgumentError.new("The method #{method} must be implemented explicitly")
-        end
-        @map.send(method, *args, &block)
-      end
-
-      if Sass::Util.ruby1_8?
-        def respond_to?(method, include_private = false)
-          super || @map.respond_to?(method, include_private)
-        end
-      end
-
-      def respond_to_missing?(method, include_private = false)
-        @map.respond_to?(method, include_private)
-      end
-    end
-  end
-end

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

@@ -1,192 +0,0 @@
-# Copyright (c) 2005-2013 David Heinemeier Hansson
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-# This class was copied from an old version of ActiveSupport.
-class OrderedHash < ::Hash
-  # In MRI the Hash class is core and written in C. In particular, methods are
-  # programmed with explicit C function calls and polymorphism is not honored.
-  #
-  # For example, []= is crucial in this implementation to maintain the @keys
-  # array but hash.c invokes rb_hash_aset() originally. This prevents method
-  # reuse through inheritance and forces us to reimplement stuff.
-  #
-  # For instance, we cannot use the inherited #merge! because albeit the algorithm
-  # itself would work, our []= is not being called at all by the C code.
-
-  def initialize(*args)
-    super
-    @keys = []
-  end
-
-  def self.[](*args)
-    ordered_hash = new
-
-    if args.length == 1 && args.first.is_a?(Array)
-      args.first.each do |key_value_pair|
-        next unless key_value_pair.is_a?(Array)
-        ordered_hash[key_value_pair[0]] = key_value_pair[1]
-      end
-
-      return ordered_hash
-    end
-
-    unless args.size.even?
-      raise ArgumentError.new("odd number of arguments for Hash")
-    end
-
-    args.each_with_index do |val, ind|
-      next if ind.odd?
-      ordered_hash[val] = args[ind + 1]
-    end
-
-    ordered_hash
-  end
-
-  def initialize_copy(other)
-    super
-    # make a deep copy of keys
-    @keys = other.keys
-  end
-
-  def []=(key, value)
-    @keys << key unless has_key?(key)
-    super
-  end
-
-  def delete(key)
-    if has_key? key
-      index = @keys.index(key)
-      @keys.delete_at index
-    end
-    super
-  end
-
-  def delete_if
-    super
-    sync_keys!
-    self
-  end
-
-  def reject!
-    super
-    sync_keys!
-    self
-  end
-
-  def reject
-    dup.reject! {|h, k| yield h, k}
-  end
-
-  def keys
-    @keys.dup
-  end
-
-  def values
-    @keys.map {|key| self[key]}
-  end
-
-  def to_hash
-    self
-  end
-
-  def to_a
-    @keys.map {|key| [key, self[key]]}
-  end
-
-  def each_key
-    return to_enum(:each_key) unless block_given?
-    @keys.each {|key| yield key}
-    self
-  end
-
-  def each_value
-    return to_enum(:each_value) unless block_given?
-    @keys.each {|key| yield self[key]}
-    self
-  end
-
-  def each
-    return to_enum(:each) unless block_given?
-    @keys.each {|key| yield [key, self[key]]}
-    self
-  end
-
-  def each_pair
-    return to_enum(:each_pair) unless block_given?
-    @keys.each {|key| yield key, self[key]}
-    self
-  end
-
-  alias_method :select, :find_all
-
-  def clear
-    super
-    @keys.clear
-    self
-  end
-
-  def shift
-    k = @keys.first
-    v = delete(k)
-    [k, v]
-  end
-
-  def merge!(other_hash)
-    if block_given?
-      other_hash.each {|k, v| self[k] = key?(k) ? yield(k, self[k], v) : v}
-    else
-      other_hash.each {|k, v| self[k] = v}
-    end
-    self
-  end
-
-  alias_method :update, :merge!
-
-  def merge(other_hash)
-    if block_given?
-      dup.merge!(other_hash) {|k, v1, v2| yield k, v1, v2}
-    else
-      dup.merge!(other_hash)
-    end
-  end
-
-  # When replacing with another hash, the initial order of our keys must come from the other hash --
-  # ordered or not.
-  def replace(other)
-    super
-    @keys = other.keys
-    self
-  end
-
-  def invert
-    OrderedHash[to_a.map! {|key_value_pair| key_value_pair.reverse}]
-  end
-
-  def inspect
-    "#<OrderedHash #{super}>"
-  end
-
-  private
-
-  def sync_keys!
-    @keys.delete_if {|k| !has_key?(k)}
-  end
-end