carton 0.1.0 → 0.2.0

data/lib/carton.rb

@@ -1,31 +1,24 @@
 # frozen_string_literal: true
 
-raise 'Ruby 4.0+ is required for Carton' if RUBY_VERSION.to_f < 4.0
-
-module Carton
-  module_function
-
-  def with_bundle(gemfile)
-    previous = ENV['BUNDLE_GEMFILE']
-    ENV['BUNDLE_GEMFILE'] = gemfile
-    yield
-  ensure
-    if previous
-      ENV['BUNDLE_GEMFILE'] = previous
-    else
-      ENV.delete 'BUNDLE_GEMFILE'
-    end
-  end
-end
-
+require_relative 'carton/error'
+require_relative 'carton/bundler'
 require_relative 'carton/export_methods'
 require_relative 'carton/exports'
+require_relative 'carton/export_declaration'
 require_relative 'carton/box'
+require_relative 'carton/gem_activation'
+require_relative 'carton/import_cache'
+require_relative 'carton/resolver'
 require_relative 'carton/runtime'
 require_relative 'carton/kernel_patch'
 
 module Carton
+  private_constant :Box
+  private_constant :ExportDeclaration
   private_constant :ExportMethods
-  private_constant :Runtime
+  private_constant :GemActivation
+  private_constant :ImportCache
   private_constant :KernelPatch
+  private_constant :Resolver
+  private_constant :Runtime
 end

data/sig/carton.rbs

@@ -0,0 +1,42 @@
+module Kernel
+  private
+
+  def import: (::String path) -> untyped
+  def import_relative: (::String path) -> untyped
+  def export: (*::Symbol names, **untyped values) -> ::Symbol?
+  def export_default: [T] (T value) -> T
+end
+
+module Carton
+  VERSION: ::String
+
+  def self.setup_bundle: (*::Symbol groups, ?gemfile: ::String?) -> untyped
+end
+
+class Carton::Error < ::StandardError
+end
+
+class Carton::ImportError < Carton::Error
+end
+
+class Carton::ExportError < Carton::Error
+end
+
+class Carton::GemfileNotFound < Carton::Error
+end
+
+class Carton::Exports < ::Module
+  type key = ::String | ::Symbol
+
+  # Exported methods come back as Method objects; values as exported.
+  def []: (key key) -> untyped
+  def deconstruct_keys: (nil keys) -> ::Hash[::Symbol, untyped]
+                      | (::Array[::Symbol] keys) -> ::Hash[::Symbol, untyped]
+  def fetch: (key key) -> untyped
+           | (key key, untyped default) -> untyped
+           | [T] (key key) { (key key) -> T } -> (untyped | T)
+  def fetch_values: (*key keys) -> ::Array[untyped]
+  def has_key?: (key key) -> bool
+  def key?: (key key) -> bool
+  def values_at: (*key keys) -> ::Array[untyped]
+end

metadata

@@ -1,63 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: carton
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - David Cristofaro
-bindir: exe
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: Carton is a thin wrapper around Ruby::Box for safe, ergonomic modularization
-  in Ruby 4+. It gives you imports and exports that feel like ES Modules while still
-  reading like Ruby. Each carton can isolate constants, gems, and monkey patches behind
-  a small public API, so large apps can keep clear boundaries.
+description: Split a Ruby app into gem-sized units that import and export like modules.
+  Each Carton runs in its own Ruby::Box, so two parts of one app can use different
+  versions of the same gem, monkey patches stay where they are made, and only what
+  a Carton exports is reachable. No manifest needed. Requires Ruby 4.0.7+.
 email:
 - david@dtcristo.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- AGENTS.md
 - CHANGELOG.md
-- DESIGN.md
 - LICENSE.txt
 - README.md
-- Rakefile
-- TODO.md
-- USAGE.md
-- examples/complex/README.md
-- examples/complex/cartons/adventure/.env
-- examples/complex/cartons/adventure/Gemfile
-- examples/complex/cartons/adventure/Gemfile.lock
-- examples/complex/cartons/adventure/lib/adventure.rb
-- examples/complex/cartons/loot/.env
-- examples/complex/cartons/loot/Gemfile
-- examples/complex/cartons/loot/Gemfile.lock
-- examples/complex/cartons/loot/lib/loot.rb
-- examples/complex/cartons/quest/lib/quest.rb
-- examples/complex/main.rb
-- examples/minimal/README.md
-- examples/minimal/bar.rb
-- examples/minimal/baz.rb
-- examples/minimal/foo.rb
-- examples/minimal/main.rb
-- images/carton.png
 - lib/carton.rb
