0UT1S's

opt/alt/ruby26/lib64/ruby/2.6.0/bundler/vendor/thor/lib/thor/core_ext/

By Order of Mr.0UT1S

[DIR] ..

N/A

hash_with_indifferent_access.rb

2.12 KB

io_binary_read.rb

308 bytes

ordered_hash.rb

2.59 KB

class Bundler::Thor
  module CoreExt
    class OrderedHash < ::Hash
      if RUBY_VERSION < "1.9"
        def initialize(*args, &block)
          super
          @keys = []
        end

def initialize_copy(other)
          super
          # make a deep copy of keys
          @keys = other.keys
        end

def []=(key, value)
          @keys << key unless key?(key)
          super
        end

def delete(key)
          if key? key
            index = @keys.index(key)
            @keys.delete_at index
          end
          super
        end

def delete_if
          super
          sync_keys!
          self
        end

alias_method :reject!, :delete_if

def reject(&block)
          dup.reject!(&block)
        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, &block)
          dup.merge!(other_hash, &block)
        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 inspect
          "#<#{self.class} #{super}>"
        end

private

def sync_keys!
          @keys.delete_if { |k| !key?(k) }
        end
      end
    end
  end
end