oci_registry 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 929ac794aafd238965aad937e7f2a1cb197986e582893d5e4051c93e0098a88a
+  data.tar.gz: 64e51f1abdbd0176f6d337a72b4c1bd1e261f3c9f599aaddd78311caadcd3070
+SHA512:
+  metadata.gz: b41dbb62fb262b588b43d5503c782a3d43857dc4b79dceed24e428666910f88bdaaabde7c6fccc957cfa9b661f1aad11d07e5dce5f3bd73c870846ed382299e3
+  data.tar.gz: a5f268cfae9dd9372f7ff8a62c9c5cef9514969e2d96ab14c1f203e28cb0df6e5c38d2486a57dcd9e50dcb51e56716b2b107efe2b4767d633d93323a9b9df200

data/CHANGELOG.md

@@ -0,0 +1,14 @@
+# Changelog
+
+## [0.1.0] - 2024-07-30
+
+### Added
+- Initial release
+- OCI/Docker registry client for interacting with registries
+- Support for authentication (username/password and token)
+- URI parser for Docker/OCI URIs
+- Utility functions for working with images and layers
+- Support for manifest operations
+- Support for tag listing
+- Support for blob operations
+- Support for image copying between registries

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OCIRegistry Contributors
+
+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.

data/README.md

@@ -0,0 +1,87 @@
+# OCI Registry
+
+A Ruby library for interacting with OCI/Docker registries using the native HTTP/tar/sha format to navigate repositories and retrieve tags, metadata and other useful information.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'oci_registry'
+```
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+### Client
+
+```ruby
+# Create a client for Docker Hub
+client = OCIRegistry::Client.new(username: 'user', password: 'pass')
+
+# Create a client for Google Container Registry
+client = OCIRegistry::Client.new(token: 'access-token', host: 'gcr.io')
+
+# Get image metadata
+metadata = client.metadata('library/nginx', 'latest')
+
+# List tags
+client.tags('library/nginx') do |tag|
+  puts tag
+end
+
+# Get manifest
+manifest = client.manifest('library/nginx', 'latest')
+
+# Download and extract layers
+layers = manifest['layers']
+client.download_and_extract_layers('library/nginx', layers, 'config.json')
+```
+
+### URI Parser
+
+```ruby
+# Parse Docker/OCI URIs
+uri = OCIRegistry::URI.new('docker://docker.io/library/nginx:latest')
+puts uri.repository # => "library/nginx"
+puts uri.tag        # => "latest"
+puts uri.host       # => "docker.io"
+```
+
+### Utils
+
+```ruby
+# Write skopeo policy file
+OCIRegistry::Utils.write_policy(filename: "policy.json")
+
+# Calculate SHA256 of a file
+sha = OCIRegistry::Utils.calculate_sha256("/path/to/file")
+
+# Sum layers from skopeo inspect output
+size = OCIRegistry::Utils.sum_layers(skopeo_inspect_json)
+
+# Copy image between registries
+digest = OCIRegistry::Utils.copy_image(
+  src_user: "user1", src_pass: "pass1",
+  dst_user: "user2", dst_pass: "pass2",
+  src_oci: "docker.io/library/nginx",
+  src_commit: "latest",
+  dst_oci: "my-registry.com/nginx",
+  dst_commit: "latest"
+)
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
+
+## Contributing
+
+Bug reports and pull requests are welcome.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/oci_registry/client.rb