+- lib/carton/activate_gems.rb
 - lib/carton/box.rb
+- lib/carton/bundler.rb
+- lib/carton/error.rb
+- lib/carton/export_declaration.rb
 - lib/carton/export_methods.rb
 - lib/carton/exports.rb
+- lib/carton/gem_activation.rb
+- lib/carton/import_cache.rb
 - lib/carton/kernel_patch.rb
+- lib/carton/resolver.rb
 - lib/carton/runtime.rb
 - lib/carton/version.rb
+- sig/carton.rbs
 homepage: https://github.com/dtcristo/carton
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
   homepage_uri: https://github.com/dtcristo/carton
-  source_code_uri: https://github.com/dtcristo/carton
   changelog_uri: https://github.com/dtcristo/carton/blob/main/CHANGELOG.md
 rdoc_options: []
 require_paths:
@@ -66,14 +52,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 4.0.1
+      version: 4.0.7
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Easily box your Ruby
 test_files: []

data/AGENTS.md

@@ -1,47 +0,0 @@
-# Agents
-
-Guidance and memory for agents working on this repo.
-
-## Memory bank
-
-- Goal: make Carton feel like part of Ruby: built-in, simple, streamlined, and not verbose.
-- Prefer simpler implementation over complexity.
-- Keep the public API small and Ruby-like.
-- The project should work with or without Bundler.
-- A package in this system is called a carton, though docs can still use "package" in plain English when it reads better.
-- Current reliable bundled-carton pattern: use `Carton.with_bundle(gemfile) { import ... }` for the entry import that should activate a carton-local bundle.
-- Conflicting bundles still need a subprocess workaround today.
-- Ruby::Box boxes start from root-box load paths/loaded features, so Carton must copy parent non-gem load paths forward itself.
-- `$LOAD_PATH` is box-local, but `Gem.loaded_specs` is shared across boxes in practice, so conflicting bundle activation still collides there.
-- Duplicating `Gem.loaded_specs` inside a box isolates a single bundled import from root state, but conflicting bundles still fail because Bundler also rewrites shared RubyGems entrypoints/spec state such as `Gem::Specification.all`.
-- Never push. Make local commits only; the user handles pushes.
-
-## Working rules
-
-- Everything should have tests. Write tests for new behaviour, run targeted tests as you go, and `RUBY_BOX=1 bundle exec rake` before finishing.
-- If you only changed an example, run that example during iteration and the full suite before finishing.
-- Run `bundle exec rake format` after every change.
-- Keep implementation and docs concise.
-- Do not over-engineer.
-- Never use thread local variables in implementation.
-- Always review https://docs.ruby-lang.org/en/4.0/Ruby/Box.html on how `Ruby::Box` works.
-- Never bump the version or publish the gem.
-- When multiple implementation choices are viable, present a menu with your recommendation.
-- Commit as you go with descriptive messages and the required Co-authored-by trailer.
-- Never push; the user will do that.
-
-## Docs
-
-- Keep `README.md`, `USAGE.md`, `DESIGN.md`, `TODO.md`, `AGENTS.md`, and example READMEs up to date when behavior, workflow, or plans change.
-- Keep the root `README.md` minimal; move detail into focused docs.
-- Put future work, open questions, and upstream ideas in `TODO.md`.
-- Update `AGENTS.md` whenever the user gives durable project guidance or you discover stable context worth remembering.
-- Use `AGENTS.md` as a concise memory bank, not a changelog.
-
-## Commands
-
-- `RUBY_BOX=1 bundle exec rake` - full suite
-- `RUBY_BOX=1 bundle exec rake test` - unit tests only
-- `RUBY_BOX=1 bundle exec rake example:minimal` - minimal example
-- `RUBY_BOX=1 bundle exec rake example:complex` - complex example
-- `bundle exec rake format` - format code

data/DESIGN.md

