brakeman 3.2.1 → 3.3.0

data/bundle/ruby/2.3.0/gems/sass-3.4.22/lib/sass/util/cross_platform_random.rb

@@ -0,0 +1,19 @@
+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.3.0/gems/sass-3.4.22/lib/sass/util/multibyte_string_scanner.rb

@@ -0,0 +1,155 @@
+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.3.0/gems/sass-3.4.22/lib/sass/util/normalized_map.rb

@@ -0,0 +1,129 @@
+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.3.0/gems/sass-3.4.22/lib/sass/util/ordered_hash.rb

@@ -0,0 +1,192 @@
+# 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