@@ -0,0 +1,57 @@
+module OCIRegistry
+  class Client
+    attr_accessor :username, :password, :token, :host
+    def initialize(username: nil, password: nil, token: nil, host: 'registry-1.docker.io')
+      # Main Execution Flow
+      @username  = username
+      @password  = password
+      @token     = token # e.g. gcloud auth print-access-token
+      @tokens    = {}
+      @manifests = {}
+      @host      = host
+    end
+    def metadata(repository, tag)
+      manifest            = self.manifest(repository, tag)
+      case manifest['mediaType']
+      when "application/vnd.docker.distribution.manifest.list.v2+json"
+        # Multi-arch images have a manifest list
+        manifest = manifest['manifests'].find { |m| m['platform']['architecture'] == 'amd64' && m['platform']['os'] == 'linux' }
+        self.metadata(repository, manifest['digest'])
+      when "application/vnd.docker.distribution.manifest.v2+json"
+        # Builders
+        blob_digest = manifest['config']['digest']
+        OCIRegistry::Remote.get_blob(host, self.token(repository), repository, blob_digest)
+      when "application/vnd.oci.image.index.v1+json"
+        # Buildpacks give a collection of manifests as an index if they are multi-arch:
+        manifest = manifest['manifests'].find { |s| s['platform']['architecture'] == 'amd64' && s['platform']['os'] == 'linux' }
+        self.metadata(repository, manifest['digest'])
+      when "application/vnd.oci.image.manifest.v1+json"
+        # OCI Images
+        blob_digest = manifest['config']['digest']
+        OCIRegistry::Remote.get_blob(host, self.token(repository), repository, blob_digest)
+      else
+        raise "Unknown manifest type: #{manifest['mediaType']}"
+      end
+    end
+    def token(repository)
+      return @token if @token # e.g. Google Container Registry
+      @tokens[repository] = OCIRegistry::Remote.get_docker_token(repository, @username, @password)
+    end
+    def manifest(repository, tag)
+      slug = "#{repository}:#{tag}"
+      @manifests[slug]    = OCIRegistry::Remote.get_manifest(self.host, self.token(repository), repository, tag)
+    end
+    def tags(repository, &block)
+      tags = OCIRegistry::Remote.get_tags(self.host, self.token(repository), repository)
+      return tags.each(&block) if block_given?
+      tags
+    end
+    def download_and_extract_layers(repository, layers, file_name)
+      OCIRegistry::Remote.download_and_extract_layers(host, self.token(repository), repository, layers, file_name)
+    end
+    def ping
+      # ping the api
+      OCIRegistry::Remote.http_get(URI("https://#{host}/v2/"), { 'Authorization' => "Bearer #{@token}" })
+    end
+  end
+end

data/lib/oci_registry/remote.rb