@@ -1,84 +0,0 @@
-# Design
-
-## Goal
-
-Keep the library small: a thin wrapper around `Ruby::Box` that makes isolated file-to-file imports feel like part of Ruby.
-
-## Main pieces
-
-| File | Role |
-| --- | --- |
-| `lib/carton.rb` | Entry point, version guard, `Carton.with_bundle`, and internal wiring |
-| `lib/carton/kernel_patch.rb` | Adds global `import`, `import_relative`, `export_default`, and `export` |
-| `lib/carton/runtime.rb` | Builds boxes, resolves targets, runs imports, and extracts exports |
-| `lib/carton/box.rb` | Box-specific helpers for requiring files, managing export state, and inheriting safe load paths |
-| `lib/carton/exports.rb` | Wraps named exports in a module-like namespace |
-| `lib/carton/export_methods.rb` | Shared `[]`, `fetch`, `fetch_values`, `values_at`, `key?`, and destructuring support |
-
-## Import flow
-
-1. `import` or `import_relative` delegates to `Carton::Runtime.import`.
-2. A fresh `Carton::Box` is created for that import.
-3. The carton entrypoint (`lib/carton.rb`) is required inside the box so the box has `export`, `import`, and `import_relative`.
-4. The target file is resolved either from the caller's base directory or from the current box's `$LOAD_PATH`.
-5. The target file is required inside the box.
-6. If the file called `export_default` or `export`, the exported value is returned.
-7. If the export was a hash, it is wrapped in `Carton::Exports`.
-8. If there was no export, the box itself is returned.
-
-Every import creates a fresh box. There is no module cache at the Carton layer.
-
-## Export model
-
-There are three return shapes:
-
-- single export: the exported object itself
-- named exports: `Carton::Exports`
-- no export: `Carton::Box`
-
-`export_default` is the explicit single-export form. `export` is the named-export form and only accepts keyword arguments. `Carton::Exports` exposes capitalized keys as constants and lowercase keys as singleton methods. Both `Carton::Exports` and `Carton::Box` share the same small fetch/deconstruction API through `ExportMethods`.
-
-## Load path model
-
-Ruby::Box creates new user boxes from the root box, not from the current caller box. In `box.c`, each new box starts by duplicating the root box's `load_path` and `loaded_features`, and `require` resolves against the loading box's local `$LOAD_PATH` / `$LOADED_FEATURES`.
-
-Carton therefore re-inherits the parent box's non-gem load paths manually so local carton directories can still be resolved by name across nested imports.
-
-The current filter deliberately tries to avoid leaking gem paths from a parent import chain into child boxes:
-
-- RubyGems paths are filtered
-- common Bundler vendor paths are filtered
-- local, non-gem carton paths are preserved
-
-This is why the examples add sibling `lib/` directories to `$LOAD_PATH` explicitly before using `import 'name'`.
-
-## Bundler model
-
-The current implementation works best when a carton bundle is selected before its entry file is evaluated. In practice that means selecting `BUNDLE_GEMFILE` around the `import` call for that carton; `Carton.with_bundle` is the small wrapper for that handoff.
-
-This keeps one carton-local bundle isolated from the caller, but current limitations remain:
-
-- a parent already running under Bundler is not a reliable place to import a child carton with its own bundle
-- switching between conflicting bundles in one process is not reliable today
-- the complex example uses a subprocess for the conflicting `loot` bundle for that reason
-
-The problem is not that Bundler has special C code mutating every box at once. Bundler and RubyGems do their activation work in Ruby:
-
-- `Bundler::SharedHelpers#find_gemfile` reads `ENV['BUNDLE_GEMFILE']`
-- `Bundler::Runtime#setup` calls `clean_load_path`, `replace_entrypoints`, `mark_loaded`, and `Gem.add_to_load_path`
-- RubyGems activation checks and writes `Gem.loaded_specs`
-
-What matters under `Ruby::Box` is which of those pieces are box-local. In practice:
-
-- `$LOAD_PATH` stays box-local; activating a bundle in an imported box does not inject its gem lib paths into the caller box
-- `Gem.loaded_specs` is still shared across boxes in practice unless it is explicitly replaced inside the box
-
-Duplicating `Gem.loaded_specs` inside an imported box was enough to keep a single bundled import from leaking back into the caller box, but it was still not enough to make two conflicting bundles coexist. Bundler also rewrites RubyGems entrypoints and spec state through code paths such as `replace_entrypoints`, `stub_rubygems`, `Gem::Specification.all = ...`, and `Gem.clear_paths`.
-
-That shared activation state is why a second box can see a gem version activated by the first one even though its own `$LOAD_PATH` is separate. In local probes, activating `dotenv 3.2.0` in one box caused a second box targeting `dotenv ~> 2.0` to fail its Bundler activation and then crash under Ruby 4.0 + `Ruby::Box`.
-
-See [TODO.md](TODO.md) for the upstream work that would help.
-
-## Why the complex example stays explicit
-
-The complex example keeps load-path setup and bundled imports visible in `main.rb` on purpose. It is meant to demonstrate Carton directly, not hide the mechanics behind another layer.

