dagger_ruby 0.7.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b40c8d40fe3d5a0e8ee5aa6c8ca2b5e48f564117b03f9d11d482cd9fd47452ab
-  data.tar.gz: 020ed088da44bb8f8ca16316491d15b32de2d654ddc6cf67941d482b9a0c72e6
+  metadata.gz: 4a4bcab9db019b25e782aab84ab1e3b154bda15f64cb7d1ffdd522d14cbfb729
+  data.tar.gz: 41e902336fe58545784c21e85a17cc55961a9aab6ad2c6370547ffb4d4779eb5
 SHA512:
-  metadata.gz: 855d15fd372059950028407385935085961a9f0488e1f38d8162253a1143caae51e0c2ac97a8ee913f7e2e38ad89dcdd49f6c766413c20741922117cc4c8c24d
-  data.tar.gz: b14cb681341a1b2db7c8c045658a16f1928c93049bb532afd393bc707e50c08a2f58e796d8a9636cb8741c55f3ecc4b51b262d21244067d9bc8be7565c164521
+  metadata.gz: 897cdcb244f34e704a70f2bb47fdeadeb946c2c29e0fff763cf0b487122657a11d2bee3d664593c0b268baf45eba0cbf9b8da1e889eb601e1f4ad6ed7056e1b2
+  data.tar.gz: c52a3cfff5a10a1ef6c8bc1e522c56bf423642dbfbc57bcc76c03e84a61e31e8f346a8157bffb53e112d2a77cdfd044b6d4c562784f9afa785f0460d02f98864

data/CHANGELOG.md

@@ -1,126 +1,87 @@
 # Changelog
 
-All notable changes to this project will be documented in this file.
+All notable changes are recorded here. The format follows
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and versions follow
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+## [Unreleased]
 
-## [0.7.0] - 2025-01-27
+## [0.10.0] - 2026-08-25
 
-### Fixed
+### Added
 
-- **Code Quality**: Refactored `DaggerRuby.connection` method to reduce cyclomatic complexity from 13 to under 12 and perceived complexity from 15 to under 12
-- **Code Quality**: Simplified `Config#initialize` method by replacing 6 individual keyword parameters with a single hash parameter
-- **Tests**: Fixed test assertion in `test_with_directory_mounts_directory` to align with Dagger API - changed from `"directory"` to `"source"` key in `withDirectory` operation arguments
-- **Environment Variables**: Improved environment variable handling using `ENV.fetch` for more consistent nil handling
+- Explicit Apple Container and Docker runner selection.
+- Compatible Dagger CLI and engine verification before standalone sessions.
+- Container default-argument, Docker healthcheck, and host image-store export APIs.
 
 ### Changed
 
-- **Config Constructor**: `DaggerRuby::Config.new` now accepts a hash of options instead of individual keyword arguments
-  - Old: `Config.new(log_output: $stdout, workdir: "/tmp", timeout: 300)`
-  - New: `Config.new(log_output: $stdout, workdir: "/tmp", timeout: 300)` (same syntax, but internally uses hash)
+- Support Ruby 3.2 and newer so Ruby applications do not need Ruby 4 solely to
+  use the Dagger client.
 
-### Technical Details
+## [0.9.0] - 2026-08-20
 
-- Broke down complex `connection` method into focused helper methods: `existing_session?`, `handle_existing_session`, `start_new_session`, `build_dagger_command`, `build_ruby_command`, `build_dagger_options`
-- Maintained backward compatibility - all existing code continues to work without changes
-- All tests pass with improved code structure and maintainability
+### Added
 
-## [0.6.0] - 2025-09-17
+- Engine-backed compatibility tests for Dagger 0.21.8.
+- Trusted publishing through RubyGems and GitHub Actions.
+- Security, contribution, and community documentation.
 
-  Programmatic Control:
+### Changed
 
