namespaced-gem 0.1.0.pre

data/lib/namespaced/gem/metadata_deps_hook.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+require_relative "uri_dependency"
+
+module Namespaced
+  module Gem
+    # Implements a `Gem.done_installing` hook that processes deferred
+    # namespace dependencies stored in a gem's metadata.
+    #
+    # ## Why This Exists
+    #
+    # When `gem install my-gem` runs and `namespaced-gem` is listed as a
+    # runtime dependency of `my-gem`, the following sequence occurs:
+    #
+    #   1. RubyGems resolves ALL dependencies before installing ANY.
+    #   2. URI-style deps (e.g. "https://beta.gem.coop/@ns/foo") can't be
+    #      resolved on rubygems.org — they'd cause resolution to fail.
+    #   3. After resolution, gems install in topological order (leaves first).
+    #   4. `namespaced-gem` installs first → `load_plugin` fires →
+    #      `rubygems_plugin.rb` is hot-loaded → this hook registers.
+    #   5. After ALL gems in the batch finish installing, `done_installing`
+    #      fires and this hook processes the deferred namespace deps.
+    #
+    # ## Gemspec Convention
+    #
+    # Gem authors encode namespace dependencies in metadata:
+    #
+    #   spec.metadata["namespaced_dependencies"] = <<~DEPS
+    #     https://beta.gem.coop/@myspace/foo ~> 1.0
+    #     @myorg/bar >= 2.0
+    #     pkg:gem/@myorg/baz ~> 3.0
+    #   DEPS
+    #
+    # Each line is: `<uri-name> <version-constraint>...`
+    #
+    # For Bundler workflows, the same deps should ALSO be declared via
+    # `add_dependency` (Bundler handles URI deps natively via
+    # BundlerIntegration). The metadata field is only needed for the
+    # `gem install` code path.
+    #
+    # ## Helper for Gem Authors
+    #
+    # Use `Namespaced::Gem.add_namespaced_dependency` in your gemspec to
+    # automatically write both `add_dependency` and the metadata field:
+    #
+    #   Namespaced::Gem.add_namespaced_dependency(spec, "https://beta.gem.coop/@ns/foo", "~> 1.0")
+    #
+    module MetadataDepsHook
+      METADATA_KEY = "namespaced_dependencies"
+
+      # Register the done_installing hook. Called from rubygems_plugin.rb.
+      def self.register!
+        return if @registered
+
+        ::Gem.done_installing do |_dep_installer, specs|
+          MetadataDepsHook.process_batch(specs)
+        end
+
+        @registered = true
+      end
+
+      # Process a batch of just-installed gem specs, looking for deferred
+      # namespace dependencies in their metadata.
+      def self.process_batch(specs)
+        specs.each do |spec|
+          process_spec(spec)
+        end
+      end
+
+      # Process a single spec's metadata for namespace dependencies.
+      def self.process_spec(spec)
+        raw = spec.metadata[METADATA_KEY]
+        return unless raw.is_a?(String) && !raw.strip.empty?
+
+        deps = parse_metadata_deps(raw)
+        return if deps.empty?
+
+        install_namespace_deps(deps, spec)
+      end
+
+      # Parse the metadata string into an array of [uri_name, version_constraints].
+      #
+      # Format: one dep per line, `<uri-name> <version constraints...>`
+      #   https://beta.gem.coop/@myspace/foo ~> 1.0
+      #   @myorg/bar >= 2.0, < 3.0
+      #   pkg:gem/@myorg/baz ~> 3.0
+      def self.parse_metadata_deps(raw)
+        raw.strip.lines.filter_map do |line|
+          line = line.strip
+          next if line.empty? || line.start_with?("#")
+
+          # Split into URI name and version constraints.
+          # The URI name is the first whitespace-delimited token.
+          parts = line.split(/\s+/, 2)
+          uri_name = parts[0]
+          version_str = parts[1]
+
+          next unless UriDependency.uri?(uri_name)
+
+          version_reqs = if version_str && !version_str.strip.empty?
+                           # Split on comma for multiple constraints: "~> 1.0, < 2.0"
+                           version_str.split(",").map(&:strip).reject(&:empty?)
+                         else
+                           [">= 0"]
+                         end
+
+          [uri_name, version_reqs]
+        end
+      end
+
+      # Install namespace dependencies using the now-active patches.
+      #
+      # At this point, rubygems_plugin.rb has been hot-loaded, so:
+      #   - DependencyPatch is active (uri_gem?, uri_dependency)
+      #   - GemResolverPatch is active (RequestSet/InstallerSet handle URI deps)
+      #   - ApiSpecPatch is active (synthesizes specs from Compact Index)
+      #   - DownloadPatch is active (clear namespace download errors)
+      def self.install_namespace_deps(deps, parent_spec)
+        deps.each do |uri_name, version_reqs|
+          uri_dep = UriDependency.parse(uri_name)
+
+          warn "[namespaced-gem] Installing deferred namespace dependency: " \
+               "#{uri_dep.gem_name} (#{version_reqs.join(", ")}) " \
+               "from #{uri_dep.source_url} " \
+               "(required by #{parent_spec.name})"
+
+          begin
+            installer = ::Gem::DependencyInstaller.new(
+              domain: :both,
+              force: false,
+              # Let the user's existing gem path config apply
+            )
+            # The GemResolverPatch will intercept this URI dep during
+            # resolution and route it to the correct namespace source.
+            installer.install(uri_name, ::Gem::Requirement.new(*version_reqs))
+          rescue ::Gem::UnsatisfiableDependencyError, Namespaced::Gem::Error => e
+            warn "[namespaced-gem] WARNING: Failed to install namespace dependency " \
+                 "#{uri_dep.gem_name} from #{uri_dep.source_url}: #{e.message}"
+            warn "[namespaced-gem]   This may be a server-side issue. See ISSUE.md."
+          end
+        end
+      end
+    end
+
+    # Convenience method for gem authors to declare a namespaced dependency
+    # in both `add_dependency` (for Bundler) and `metadata` (for gem install).
+    #
+    # Usage in gemspec:
+    #   require "namespaced/gem"
+    #   Namespaced::Gem.add_namespaced_dependency(spec, "https://beta.gem.coop/@ns/foo", "~> 1.0")
+    #
+    def self.add_namespaced_dependency(spec, uri_name, *version_constraints)
+      # Standard add_dependency — works with Bundler via BundlerIntegration
+      spec.add_dependency(uri_name, *version_constraints)
+
+      # Also store in metadata for the gem install hot-load path
+      version_str = version_constraints.join(", ")
+      entry = "#{uri_name} #{version_str}"
+
+      existing = spec.metadata[MetadataDepsHook::METADATA_KEY]
+      spec.metadata[MetadataDepsHook::METADATA_KEY] = if existing && !existing.strip.empty?
+                                                         "#{existing.strip}\n#{entry}"
+                                                       else
+                                                         entry
+                                                       end
+    end
+  end
+end