data/Rakefile

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-STREE_FILES = '"**/*.{rb,rake,gemspec}" "**/Rakefile" "**/Gemfile"'
-EXAMPLES = %w[minimal complex].freeze
-
-desc 'Run all tests'
-task :test do
-  test_files =
-    Dir.glob('test/**/*_test.rb').sort.map { |f| File.expand_path(f) }
-  sh "RUBY_BOX=1 ruby -Ilib -Itest -e 'ARGV.each { |f| require f }' #{test_files.join(' ')}",
-     verbose: false
-end
-
-namespace :example do
-  EXAMPLES.each do |name|
-    desc "Run the #{name} example"
-    task name.to_sym do
-      dir = File.join('examples', name)
-
-      puts
-      puts "== Running example/#{name} =="
-      puts
-
-      Bundler.with_unbundled_env do
-        # Install gems for any carton/local example gemfile.
-        Dir
-          .glob(File.join(dir, '**/Gemfile'))
-          .each do |gemfile|
-            pkg_dir = File.dirname(gemfile)
-            sh(
-              "cd #{pkg_dir} && " \
-                'BUNDLE_GEMFILE=Gemfile bundle check >/dev/null 2>&1 || ' \
-                'BUNDLE_GEMFILE=Gemfile bundle install --quiet',
-              verbose: false,
-            )
-          end
-
-        sh "RUBY_BOX=1 ruby #{File.join(dir, 'main.rb')}", verbose: false
-      end
-    end
-  end
-end
-
-desc 'Run all examples'
-task examples: EXAMPLES.map { |n| "example:#{n}" }
-
-desc 'Format code'
-task :format do
-  sh "bundle exec stree write #{STREE_FILES}", verbose: false
-end
-
-task default: %i[test examples]

data/TODO.md

@@ -1,33 +0,0 @@
-# TODO
-
-## Bundler / upstream
-
-- Add a Bundler API that can activate a specific Gemfile explicitly instead of relying on process-global `ENV['BUNDLE_GEMFILE']` and `bundler/setup`.
-- Make multiple bundle contexts safer for embedded runtimes. Today one carton-local bundle can work, but importing a second conflicting bundle in the same process still resolves against the first bundle's shared RubyGems activation state and can crash under `Ruby::Box`.
-- Expose resolved bundle load paths without forcing full `Bundler.setup` and RubyGems entrypoint replacement.
-- Make `Bundler.reset!`, `with_original_env`, and `with_unbundled_env` sufficient for re-entering Bundler with another Gemfile, or add a supported replacement for that workflow.
-- Improve support for a parent process already running under Bundler importing a child carton that needs a different bundle.
-- Make RubyGems activation state such as `Gem.loaded_specs` safely box-local or otherwise explicitly isolateable so two conflicting bundles can coexist under `Ruby::Box` without a subprocess.
-- Investigate whether `Bundler.rubygems.replace_entrypoints`, `stub_rubygems`, `Gem::Specification.all`, and `Gem.clear_paths` can be made box-local. Duplicating `Gem.loaded_specs` inside the box isolated a single bundled import from the root box, but it was not enough to make a second conflicting bundle work.
-
-## Ruby::Box / upstream
-
-- Expose more public APIs or clearer guarantees around box-local `$LOAD_PATH`, `$LOADED_FEATURES`, and feature resolution so libraries like Carton do not need to manually copy parent load paths and call `resolve_feature_path`.
-- Investigate the crash path after conflicting bundled imports under Ruby 4.0 + `Ruby::Box`, even when the immediate conflict is already surfaced as a Bundler/RubyGems activation error.
-
-## Library
-
-- Revisit `Carton::Box#gem_path?`; it still relies partly on path heuristics.
-- Add targeted tests for bundled carton imports instead of covering that behavior only through the complex example.
-- Remove the targeted Minitest `object_id` warning suppression once Ruby::Box or Minitest no longer emits it under Ruby 4.0.
-- Revisit whether `import` should always return a `Carton::Exports` wrapper with a `default` accessor, or whether the current duck-typed return values are the better long-term fit.
-
-## Examples / docs
-
-- Keep the root README intentionally short and push detail into focused docs.
-- Keep documenting current Bundler constraints plainly until the runtime or Bundler story improves.
-
-## Tooling ideas
-
-- Explore a Prism-based strict mode/linter that enforces `import`/`export` calls at file root and can build a static dependency graph without evaluating code.
-- If that exists, add graph validation ideas such as cycle detection, missing import targets, dead imports, and unused exports.

