dagger_ruby 0.6.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d55d30e1a649d969398e1f7e4a049e5303cbf037b0b57272e4f7c093c0f86722
-  data.tar.gz: 0d242f193df07c677b1e70c105bfd856a881a740b727376942f4d33a593e0612
+  metadata.gz: 3236161fdcbdb34e426318363c0db9b1625fef0bfff6d83d021908ccaab26e69
+  data.tar.gz: d0510f01bd92c27f6f06ba2c2693007771ffb8d6fb8da663ef2aea8798bd09d6
 SHA512:
-  metadata.gz: c1ab620c788a833a369fa4f587a1ed50d3feab24278c314192bf75afb4b1a42a69a7ad756b03644d699bb424a4dce16087e18af5d265d2befbf47ef92295c6a7
-  data.tar.gz: 2aa572694719d97f99523ef393075fd2468344d975a0e7774a74d1e89d56cd25529d1fddc520c1a9c18887caf3de7d347231c947c67ed2ecc8d788cff44c79bf
+  metadata.gz: fb8c138bbf1c674ad47cffecb4d31c77348c83a4e83e6439f55240925587ba16035f53d21f49995d849807d6d1b9bd70edb0cabec3fe860c521efaade6307539
+  data.tar.gz: ad20b3fb027215a665fb58fbfde7ae125d791e7b596c449ac23f91e87e07e16de154d9775b19d070066855b26cb062e8d69ffe382f64d9c59feab438daa225d6

data/CHANGELOG.md

@@ -1,105 +1,73 @@
 # 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.6.0] - 2025-09-17
+## [0.9.0] - 2026-08-20
 
-  Programmatic Control:
+### Added
+
+- Engine-backed compatibility tests for Dagger 0.21.8.
+- Trusted publishing through RubyGems and GitHub Actions.
+- Security, contribution, and community documentation.
 
-  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
+### Changed
 
-  📋 Progress Options:
+- 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.
 
-  - plain - Simple text progress (no fancy symbols like ▶ ●)
-  - dots - Just dots for progress
-  - tty - Full fancy output (default)
-  - auto - Auto-detect based on terminal
+### Fixed
 
-  🎯 What This Eliminates:
+- 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.
 
-  - All the ▶ connect, ● container: symbols
-  - Timing information like 0.7s, 3.6s CACHED
-  - Complex tree-style progress display
+## [0.8.0] - 2025-01-27
 
-## [0.4.0] - 2025-09-17
+### Changed
 
-1. Environment Variable (Easiest)
+- Simplified internal configuration initialization while keeping its public call
+  shape compatible.
 
-export DAGGER_LOG_LEVEL=error  # Only show errors
-# or
-DAGGER_LOG_LEVEL=warn your_ruby_script.rb  # Only warnings and errors
+### Fixed
 
-2. Programmatic Configuration
+- Corrected `withDirectory` query arguments.
 
-config = DaggerRuby::Config.new(engine_log_level: "error")
-DaggerRuby.connection(config) do |client|
-# Your dagger operations with minimal logging
-end
+## [0.6.0] - 2025-01-17
 
-3. Available Log Levels (from most to least verbose):
+### Added
 
-- trace - Everything (most verbose)
-- debug - Default Dagger behavior
-- info - Informational messages
-- warn - Warnings and errors (new default)
-- error - Only errors (cleanest output)
+- Progress and engine-log configuration.
 
-What Changed:
+## [0.4.0] - 2024-12-19
 
-- 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
+### Added
+
+- 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.9.0...HEAD
+[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,186 @@
-# 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 4.0 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,
+)
 
 DaggerRuby.connection(config) do |client|
-  # Your pipeline code
+  # Build pipeline
 end
 ```
 
-## Error Handling
+`DAGGER_QUIET`, `DAGGER_SILENT`, and `DAGGER_PROGRESS` can provide the same CLI
+preferences through the environment.
 
-DaggerRuby provides specific error classes for different failure scenarios:
+## Errors
+
+Connection, transport, GraphQL, and invalid-query failures use dedicated error
+classes:
 
 ```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}"
+  DaggerRuby.connection { |client| puts client.container.from("missing").stdout }
+rescue DaggerRuby::ConnectionError, DaggerRuby::GraphQLError => error
+  warn error.message
 end
 ```
 
-## Best Practices
-
-### 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)
-
-# Bad: No caching, slower builds
-container.with_exec(["npm", "install"])
-```
-
-### 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"))
-```
-
-### 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!
-```
-
-## 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 Ruby 4.0 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.