data/lib/namespaced/gem/namespace_source_registry.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Namespaced
+  module Gem
+    # Thread-safe registry of namespace source URLs.
+    #
+    # When the GemResolverPatch or other code creates a Gem::Source for a
+    # namespace URL (e.g. "https://beta.gem.coop/@kaspth"), it registers
+    # that URL here.  Later, patches like ApiSpecPatch and DownloadPatch
+    # can check whether a given Gem::Source is a namespace source — without
+    # relying on heuristics like scanning the URL for "@" segments.
+    #
+    # This registry is the single source of truth for "is this source a
+    # namespace source that our plugin manages?"
+    module NamespaceSourceRegistry
+      @mutex = Mutex.new
+      @sources = {} # normalized_url_string => true
+
+      # Register a namespace source URL.  Safe to call multiple times with
+      # the same URL (idempotent).
+      def self.register(source_url)
+        normalized = normalize(source_url)
+        @mutex.synchronize { @sources[normalized] = true }
+      end
+
+      # Returns true if +source+ is a Gem::Source whose URI was previously
+      # registered as a namespace source.
+      def self.namespace_source?(source)
+        return false unless source.is_a?(::Gem::Source)
+
+        uri = source.respond_to?(:uri) && source.uri
+        return false unless uri
+
+        namespace_source_url?(uri)
+      end
+
+      # Returns true if the given URL string (or URI object) was registered.
+      def self.namespace_source_url?(url)
+        normalized = normalize(url)
+        @mutex.synchronize { @sources.key?(normalized) }
+      end
+
+      # Clear all registered sources.  Primarily for testing.
+      def self.clear!
+        @mutex.synchronize { @sources.clear }
+      end
+
+      # Returns a frozen copy of all registered source URLs (for debugging).
+      def self.registered_urls
+        @mutex.synchronize { @sources.keys.freeze }
+      end
+
+      class << self
+        private
+
+        def normalize(url)
+          url.to_s.chomp("/")
+        end
+      end
+    end
+  end
+end