data/USAGE.md

@@ -1,173 +0,0 @@
-# Usage
-
-## Requirements
-
-- Ruby 4.0+
-- `RUBY_BOX=1`
-- `require 'carton'` before using `import`, `import_relative`, `export_default`, or `export`
-
-In Carton, an importable package is called a carton. This guide still says "package" sometimes in plain English, but "carton" is the project term.
-
-## Exporting
-
-### Single export
-
-Use a single export when the file represents one main thing.
-
-```ruby
-# user.rb
-class User
-  def initialize(name) = @name = name
-
-  def greet = "Hello, #{@name}!"
-end
-
-export_default User
-```
-
-Importing that file returns the exported object itself:
-
-```ruby
-User = import_relative 'user'
-User.new('Alice').greet
-```
-
-### Named exports
-
-Use keyword arguments when the file exports a small namespace.
-
-```ruby
-# math.rb
-def add(a, b) = a + b
-
-export(
-  PI: 3.14159,
-  version: '1.0.0',
-  add: method(:add)
-)
-```
-
-Importing named exports returns a `Carton::Exports` object, which behaves like a namespace module.
-
-```ruby
-MathTools = import_relative 'math'
-
-MathTools::PI
-MathTools.version
-MathTools.add(2, 3)
-```
-
-`Carton::Exports` and bare `Carton::Box` imports share a small lookup API: `[]`, `fetch`, `fetch_values`, `values_at`, and `key?`.
-
-Only one export call is allowed per imported file. Use `export_default value` for single exports or `export foo:, bar:` for named exports.
-
-## Importing
-
-### `import_relative`
-
-`import_relative path` resolves relative to the calling file, like `require_relative`.
-
-```ruby
-User = import_relative 'user'
-```
-
-### `import`
-
-`import path` resolves using the current box's `$LOAD_PATH` or an absolute path.
-
-```ruby
-Quest = import 'quest'
-Widget = import '/absolute/path/to/widget.rb'
-```
-
-When you want `import 'name'` to work across local cartons, add their `lib/` directories to `$LOAD_PATH` first.
-
-```ruby
-cartons_dir = File.expand_path('cartons', __dir__)
-
-Dir.glob(File.join(cartons_dir, '*/lib')).sort.each do |dir|
-  $LOAD_PATH.unshift(dir) unless $LOAD_PATH.include?(dir)
-end
-```
-
-The complex example keeps that setup explicit in `examples/complex/main.rb`.
-
-## Destructuring
-
-Named exports support pattern matching through `deconstruct_keys`.
-
-```ruby
-import_relative('math') => { add:, version: }
-
-add.(2, 3)
-version
-```
-
-You can rename during destructuring:
-
-```ruby
-import_relative('math') => { add: sum }
-sum.(10, 10)
-```
-
-## Constants
-
-For exported constants, the simplest options are namespace access, `[]`, or `fetch`.
-
-```ruby
-MathTools = import_relative 'math'
-PI = MathTools::PI
-```
-
-```ruby
-PI = import('math')[:PI]
-```
-
-For multiple values:
-
-```ruby
-PI, version = import_relative('math').fetch_values(:PI, :version)
-```
-
-## Bare imports
-
-If a file does not call `export`, importing it returns the `Carton::Box` itself.
-
-```ruby
-Toolbox = import 'some_script'
-
-Toolbox::SomeConstant
-Toolbox.fetch(:helper)
-```
-
-## Bundler inside cartons
-
-The library works with or without Bundler. Plain cartons need no extra setup. For a bundled carton, the reliable pattern today is still: select the Gemfile around the `import` that loads that carton.
-
-```ruby
-gemfile = File.expand_path('cartons/adventure/Gemfile', __dir__)
-
-Adventure = Carton.with_bundle(gemfile) { import 'adventure' }
-```
-
-`Carton.with_bundle` is just a small wrapper around the same `BUNDLE_GEMFILE` handoff. The underlying constraint is still Bundler's: `bundler/setup` discovers the active Gemfile from env/process state, and RubyGems activation state (`Gem.loaded_specs`) is still shared across boxes in practice, so conflicting bundles still cannot be switched reliably in one process today.
-
-Current limits:
-
-- one carton-local bundle can be activated cleanly from an unbundled parent
-- a bundled parent process is not a reliable place to import a child carton with its own bundle
-- conflicting bundles in one process still need a subprocess workaround
-
-See [TODO.md](TODO.md) for the upstream Bundler work that would make this cleaner.
-
-## Examples
-
-```sh
-RUBY_BOX=1 ruby examples/minimal/main.rb
-RUBY_BOX=1 bundle exec rake example:complex
-```
-
-See the example READMEs for details:
-
-- [examples/minimal/README.md](examples/minimal/README.md)
-- [examples/complex/README.md](examples/complex/README.md)