-  config = DaggerRuby::Config.new(
-    engine_log_level: "error",  # Only errors
-    progress: "plain"           # Clean progress format
-  )
-  DaggerRuby.connection(config) do |client|
-    # Your operations with clean output
-  end
+- Require Ruby 4.0 or newer.
+- Align container, directory, file, Git, host, secret, cache, and service queries
+  with the Dagger 0.21.8 GraphQL schema.
+- Update runtime and development dependencies.
+- Present the project as a community-maintained client with an explicit
+  compatibility policy.
 
-  📋 Progress Options:
+### Fixed
 
-  - plain - Simple text progress (no fancy symbols like ▶ ●)
-  - dots - Just dots for progress
-  - tty - Full fancy output (default)
-  - auto - Auto-detect based on terminal
+- Preserve the value returned by `DaggerRuby.connection` blocks.
+- Forward script names and arguments to `dagger run` without shell interpolation.
+- Escape GraphQL strings and select nested fields consistently.
 
-  🎯 What This Eliminates:
+## [0.8.0] - 2025-01-27
 
-  - All the ▶ connect, ● container: symbols
-  - Timing information like 0.7s, 3.6s CACHED
-  - Complex tree-style progress display
+### Changed
 
-## [0.4.0] - 2025-09-17
+- Simplified internal configuration initialization while keeping its public call
+  shape compatible.
 
-1. Environment Variable (Easiest)
+### Fixed
 
-export DAGGER_LOG_LEVEL=error  # Only show errors
-# or
-DAGGER_LOG_LEVEL=warn your_ruby_script.rb  # Only warnings and errors
+- Corrected `withDirectory` query arguments.
 
-2. Programmatic Configuration
+## [0.6.0] - 2025-01-17
 
-config = DaggerRuby::Config.new(engine_log_level: "error")
-DaggerRuby.connection(config) do |client|
-# Your dagger operations with minimal logging
-end
+### Added
 
-3. Available Log Levels (from most to least verbose):
+- Progress and engine-log configuration.
 
-- trace - Everything (most verbose)
-- debug - Default Dagger behavior
-- info - Informational messages
-- warn - Warnings and errors (new default)
-- error - Only errors (cleanest output)
+## [0.4.0] - 2024-12-19
 
-What Changed:
+### Added
 
-- Added engine_log_level to Config class (lib/dagger_ruby/config.rb:5)
-- Modified dagger run command to pass --log-level flag (lib/dagger_ruby.rb:35-38)
-- Environment variable DAGGER_LOG_LEVEL support
-- Tests updated and passing
+- Dagger log-level configuration.
 
 ## [0.3.0] - 2024-12-19
 
-### Fixed 
+### Fixed
 
-- Removed unwanted Gemfile dependencies 
-- Rubocop
+- Dependency and lint configuration.
 
 ## [0.1.0] - 2024-12-19
 
 ### Added
-- Complete Dagger Ruby SDK with full API coverage
-- Smart connection handling that auto-detects Dagger sessions
-- Container operations (from, with_exec, with_directory, with_mounted_cache, etc.)
-- Directory and file operations with proper GraphQL query generation
-- Cache volume management for build optimization
-- Secret management and mounting
-- HTTP GraphQL client with session token authentication
-- Lazy execution with method chaining
-- Comprehensive test suite (72 tests, 119 assertions, 0 failures)
-- Working examples with dummy applications
-- Integration with BoringBuildRuby for Rails application builds
-
-### Features
-- **Client**: GraphQL client with automatic session detection
-- **Container**: Full container lifecycle management and operations
-- **Directory**: File system operations and directory manipulation
-- **File**: File reading, writing, and export operations  
-- **Cache Volume**: Build caching for faster rebuilds
-- **Secret**: Secure secret injection and mounting
-- **Query Builder**: Optimized GraphQL query generation
-- **Error Handling**: Comprehensive error types and messages
-
-### Examples
-- Simple Ruby application build with caching
-- Rails CI/CD pipeline with multi-environment support
-- BoringBuildRuby integration for optimized Rails builds
-- Cowsay demonstration of basic operations
-
-### Performance
-- Lazy evaluation prevents unnecessary API calls
-- Cache volumes provide 50-80% faster rebuilds
-- Optimized GraphQL query generation
-- HTTP connection reuse and pooling 
+
+- Initial container, directory, file, cache, secret, Git, and GraphQL client.
+
+[Unreleased]: https://github.com/boringcache/dagger_ruby/compare/v0.10.0...HEAD
+[0.10.0]: https://github.com/boringcache/dagger_ruby/compare/v0.9.0...v0.10.0
+[0.9.0]: https://github.com/boringcache/dagger_ruby/compare/v0.8.0...v0.9.0
+[0.8.0]: https://github.com/boringcache/dagger_ruby/releases/tag/v0.8.0
+[0.6.0]: https://github.com/boringcache/dagger_ruby/releases/tag/v0.6.0
+[0.4.0]: https://github.com/boringcache/dagger_ruby/releases/tag/v0.4.0
+[0.3.0]: https://github.com/boringcache/dagger_ruby/releases/tag/v0.3.0
+[0.1.0]: https://github.com/boringcache/dagger_ruby/releases/tag/v0.1.0

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2025 Gaurav Tiwari
+Copyright (c) 2025 BoringCache
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,319 +1,194 @@
-# DaggerRuby
+# Dagger Ruby
 
