class Bundler::Checksum::Store - bundler: Ruby Standard Library Documentation

# class Bundler::Checksum::Store

### Attributes

store[R]

### Public Class Methods

new() click to toggle source

    # File bundler/checksum.rb, line 170
    def initialize
      @store = {}
      @store_mutex = Mutex.new
    end

### Public Instance Methods

inspect() click to toggle source

    # File bundler/checksum.rb, line 175
    def inspect
      "#<#{self.class}:#{object_id} size=#{store.size}>"
    end

merge!(other) click to toggle source

    # File bundler/checksum.rb, line 210
    def merge!(other)
      other.store.each do |lock_name, checksums|
        checksums.each do |_algo, checksum|
          register_checksum(lock_name, checksum)
        end
      end
    end

register(spec, checksum) click to toggle source

    # File bundler/checksum.rb, line 204
    def register(spec, checksum)
      return unless checksum

      register_checksum(spec.name_tuple.lock_name, checksum)
    end

replace(spec, checksum) click to toggle source

Replace when the new checksum is from the same source. The primary purpose is registering checksums from gems where there are duplicates of the same gem (according to full_name) in the index.

In particular, this is when 2 gems have two similar platforms, e.g. “darwin20” and “darwin-20”, both of which resolve to darwin-20. In the `Index`, the later gem replaces the former, so we do that here.

However, if the new checksum is from a different source, we register like normal. This ensures a mismatch error where there are multiple top level sources that contain the same gem with different checksums.

    # File bundler/checksum.rb, line 190
    def replace(spec, checksum)
      return unless checksum

      lock_name = spec.name_tuple.lock_name
      @store_mutex.synchronize do
        existing = fetch_checksum(lock_name, checksum.algo)
        if !existing || existing.same_source?(checksum)
          store_checksum(lock_name, checksum)
        else
          merge_checksum(lock_name, checksum, existing)
        end
      end
    end

to_lock(spec) click to toggle source

    # File bundler/checksum.rb, line 218
    def to_lock(spec)
      lock_name = spec.name_tuple.lock_name
      checksums = @store[lock_name]
      if checksums
        "#{lock_name} #{checksums.values.map(&:to_lock).sort.join(",")}"
      else
        lock_name
      end
    end

### Private Instance Methods

fetch_checksum(lock_name, algo) click to toggle source

    # File bundler/checksum.rb, line 249
    def fetch_checksum(lock_name, algo)
      @store[lock_name]&.fetch(algo, nil)
    end

merge_checksum(lock_name, checksum, existing) click to toggle source

    # File bundler/checksum.rb, line 241
    def merge_checksum(lock_name, checksum, existing)
      existing.merge!(checksum) || raise(ChecksumMismatchError.new(lock_name, existing, checksum))
    end

register_checksum(lock_name, checksum) click to toggle source

    # File bundler/checksum.rb, line 230
    def register_checksum(lock_name, checksum)
      @store_mutex.synchronize do
        existing = fetch_checksum(lock_name, checksum.algo)
        if existing
          merge_checksum(lock_name, checksum, existing)
        else
          store_checksum(lock_name, checksum)
        end
      end
    end

store_checksum(lock_name, checksum) click to toggle source

    # File bundler/checksum.rb, line 245
    def store_checksum(lock_name, checksum)
      (@store[lock_name] ||= {})[checksum.algo] = checksum
    end