data/examples/complex/README.md

@@ -1,33 +0,0 @@
-# Complex example
-
-Multi-carton example showing the library directly: explicit load-path setup, a bundled single export loaded by name, a plain carton loaded by name, and a destructured import.
-
-## Cartons
-
-| Carton | Purpose |
-| --- | --- |
-| `main` | explicit feature tour of the library |
-| `adventure` | bundled carton imported by name |
-| `quest` | plain carton imported by name |
-| `loot` | carton that demonstrates a conflicting `dotenv` version via subprocess |
-
-`main.rb` keeps the load-path setup and bundled import explicit on purpose so the example reads like a direct Carton feature tour. `Carton.with_bundle` shortens the `BUNDLE_GEMFILE` handoff, but it is still the same Bundler constraint under the hood.
-
-## Why `loot` still uses a subprocess
-
-One carton-local bundle can be activated from an unbundled parent today. The trouble starts when another box tries to activate a conflicting version: box-local `$LOAD_PATH` is not enough because RubyGems activation state is still shared. `loot` therefore loads its `dotenv` data in a subprocess and selects its Gemfile there instead of using `Carton.with_bundle` during the import itself. That is tracked in [../../TODO.md](../../TODO.md).
-
-## Run
-
-```sh
-RUBY_BOX=1 bundle exec rake example:complex
-```
-
-Or manually:
-
-```sh
-cd examples/complex/cartons/adventure && BUNDLE_GEMFILE=Gemfile bundle install
-cd ../loot && BUNDLE_GEMFILE=Gemfile bundle install
-cd ../../..
-RUBY_BOX=1 ruby examples/complex/main.rb
-```

data/examples/complex/cartons/adventure/.env

@@ -1 +0,0 @@
-BANNER=single export loaded from a bundled carton

data/examples/complex/cartons/adventure/Gemfile

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gem 'dotenv', '~> 3.0'

data/examples/complex/cartons/adventure/Gemfile.lock

@@ -1,17 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    dotenv (3.2.0)
-
-PLATFORMS
-  arm64-darwin-25
-  ruby
-
-DEPENDENCIES
-  dotenv (~> 3.0)
-
-CHECKSUMS
-  dotenv (3.2.0) sha256=e375b83121ea7ca4ce20f214740076129ab8514cd81378161f11c03853fe619d
-
-BUNDLED WITH
-  4.0.3

data/examples/complex/cartons/adventure/lib/adventure.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'dotenv'
-
-module Adventure
-  CONFIG = Dotenv.parse(File.expand_path('../.env', __dir__))
-  def self.banner = CONFIG.fetch('BANNER')
-
-  def self.dotenv_version = Gem.loaded_specs.fetch('dotenv').version.to_s
-end
-
-export_default Adventure

data/examples/complex/cartons/loot/.env

@@ -1 +0,0 @@
-MESSAGE=loaded through a conflicting bundle in a subprocess

data/examples/complex/cartons/loot/Gemfile

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-source 'https://rubygems.org'
-
-gem 'dotenv', '~> 2.0'

data/examples/complex/cartons/loot/Gemfile.lock

@@ -1,17 +0,0 @@
-GEM
-  remote: https://rubygems.org/
-  specs:
-    dotenv (2.8.1)
-
-PLATFORMS
-  arm64-darwin-25
-  ruby
-
-DEPENDENCIES
-  dotenv (~> 2.0)
-
-CHECKSUMS
-  dotenv (2.8.1) sha256=c5944793349ae03c432e1780a2ca929d60b88c7d14d52d630db0508c3a8a17d8
-
-BUNDLED WITH
-  4.0.3