-A Ruby SDK for [Dagger](https://dagger.io) - build powerful CI/CD pipelines using Ruby code instead of YAML configurations.
+[![CI](https://github.com/boringcache/dagger_ruby/actions/workflows/main.yml/badge.svg)](https://github.com/boringcache/dagger_ruby/actions/workflows/main.yml)
+[![Gem Version](https://badge.fury.io/rb/dagger_ruby.svg)](https://rubygems.org/gems/dagger_ruby)
 
-DaggerRuby provides a fluent, idiomatic Ruby interface to Dagger's container-based CI/CD engine, enabling you to define build pipelines programmatically with the full power of Ruby.
+A small, chainable Ruby client for [Dagger](https://dagger.io). Use Ruby to run
+container builds, mount source directories and caches, pass secrets, and connect
+services through Dagger's GraphQL API.
 
-## Installation
-
-Add this line to your application's Gemfile:
+This is a community-maintained client, not an official Dagger SDK. It deliberately
+covers a practical subset of the API instead of Dagger module code generation.
 
-```ruby
-gem 'dagger_ruby'
-```
+## Requirements
 
-And then execute:
+- Ruby 3.2 or newer
+- Dagger 0.21.8
+- Docker, Colima, or another container runtime supported by Dagger
 
-```bash
-bundle install
-```
+## Installation
 
-Or install it yourself with:
+Add the gem to your bundle:
 
 ```bash
-gem install dagger_ruby
+bundle add dagger_ruby
 ```
 
-### Prerequisites
+Install the [Dagger CLI](https://docs.dagger.io/getting-started/installation/) if
+it is not already available.
 
-- Ruby 3.1 or higher
-- [Dagger CLI](https://docs.dagger.io/install) installed
-- Docker or compatible container runtime (Docker Desktop, Podman, etc.)
+## Quick start
 
-## Quick Start
+Create `pipeline.rb`:
 
 ```ruby
-require 'dagger_ruby'
+require "dagger_ruby"
 
 DaggerRuby.connection do |client|
-  result = client.container
-    .from("alpine:latest")
-    .with_exec(["echo", "hello world"])
-    .stdout
-  
-  puts result
+  output = client.container
+                 .from("alpine:3.22")
+                 .with_exec(["echo", "hello from Dagger"])
+                 .stdout
+
+  puts output
 end
 ```
 
-Run your script with Dagger:
+Then run it normally:
 
 ```bash
-dagger run ruby your_script.rb
+bundle exec ruby pipeline.rb
 ```
 
-## Key Features
+Outside an existing Dagger session, `DaggerRuby.connection` restarts the script
+under `dagger run`. Inside a session, it connects directly. You can also make the
+session explicit:
 
-- **Smart Connection**: Auto-detects Dagger sessions
-- **Lazy Execution**: Queries built but not executed until needed
-- **Cache Volumes**: Fast builds with persistent caching
-- **Secrets Management**: Secure handling of sensitive data
-- **Git Integration**: Clone and build from repositories
-- **Registry Auth**: Push to private registries
-- **Multi-platform**: Build for multiple architectures
+```bash
+dagger run -- bundle exec ruby pipeline.rb
+```
 
-## Examples
+## Common operations
 
-### Basic Container
-```ruby
-DaggerRuby.connection do |client|
-  client.container
-    .from("python:alpine")
-    .with_exec(["pip", "install", "cowsay"])
-    .with_exec(["cowsay", "Hello from Dagger!"])
-    .stdout
-end
-```
+Mount the current project and a persistent Bundler cache:
 
-### With Caching
 ```ruby
 DaggerRuby.connection do |client|
-  cache = client.cache_volume("bundle-cache")
-  
-  client.container
-    .from("ruby:3.2")
-    .with_mounted_cache("/usr/local/bundle", cache)
-    .with_exec(["bundle", "install"])
-    .with_exec(["ruby", "app.rb"])
+  source = client.host.directory(Dir.pwd, exclude: [".git", "vendor"])
+  gems = client.cache_volume("bundle-cache")
+
+  tests = client.container
+                .from("ruby:4.0.6")
+                .with_directory("/src", source)
+                .with_mounted_cache("/usr/local/bundle", gems)
+                .with_workdir("/src")
+                .with_exec(["bundle", "install"])
+                .with_exec(["bundle", "exec", "rake", "test"])
+
+  puts tests.stdout
 end
 ```
 
-### Git Repository
-```ruby
-DaggerRuby.connection do |client|
-  source = client.git("https://github.com/user/repo.git")
-    .branch("main")
-    .tree
-    
-  client.container
-    .from("node:18")
-    .with_directory("/src", source)
-    .with_exec(["npm", "install"])
-    .with_exec(["npm", "run", "build"])
-end
-```
+Pass a secret without placing its plaintext in the container definition:
 
-### Secret Management
 ```ruby
 DaggerRuby.connection do |client|
-  # Set a secret
-  db_password = client.set_secret("db_password", "super_secret")
-  
-  client.container
-    .from("postgres:15")
-    .with_secret_variable("POSTGRES_PASSWORD", db_password)
-    .with_exec(["postgres"])
-end
-```
+  token = client.set_secret("registry-token", ENV.fetch("REGISTRY_TOKEN"))
 
-### Multi-stage Builds
-```ruby
-DaggerRuby.connection do |client|
-  # Build stage
-  builder = client.container
-    .from("golang:1.21")
-    .with_directory("/src", client.host.directory("."))
-    .with_workdir("/src")
-    .with_exec(["go", "build", "-o", "app"])
-  
-  # Runtime stage
-  client.container
-    .from("alpine:latest")
-    .with_file("/bin/app", builder.file("/src/app"))
-    .with_entrypoint(["/bin/app"])
-end
-```
+  result = client.container
+                 .from("alpine:3.22")
+                 .with_secret_variable("REGISTRY_TOKEN", token)
+                 .with_exec(["sh", "-c", "test -n \"$REGISTRY_TOKEN\""])
+                 .exit_code
 
-### Building and Pushing Images
-```ruby
-DaggerRuby.connection do |client|
-  ref = client.container
-    .from("node:18")
-    .with_directory("/app", client.host.directory("."))
-    .with_workdir("/app")
-    .with_exec(["npm", "ci"])
-    .with_exec(["npm", "run", "build"])
-    .publish("registry.example.com/my-app:latest")
-  
-  puts "Published image: #{ref}"
+  abort "secret was unavailable" unless result.zero?
 end
 ```
 
-## Advanced Usage
+Bind a service to another container:
 
-### Working with Services
 ```ruby
 DaggerRuby.connection do |client|
-  # Start a database service
-  postgres = client.container
-    .from("postgres:15")
-    .with_env_variable("POSTGRES_PASSWORD", "password")
-    .with_exposed_port(5432)
-    .as_service
-  
-  # Run tests against the database
-  client.container
-    .from("ruby:3.2")
-    .with_service_binding("db", postgres)
-    .with_env_variable("DATABASE_URL", "postgres://postgres:password@db:5432/test")
-    .with_exec(["bundle", "exec", "rspec"])
+  redis = client.container
+                .from("redis:8-alpine")
+                .with_exposed_port(6379)
+                .as_service
+
+  pong = client.container
+               .from("redis:8-alpine")
+               .with_service_binding("redis", redis)
+               .with_exec(["redis-cli", "-h", "redis", "ping"])
+               .stdout
+
+  puts pong
 end
 ```
 
-### Cross-platform Builds
+Clone a repository:
+
 ```ruby
-DaggerRuby.connection do |client|
-  platforms = ["linux/amd64", "linux/arm64"]
-  
-  platforms.each do |platform|
-    ref = client.container(platform: platform)
-      .from("golang:1.21")
-      .with_directory("/src", client.host.directory("."))
-      .with_workdir("/src")
-      .with_exec(["go", "build", "-o", "app"])
-      .publish("my-registry.com/app:latest-#{platform.gsub('/', '-')}")
-    
-    puts "Built for #{platform}: #{ref}"
-  end
-end
+source = client.git("https://github.com/example/project.git")
+               .branch("main")
+               .tree
 ```
 
-## Configuration
+Authenticated Git and registry operations accept Dagger `Secret` objects; see
+the public methods in `DaggerRuby::Client` and `DaggerRuby::Container` for the
+available options.
 
-DaggerRuby can be configured using a configuration object:
+## Configuration
 
 ```ruby
-config = DaggerRuby::Config.new
-config.timeout = 300  # Set timeout to 5 minutes
-config.log_output = STDOUT  # Enable logging
+config = DaggerRuby::Config.new(
+  timeout: 300,
+  progress: "plain",
+  log_output: $stderr,
+  runtime: :apple,
+)
 
 DaggerRuby.connection(config) do |client|
-  # Your pipeline code
-end
-```
-
-## Error Handling
-
-DaggerRuby provides specific error classes for different failure scenarios:
-
-```ruby
-begin
-  DaggerRuby.connection do |client|
-    client.container
-      .from("nonexistent:image")
-      .stdout
-  end
-rescue DaggerRuby::ConnectionError => e
-  puts "Failed to connect to Dagger: #{e.message}"
-rescue DaggerRuby::GraphQLError => e
-  puts "GraphQL error: #{e.message}"
-rescue DaggerRuby::InvalidQueryError => e
-  puts "Invalid query: #{e.message}"
+  # Build pipeline
 end
 ```
 
-## Best Practices
+`DAGGER_QUIET`, `DAGGER_SILENT`, and `DAGGER_PROGRESS` can provide the same CLI
+preferences through the environment.
 
-### 1. Use Cache Volumes for Dependencies
-```ruby
-# Good: Use cache volumes for package managers
-cache = client.cache_volume("npm-cache")
-container.with_mounted_cache("/root/.npm", cache)
+The client verifies the installed Dagger CLI before it starts a runner and then
+verifies the connected engine version. This matters for runtime drivers because
+the compatible CLI provisions the runner; merely pointing an older CLI at a
+newer engine image is not sufficient. Use `runtime: :apple` or `runtime: :docker`
+when more than one runtime is installed and automatic detection would be
+ambiguous. A custom runner can be selected with `runner_host:`.
 
-# Bad: No caching, slower builds
-container.with_exec(["npm", "install"])
-```
+## Errors
 
-### 2. Leverage Multi-stage Builds
-```ruby
-# Separate build and runtime environments for smaller images
-builder = client.container.from("node:18").with_exec(["npm", "run", "build"])
-runtime = client.container.from("nginx:alpine").with_directory("/usr/share/nginx/html", builder.directory("/app/dist"))
-```
+Connection, transport, GraphQL, and invalid-query failures use dedicated error
+classes:
 
-### 3. Use Secrets for Sensitive Data
 ```ruby
-# Good: Use Dagger secrets
-api_key = client.set_secret("api_key", ENV["API_KEY"])
-container.with_secret_variable("API_KEY", api_key)
-
-# Bad: Expose secrets in environment variables
-container.with_env_variable("API_KEY", ENV["API_KEY"])  # This gets cached!
+begin
+  DaggerRuby.connection { |client| puts client.container.from("missing").stdout }
+rescue DaggerRuby::ConnectionError, DaggerRuby::GraphQLError => error
+  warn error.message
+end
 ```
 
-## Examples
-
-See the `examples/` directory for complete working examples:
+## Compatibility
 
-- `examples/cowsay.rb` - Simple container execution
-- `examples/ruby_app_build.rb` - Ruby web application build and validation
-- `examples/service_test.rb` - App testing and validation
-- `examples/simple_service.rb` - Quick service binding demo with Redis
-
-### Running Examples
-
-```bash
-# Simple container example
-dagger run ruby examples/cowsay.rb "Hello Dagger!"
-
-# Build and validate a Ruby web application
-dagger run ruby examples/ruby_app_build.rb
-
-# Test and validate app without services
-dagger run ruby examples/service_test.rb
-
-# Quick service binding example
-dagger run ruby examples/simple_service.rb
-```
+The current branch is tested against maintained Ruby releases and Dagger 0.21.8. Dagger's
+GraphQL schema can change between releases, so each supported engine update is
+validated by the live integration suite before release. Earlier Ruby and Dagger
+versions are not covered by the current compatibility contract.
 
 ## Development
 
-After checking out the repo, run:
-
 ```bash
-bin/setup    # Install dependencies
-bin/console  # Start an interactive prompt
+bin/setup
+bin/ci
 ```
 
-To run tests:
+The fast suite stubs the GraphQL endpoint. Run the engine-backed contract tests
+with the supported Dagger version:
 
 ```bash
-bundle exec rake test
+DAGGER_LIVE_TESTS=1 dagger run -- bundle exec ruby test/integration/test_dagger_engine.rb
 ```
 
-## Contributing
-
-1. Fork the repository
-2. Create your feature branch (`git checkout -b feature/amazing-feature`)
-3. Commit your changes (`git commit -am 'Add amazing feature'`)
-4. Push to the branch (`git push origin feature/amazing-feature`)
-5. Open a Pull Request
-
-## Requirements
-
-- Ruby 3.1+
-- Dagger CLI
-- Docker or compatible container runtime
-
-## Support
-
-- [GitHub Issues](https://github.com/boring-build/dagger-ruby/issues) - Bug reports and feature requests
-- [Dagger Documentation](https://docs.dagger.io) - Official Dagger documentation
-- [Ruby Documentation](https://docs.ruby-lang.org) - Ruby language documentation
-
-## Acknowledgments
-
-Built with ❤️ using **Claude Sonnet 3.5/4** + **GPT-4** AI assistance.
+Working examples live in [`examples/`](examples). Contribution and security
+guidance are in [`CONTRIBUTING.md`](CONTRIBUTING.md) and
+[`SECURITY.md`](SECURITY.md).
 
 ## License
 
-MIT
+Dagger Ruby is available under the [MIT License](LICENSE.txt).

data/SECURITY.md

@@ -0,0 +1,18 @@
+# Security policy
+
+## Supported versions
+
+Security fixes are made on the latest released version. Please upgrade before
+reporting a problem that only affects an older release.
+
+## Reporting a vulnerability
+
+Use [GitHub's private vulnerability reporting](https://github.com/boringcache/dagger_ruby/security/advisories/new).
+Do not open a public issue for a suspected vulnerability.
+
+Include the affected version, a minimal reproduction, the likely impact, and any
+suggested remediation. Maintainers will acknowledge a complete report within
+seven days and coordinate disclosure after a fix is available.
+
+Never include real credentials, tokens, customer data, or other secrets in a
+report or reproduction.