data/lib/namespaced/gem/uri_dependency.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module Namespaced
+  module Gem
+    # Represents a gem dependency specified as a URI, enabling namespaced gem
+    # sources (e.g. gem.coop namespaces) to be declared directly in gemspecs.
+    #
+    # Supported formats:
+    #   Full URI:   "https://beta.gem.coop/@myspace/my-gem"
+    #   Shorthand:  "@myspace/my-gem"  (defaults to https://beta.gem.coop)
+    #   Package URL (purl-spec):
+    #     "pkg:gem/@myspace/my-gem"
+    #     "pkg:gem/@myspace/my-gem?repository_url=https://beta.gem.coop"
+    #     "pkg:gem/my-gem?repository_url=https://beta.gem.coop/@myspace"
+    #
+    # Usage in a gemspec:
+    #   spec.add_dependency "https://beta.gem.coop/@myspace/my-gem", "~> 1.0"
+    #   spec.add_dependency "pkg:gem/@myspace/my-gem", "~> 1.0"
+    class UriDependency
+      DEFAULT_SERVER = "https://beta.gem.coop"
+
+      # Pattern matching full HTTPS/HTTP URIs to a namespaced gem.
+      # e.g. https://beta.gem.coop/@namespace/gem-name
+      FULL_URI_PATTERN = %r{
+        \A
+        (https?://[^/]+)      # server base, e.g. https://beta.gem.coop
+        /
+        (@[^/]+)              # namespace, e.g. @myspace
+        /
+        ([a-zA-Z0-9._\-]+)   # gem name (dots allowed per RubyGems convention)
+        \z
+      }x
+
+      # Shorthand: @namespace/gem-name (no server; defaults to beta.gem.coop)
+      SHORTHAND_PATTERN = %r{
+        \A
+        (@[^/]+)              # namespace, e.g. @myspace
+        /
+        ([a-zA-Z0-9._\-]+)   # gem name (dots allowed per RubyGems convention)
+        \z
+      }x
+
+      # Package URL (purl-spec): pkg:gem/[@namespace/]gem-name[@version][?qualifiers]
+      # See https://github.com/package-url/purl-spec
+      #
+      # Supported forms:
+      #   pkg:gem/@myspace/my-gem                                       — namespace, default server
+      #   pkg:gem/@myspace/my-gem?repository_url=https://beta.gem.coop  — namespace + explicit server
+      #   pkg:gem/my-gem?repository_url=https://beta.gem.coop/@myspace  — namespace embedded in qualifier
+      #
+      # The @version component (if present) is captured but ignored — version
+      # constraints come from the second argument to add_dependency.
+      PURL_PATTERN = %r{
+        \A
+        pkg:gem/
+        (?:(@[^/]+)/)?          # optional namespace, e.g. @myspace
+        ([a-zA-Z0-9._\-]+)     # gem name
+        (?:@[^?]+)?             # optional @version (ignored)
+        (?:\?(.+))?             # optional ?qualifiers
+        \z
+      }x
+
+      attr_reader :original, :server_base, :namespace, :gem_name
+
+      # Returns true if +name+ looks like a URI dependency (full URI, shorthand,
+      # or purl).
+      def self.uri?(name)
+        return false unless name.is_a?(String)
+
+        FULL_URI_PATTERN.match?(name) || SHORTHAND_PATTERN.match?(name) || PURL_PATTERN.match?(name)
+      end
+
+      # Parses +name+ into a UriDependency. Raises ArgumentError if not a URI dep.
+      def self.parse(name)
+        new(name)
+      end
+
+      def initialize(name)
+        @original = -String(name)
+
+        if (m = FULL_URI_PATTERN.match(@original))
+          @server_base = -m[1]
+          @namespace   = -m[2]
+          @gem_name    = -m[3]
+        elsif (m = SHORTHAND_PATTERN.match(@original))
+          @server_base = DEFAULT_SERVER
+          @namespace   = -m[1]
+          @gem_name    = -m[2]
+        elsif (m = PURL_PATTERN.match(@original))
+          parse_purl(m)
+        else
+          raise ArgumentError, "Not a valid URI dependency: #{name.inspect}"
+        end
+
+        freeze
+      end
+
+      # The Bundler source URL for this dependency's namespace.
+      # This is what you'd put in a Gemfile `source` block.
+      def source_url
+        "#{server_base}/#{namespace}"
+      end
+
+      # Value equality — two UriDependency objects are equal when they refer
+      # to the same gem in the same namespace on the same server.
+      def ==(other)
+        other.is_a?(self.class) &&
+          server_base == other.server_base &&
+          namespace == other.namespace &&
+          gem_name == other.gem_name
+      end
+
+      alias eql? ==
+
+      def hash
+        [self.class, server_base, namespace, gem_name].hash
+      end
+
+      def to_s
+        "#{source_url}/#{gem_name}"
+      end
+
+      def inspect
+        "#<#{self.class} gem_name=#{gem_name.inspect} source_url=#{source_url.inspect}>"
+      end
+
+      private
+
+      # Parse a purl match into server_base, namespace, and gem_name.
+      #
+      # Three forms:
+      #   1. pkg:gem/@ns/name              → namespace from purl, default server
+      #   2. pkg:gem/@ns/name?repository_url=https://server
+      #                                    → namespace from purl, server from qualifier
+      #   3. pkg:gem/name?repository_url=https://server/@ns
+      #                                    → both from qualifier
+      def parse_purl(match)
+        purl_namespace = match[1]  # may be nil
+        @gem_name      = -match[2]
+        qualifiers     = parse_qualifiers(match[3])
+        repo_url       = qualifiers["repository_url"]
+
+        if purl_namespace
+          # Forms 1 & 2: namespace is in the purl path
+          @namespace   = -purl_namespace
+          @server_base = repo_url ? -repo_url.chomp("/") : DEFAULT_SERVER
+        elsif repo_url
+          # Form 3: namespace is embedded in repository_url
+          #   e.g. https://beta.gem.coop/@myspace
+          repo_uri = URI.parse(repo_url)
+          path_segments = repo_uri.path.split("/").reject(&:empty?)
+          ns_segment = path_segments.find { |s| s.start_with?("@") }
+
+          unless ns_segment
+            raise ArgumentError,
+                  "purl qualifier repository_url must include a @namespace or the purl path must: #{@original.inspect}"
+          end
+
+          @namespace   = -ns_segment
+          @server_base = -"#{repo_uri.scheme}://#{repo_uri.host}#{repo_uri.port == repo_uri.default_port ? "" : ":#{repo_uri.port}"}"
+        else
+          raise ArgumentError,
+                "purl for a namespaced gem must include a @namespace in the path or a repository_url qualifier: #{@original.inspect}"
+        end
+      end
+
+      # Parse a URL query string into a Hash.  Returns an empty Hash for nil.
+      def parse_qualifiers(raw)
+        return {} unless raw
+
+        URI.decode_www_form(raw).to_h
+      end
+    end
+  end
+end

data/lib/namespaced/gem/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Namespaced
+  module Gem
+    VERSION = "0.1.0.pre"
+  end
+end

data/lib/namespaced/gem.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "gem/version"
+require_relative "gem/uri_dependency"
+require_relative "gem/namespace_source_registry"
+require_relative "gem/dependency_patch"
+require_relative "gem/api_spec_patch"
+require_relative "gem/download_patch"
+require_relative "gem/bundler_integration"
+require_relative "gem/bundler_resolver_patch"
+require_relative "gem/gem_resolver_patch"
+require_relative "gem/metadata_deps_hook"
+
+module Namespaced
+  # Namespaced::Gem is a RubyGems plugin/shim that enables gemspec dependencies
+  # to be declared as full URIs, pointing to namespaced gem sources such as
+  # gem.coop namespaces (e.g. https://beta.gem.coop/@myspace/my-gem).
+  #
+  # When installed, this gem's rubygems_plugin.rb is loaded at RubyGems boot,
+  # patching Gem::Dependency to accept URI names, Bundler::Dsl to automatically
+  # inject source blocks, and both Bundler's and RubyGems' resolvers to remap
+  # URI-named transitive deps to their real names and namespace sources.
+  module Gem
+    class Error < StandardError; end
+  end
+end

data/lib/rubygems_plugin.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+# RubyGems plugin for namespaced-gem.
+#
+# This file is automatically loaded by RubyGems at boot time (before any
+# gemspecs are evaluated) because it matches the `rubygems*_plugin.rb` naming
+# convention in the gem's require path.
+#
+# What it does:
+#   1. Patches Gem::Dependency to accept URI-style gem names such as
+#      "https://beta.gem.coop/@namespace/gem-name".
+#   2. Patches Gem::RequestSet and Gem::Resolver::InstallerSet so that
+#      `gem install` can resolve URI-named deps against the correct namespace
+#      source, both as direct deps and as transitive deps.
+#   3. Patches Gem::Resolver::APISpecification#spec to synthesize a
+#      Gem::Specification from Compact Index data for namespace sources —
+#      bypassing the missing Marshal endpoint.
+#   4. Patches Gem::Source#download to provide clear error messages when
+#      namespace servers fail to serve .gem files.
+#   5. Registers deferred patches for Bundler::Dsl, Bundler::Definition, and
+#      Bundler::Resolver so that `bundle install` / `bundle add` automatically
+#      resolve URI deps (both direct and transitive) against namespace sources.
+#   6. Registers a Gem.done_installing hook that processes deferred namespace
+#      dependencies stored in spec.metadata["namespaced_dependencies"]. This
+#      enables the "hot-load" path: when namespaced-gem is installed as a leaf
+#      dependency, Gem::Installer#load_plugin hot-loads this file, and the
+#      done_installing hook triggers a second install pass for URI deps.
+#
+# See lib/namespaced/gem/dependency_patch.rb       — Gem::Dependency patch
+#     lib/namespaced/gem/gem_resolver_patch.rb     — Gem::RequestSet / InstallerSet
+#     lib/namespaced/gem/api_spec_patch.rb         — Gem::Resolver::APISpecification
+#     lib/namespaced/gem/download_patch.rb         — Gem::Source#download
+#     lib/namespaced/gem/bundler_integration.rb    — Bundler::Dsl patch
+#     lib/namespaced/gem/bundler_resolver_patch.rb — Bundler::Definition / Resolver
+
+require_relative "namespaced/gem/dependency_patch"
+require_relative "namespaced/gem/gem_resolver_patch"
+require_relative "namespaced/gem/api_spec_patch"
+require_relative "namespaced/gem/download_patch"
+require_relative "namespaced/gem/bundler_integration"
+require_relative "namespaced/gem/bundler_resolver_patch"
+require_relative "namespaced/gem/metadata_deps_hook"
+
+# 1. Patch Gem::Dependency immediately — must run before any gemspec is parsed.
+Namespaced::Gem::DependencyPatch.apply!
+
+# 2. Patch Gem::RequestSet / InstallerSet for `gem install` — always available.
+Namespaced::Gem::GemResolverPatch.apply!
+
+# 3. Patch Gem::Resolver::APISpecification#spec to synthesize specs for
+#    namespace sources (bypasses the missing Marshal endpoint).
+Namespaced::Gem::ApiSpecPatch.apply!
+
+# 4. Patch Gem::Source#download for clear namespace download error messages.
+Namespaced::Gem::DownloadPatch.apply!
+
+# 5. Patch Bundler if loaded, or defer until it is.
+Namespaced::Gem::BundlerIntegration.apply_when_ready!
+Namespaced::Gem::BundlerResolverPatch.apply_when_ready!
+
+# 6. Register the done_installing hook for deferred namespace dependencies.
+#
+#    This enables the "hot-load" path for `gem install my-gem` where my-gem
+#    depends on namespaced-gem and stores URI deps in metadata:
+#
+#      spec.metadata["namespaced_dependencies"] = "https://beta.gem.coop/@ns/foo ~> 1.0"
+#
+#    When namespaced-gem is installed as a leaf dependency (topological order),
+#    Gem::Installer#load_plugin hot-loads this file into the running process.
+#    The done_installing hook then fires after ALL gems in the batch finish
+#    installing, reads the metadata, and triggers a second resolution pass
+#    for the deferred namespace deps — with all patches now active.
+Namespaced::Gem::MetadataDepsHook.register!

data/sig/namespaced/gem.rbs

@@ -0,0 +1,87 @@
+module Namespaced
+  module Gem
+    VERSION: String
+
+    class Error < StandardError
+    end
+
+    class UriDependency
+      DEFAULT_SERVER: String
+      FULL_URI_PATTERN: Regexp
+      SHORTHAND_PATTERN: Regexp
+      PURL_PATTERN: Regexp
+
+      attr_reader original: String
+      attr_reader server_base: String
+      attr_reader namespace: String
+      attr_reader gem_name: String
+
+      def self.uri?: (untyped name) -> bool
+      def self.parse: (String name) -> UriDependency
+
+      def initialize: (String name) -> void
+
+      def source_url: () -> String
+      def ==: (untyped other) -> bool
+      alias eql? ==
+      def hash: () -> Integer
+      def to_s: () -> String
+      def inspect: () -> String
+
+      private
+
+      def parse_purl: (MatchData match) -> void
+      def parse_qualifiers: (String? raw) -> Hash[String, String]
+    end
+
+    module DependencyPatch
+      def self.apply!: () -> void
+
+      module InstanceMethods
+        def uri_gem?: () -> bool
+        def uri_dependency: () -> UriDependency?
+      end
+    end
+
+    module BundlerIntegration
+      def self.apply!: () -> void
+      def self.apply_when_ready!: () -> void
+
+      module DslPatch
+        def gemspec: (?Hash[Symbol, untyped]? opts) -> void
+
+        private def inject_uri_sources_for: (Gem::Specification spec) -> void
+      end
+    end
+
+    module BundlerResolverPatch
+      def self.apply!: () -> void
+      def self.apply_when_ready!: () -> void
+
+      module DefinitionPatch
+        def initialize: (untyped lockfile, Array[untyped] dependencies, untyped sources, *untyped) -> void
+
+        private def remap_uri_dependencies: (Array[untyped] dependencies) -> [Array[untyped], Array[String]]
+        private def dep_options_for: (untyped dep, String source_url) -> Hash[String, untyped]
+      end
+
+      module ResolverPatch
+        def to_dependency_hash: (Array[untyped] dependencies, untyped packages) -> untyped
+      end
+    end
+
+    module GemResolverPatch
+      def self.apply!: () -> void
+
+      module RequestSetPatch
+        def resolve: (?untyped set) -> untyped
+      end
+
+      module InstallerSetPatch
+        def find_all: (untyped req) -> Array[untyped]
+
+        private def _namespaced_resolver_set: (String source_url) -> untyped
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: namespaced-gem
+version: !ruby/object:Gem::Version
+  version: 0.1.0.pre
+platform: ruby
+authors:
+- Peter H. Boling
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: "\U0001F50C A RubyGems plugin that allows gemspec dependencies to be
+  declared as full\nURIs pointing to namespaced gem sources such as gem.coop namespaces\n(e.g.
+  `https://beta.gem.coop/@myspace/my-gem`).\n\nWhen installed, this gem patches both
+  RubyGems' native resolver (`gem\ninstall`) and Bundler's resolver (`bundle install`)
+  to parse URI dependency\nnames, route them to the correct namespace source, and
+  remap transitive deps\non the fly — so `gem install @kaspth/oaken` and `bundle install`
+  with URI\ndeps in gemspecs both Just Work™.\n\nSee https://github.com/gem-coop/gem.coop/issues/12
+  for the original discussion.\n"
+email:
+- peter.boling@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".idea/.gitignore"
+- ".idea/git_toolbox_prj.xml"
+- ".idea/modules.xml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- HOT_HOOK.md
+- HOT_LOAD_ANALYSIS.md
+- ISSUE.md
+- README.md
+- Rakefile
+- WORKAROUND.md
+- lib/example_hooks.rb
+- lib/namespaced/gem.rb
+- lib/namespaced/gem/api_spec_patch.rb
+- lib/namespaced/gem/bundler_integration.rb
+- lib/namespaced/gem/bundler_resolver_patch.rb
+- lib/namespaced/gem/dependency_patch.rb
+- lib/namespaced/gem/download_patch.rb
+- lib/namespaced/gem/gem_resolver_patch.rb
+- lib/namespaced/gem/metadata_deps_hook.rb
+- lib/namespaced/gem/namespace_source_registry.rb
+- lib/namespaced/gem/uri_dependency.rb
+- lib/namespaced/gem/version.rb
+- lib/rubygems_plugin.rb
+- sig/namespaced/gem.rbs
+homepage: https://gitlab.com/galtzo-floss/namespaced-gem
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://gitlab.com/galtzo-floss/namespaced-gem
+  source_code_uri: https://gitlab.com/galtzo-floss/namespaced-gem
+  changelog_uri: https://gitlab.com/galtzo-floss/namespaced-gem/-/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 4.0.5
+requirements: []
+rubygems_version: 4.0.7
+specification_version: 4
+summary: "\U0001F50C RubyGems plugin enabling URI-style gemspec dependencies for namespaced
+  gem sources (e.g. gem.coop namespaces)."
+test_files: []