@@ -0,0 +1,193 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'optparse'
+require 'base64'
+require 'zlib'
+require 'minitar'
+require 'stringio'
+require 'fileutils'
+
+
+module OCIRegistry
+  class Remote
+
+    # Helper method to handle HTTP GET requests with redirect support
+    def self.http_get(uri, headers = {}, limit = 10)
+      raise 'Too many HTTP redirects' if limit == 0
+
+      request = Net::HTTP::Get.new(uri)
+      headers.each { |k, v| request[k] = v }
+
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http.request(request)
+      end
+
+      case response
+      when Net::HTTPRedirection
+        location = response['location']
+        # warn "Redirected to #{location}"
+        # Handle the case where location is a relative URL by reconstructing the full URL
+        new_uri = ::URI.join(uri, location)
+        http_get(new_uri, headers, limit - 1)
+      # 429
+      when Net::HTTPTooManyRequests
+        puts "Rate limited: #{response.code} #{response.message}"
+        # Retry after the specified time
+        retry_after = response['Retry-After'].to_i || 10
+        sleep(retry_after)
+        http_get(uri, headers, limit - 1)
+      else
+        response
+      end
+    end
+
+    # Step 1: Obtain an Access Token
+    def self.get_docker_token(repository, username = nil, password = nil)
+      uri = URI("https://auth.docker.io/token?service=registry.docker.io&scope=repository:#{repository}:pull")
+
+      headers = {}
+      if username && password
+        encoded_credentials = Base64.strict_encode64("#{username}:#{password}")
+        headers['Authorization'] = "Basic #{encoded_credentials}"
+      end
+
+      response = http_get(uri, headers)
+
+      if response.is_a?(Net::HTTPSuccess)
+        json = JSON.parse(response.body)
+        json['token']
+      else
+        raise "Failed to obtain token: #{response.code} #{response.message}"
+      end
+    end
+
+    # Step 2: Fetch the Image Manifest
+    def self.get_manifest(host, token, repository, tag)
+      uri = URI("https://#{host}/v2/#{repository}/manifests/#{tag}")
+      headers = {
+        'Authorization' => "Bearer #{token}",
+        'Accept' => [
+                      'application/vnd.oci.image.index.v1+json',
+                      'application/vnd.docker.distribution.manifest.list.v2+json',
+                      'application/vnd.oci.image.manifest.v1+json',
+                      'application/vnd.docker.distribution.manifest.v2+json'
+        ].join(', ')
+      }
+
+      response = http_get(uri, headers)
+
+      if response.is_a?(Net::HTTPSuccess)
+        JSON.parse(response.body)
+      else
+        raise "Failed to fetch manifest: #{response.code} #{response.message}"
+      end
+    end
+
+    # Step 4: Retrieve the Image Configuration
+    def self.get_blob(host, token, repository, blob_digest)
+      uri = URI("https://#{host}/v2/#{repository}/blobs/#{blob_digest}")
+      headers = { 'Authorization' => "Bearer #{token}" }
+
+      response = http_get(uri, headers)
+
+      if response.is_a?(Net::HTTPSuccess)
+        JSON.parse(response.body)
+      else
+        raise "Failed to retrieve image configuration for #{uri.inspect}: #{response.code} #{response.message}"
+      end
+    end
+
+    # Function to fetch the list of tags for the repository
+    def self.get_tags(host, token, repository)
+      tags = []
+      batch_size = 100
+      next_url = "/v2/#{repository}/tags/list?n=#{batch_size}"
+      headers = {
+        'Authorization' => "Bearer #{token}",
+        'Accept' => 'application/json'
+      }
+
+      loop do
+        uri = URI("https://#{host}#{next_url}")
+        response = http_get(uri, headers)
+
+        if response.is_a?(Net::HTTPSuccess)
+          json = JSON.parse(response.body)
+          tags.concat(json['tags'] || [])
+
+          # Check for pagination
+          link_header = response['Link']
+          if link_header && link_header.include?('rel="next"')
+            next_url = link_header.match(/<(.+)>;/)[1]
+          else
+            break
+          end
+        else
+          puts "Failed to fetch tags for #{repository}: https://#{host}#{next_url} #{response.code} #{response.message}"
+          break
+        end
+      end
+
+      tags
+    end
+
+    # Step 5: Extract Labels and Metadata
+    def self.display_metadata(config_json)
+      labels = config_json['config']['Labels']
+      puts "Labels:"
+      puts JSON.pretty_generate(labels)
+
+      puts "\nOther Metadata:"
+      metadata = config_json['config']
+      puts JSON.pretty_generate(metadata)
+    end
+
+    # Function to download and extract layers
+    def self.download_and_extract_layers(host, token, repository, layers, file_name)
+      layers.each_with_index do |layer, index|
+        digest = layer['digest']
+        puts "Processing layer #{index + 1}/#{layers.size}: #{digest}"
+
+        # Download the layer blob
+        uri = URI("https://#{host}/v2/#{repository}/blobs/#{digest}")
+        headers = { 'Authorization' => "Bearer #{token}" }
+
+        response = http_get(uri, headers)
+
+        if response.is_a?(Net::HTTPSuccess)
+          # Decompress and extract the tar.gz layer
+          found = extract_layer(response.body, file_name)
+          return true if found
+        else
+          puts "Failed to download layer #{digest}: #{response.code} #{response.message}"
+        end
+      end
+      false
+    end
+
+    # Function to extract a layer and search for the specified file
+    def self.extract_layer(layer_data, file_name)
+      # Decompress the gzip layer data
+      gz = Zlib::GzipReader.new(StringIO.new(layer_data))
+      tar_io = StringIO.new(gz.read)
+
+      # Extract tar contents
+      Minitar::Input.open(tar_io) do |tar|
+        tar.each do |entry|
+          # Normalize file paths to handle different directory structures
+          entry_path = entry.full_name.sub(/^\.\//, '').sub(/^\/+/, '')
+
+          if File.basename(entry_path) == file_name
+            puts "\nFound '#{file_name}' in layer:"
+            contents = entry.read
+            puts contents
+            return true
+          end
+        end
+      end
+      false
+    end
+
+  end
+end

data/lib/oci_registry/uri.rb

@@ -0,0 +1,58 @@
+require 'uri'
+
+# Define a custom class for Docker URIs
+module OCIRegistry
+  class URI < URI::Generic
+    attr_accessor :repository, :tag, :digest, :host, :scheme
+
+    def initialize(uri)
+      raise ArgumentError, 'OCIRegistry::URI->URI cannot be nil' if uri.nil?
+      raise ArgumentError, 'OCIRegistry::URI->URI must be a String' unless uri.is_a?(String)
+
+      # TODO: This addition makes this less an OCI URI library and more a CNB Builder Resource Library
+      # Handle the case where the URI is just ./eol-buildpack/ which is a local path.
+      @repository = uri and @scheme = 'local' and return if uri.start_with?('./')
+
+      # Call the parent class constructor
+      @parsed = ::URI.parse(uri)  # Use `::URI` to refer to Ruby's URI class
+
+      # Ensure the scheme is docker
+      unless ['docker', 'oci'].include?(@parsed.scheme)
+        raise ArgumentError, 'URI must start with (docker|oci)://'
+      end
+
+      # Extract repository, tag, and digest from the URI's path
+      @scheme = @parsed.scheme
+      @host = @parsed.host
+      @repository, tag_or_digest = @parsed.path.split('@').first.split(':')
+      # Remove any leading slashes from the repository
+      @repository = @repository.sub(%r{^/*}, '')
+      @digest = @parsed.path.split('@')[1]
+      @tag = tag_or_digest unless @digest
+    end
+
+    # Allow for 
+    # heroku/ruby
+    # heroku/ruby:2.7.2
+    # heroku/ruby@sha256:1234abcd
+    # docker://docker.io/heroku/ruby
+    # docker://docker.io/heroku/ruby:2.7.2
+    def to_s
+      base = ""
+      base += "#{@scheme}://"  if @scheme
+      base += "#{@host}/"      if @host
+      base += "#{@repository}" if @repository
+      base += ":#{@tag}"    if @tag
+      base += "@#{@digest}" if @digest
+      base
+    end
+  end
+end
+
+# Examples of parsing
+# uri1 = DockerURI.new('docker://docker.io/heroku/buildpack-dot@sha256:123')
+# uri2 = DockerURI.new('docker://docker.io/heroku/buildpack-dot:3.1.2')
+
+# puts "Parsed URI1: Repository=#{uri1.repository}, Tag=#{uri1.tag}, Digest=#{uri1.digest}"
+# puts "Parsed URI2: Repository=#{uri2.repository}, Tag=#{uri2.tag}, Digest=#{uri2.digest}"
+

data/lib/oci_registry/utils.rb

@@ -0,0 +1,119 @@
+# OCI related functions. Generally using skopeo and umoci. These span U9s (Heroku slug repackaging) and 
+# Qack (CNB "pack" rebuilding).
+# Resources:
+# - [Manual OCI building](https://ravichaganti.com/blog/2022-11-28-building-container-images-using-no-tools/)
+require 'shellwords'
+require 'open3'
+require 'json'
+require 'digest'
+require 'tmpdir'
+
+module OCIRegistry
+  class Utils
+    # Helper method to run shell commands
+    def self.run_command(cmd)
+      stdout, stderr, status = Open3.capture3(cmd)
+      {
+        out: stdout,
+        err: stderr,
+        status: status.exitstatus
+      }
+    end
+
+    def self.get_image_digest(image_name)
+    end
+    
+    # Function to calculate SHA256 hash of a file
+    def self.calculate_sha256(file_path)
+      Digest::SHA256.file(file_path).hexdigest
+    end
+    
+    def self.write_policy(filename: "policy.json")
+      File.open(filename, "w") do |f|
+        f.write <<~EOF
+          {
+              "default": [
+                  {
+                      "type": "insecureAcceptAnything"
+                  }
+              ],
+              "transports":
+                  {
+                      "docker-daemon":
+                          {
+                              "": [{"type":"insecureAcceptAnything"}]
+                          }
+                  }
+          }
+        EOF
+      end
+    end
+    
+    # Takes the output of skopeo inspect and returns the size of the image by adding its layers.
+    # cmd = %Q[skopeo inspect oci:#{td}/tmp_stack:latest]
+    # skopeo_inspect = JSON.parse(`#{cmd}`)
+    def self.sum_layers(skopeo_inspect)
+      # Ensure we treat as JSON...
+      skopeo_inspect = JSON.parse(skopeo_inspect) if skopeo_inspect.is_a?(String)
+      checksum = skopeo_inspect['Digest']
+      if skopeo_inspect['LayersData'].nil?
+        puts "skopeo_inspect: #{skopeo_inspect.to_yaml}"
+        raise "No layers found."
+      end
+      size = skopeo_inspect['LayersData'].map { |l| l['Size'] }.sum
+    end
+    
+    def self.copy_image(src_user:, src_pass:, dst_user:, dst_pass:, src_oci:, src_commit:, dst_oci:, dst_commit:)
+      src_user = Shellwords.escape(src_user)
+      src_pass = Shellwords.escape(src_pass)
+      dst_user = Shellwords.escape(dst_user)
+      dst_pass = Shellwords.escape(dst_pass)
+
+      copy(src_user: src_user, src_pass: src_pass, dst_user: dst_user, dst_pass: dst_pass, src_oci: src_oci, src_commit: src_commit, dst_oci: dst_oci, dst_commit: dst_commit)
+      cmd = %Q[skopeo inspect --creds #{dst_user}:#{dst_pass} docker://#{dst_oci}:#{dst_commit}]
+      details = run_command(cmd)
+      if details[:status] == 1
+        # Error occured
+        # Logger: ("Error inspecting image:\n#{details[:err]}")
+        raise "Image not found in registry #{details[:err]}."
+      end
+      inspect = JSON.parse(details[:out])
+      inspect['Digest']
+    end
+
+    # TODO: Copy FROM registry->local then local->registry. This avoids an error where a slow vs fast registry 
+    # [causes a timeout](https://github.com/containers/image/issues/1083).
+    def self.copy(src_user:, src_pass:, dst_user:, dst_pass:, src_oci:, src_commit:, dst_oci:, dst_commit:)
+      retries = 0
+      begin
+        details = {}
+        # We need a tempdir to write the policy file
+        Dir.mktmpdir do |dir|
+          OCIRegistry::Utils.write_policy(filename: File.join(dir, "policy.json"))
+          cmd = %Q[skopeo  --policy #{dir}/policy.json copy --src-creds #{src_user}:#{src_pass} --dest-creds #{dst_user}:#{dst_pass} docker://#{src_oci}:#{src_commit} docker://#{dst_oci}:#{dst_commit}]
+          details = run_command(cmd)
+          # Dir.mktmpdir do |tar|
+          #   cmd = %Q[skopeo  --policy #{dir}/policy.json copy --src-creds  #{src_user}:#{src_pass} docker://#{src_oci}:#{src_commit} dir:#{tar}]
+          #   details = run_command(cmd)
+          #   cmd = %Q[skopeo  --policy #{dir}/policy.json copy --dest-creds #{dst_user}:#{dst_pass} dir:#{tar} docker://#{dst_oci}:#{dst_commit}]
+          #   details = run_command(cmd)
+          # end
+        end
+        if details[:status] == 1
+          # Error occured
+          # Logger: ("Error copying image:\n#{details[:err]}")
+          raise "Error copying image from registry to registry #{details[:err]}."
+        end
+        details
+      rescue Exception => e
+        # Logger: ("Error caught copying image: #{e.message}.")
+        if (retries += 1) < 3
+          # Logger: ("Retry... ##{retries}.")
+          sleep 10 * 2**retries # Exponential backoff
+          retry
+        end
+        raise e
+      end
+    end
+  end
+end

data/lib/oci_registry/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module OCIRegistry
+  VERSION = "0.1.0"
+end

data/lib/oci_registry.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "oci_registry/version"
+require "oci_registry/client"
+require "oci_registry/remote"
+require "oci_registry/uri"
+require "oci_registry/utils"
+
+module OCIRegistry
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: oci_registry
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jonathan Siegel
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2025-07-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: shellwords
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.18'
+- !ruby/object:Gem::Dependency
+  name: vcr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+description: A Ruby library for interacting with OCI/Docker registries using the native
+  HTTP/tar/sha format to navigate repositories and retrieve tags, metadata and other
+  useful information.
+email:
+- usiegj00@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/oci_registry.rb
+- lib/oci_registry/client.rb
+- lib/oci_registry/remote.rb
+- lib/oci_registry/uri.rb
+- lib/oci_registry/utils.rb
+- lib/oci_registry/version.rb
+homepage: https://github.com/usiegj00/oci_registry
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ruby client for OCI/Docker Registry HTTP API v2
+test_files: []