dagger_ruby 0.6.0 → 0.9.0

data/lib/dagger_ruby/file.rb

@@ -4,12 +4,6 @@ require_relative "dagger_object"
 
 module DaggerRuby
   class File < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("file")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "file"
     end
@@ -18,20 +12,15 @@ module DaggerRuby
       chain_operation("withName", { "name" => name })
     end
 
-    def with_contents(contents)
-      chain_operation("withContents", { "contents" => contents })
-    end
-
     def with_timestamps(timestamp)
       chain_operation("withTimestamps", { "timestamp" => timestamp })
     end
 
-    def with_secret(secret)
-      chain_operation("withSecret", { "secret" => secret })
-    end
-
-    def contents
-      get_scalar("contents")
+    def contents(offset_lines: nil, limit_lines: nil)
+      args = {}
+      args["offsetLines"] = offset_lines if offset_lines
+      args["limitLines"] = limit_lines if limit_lines
+      get_scalar("contents", args)
     end
 
     def size
@@ -42,48 +31,27 @@ module DaggerRuby
       get_scalar("name")
     end
 
+    def chown(owner)
+      chain_operation("chown", { "owner" => owner })
+    end
+
+    def with_replaced(search, replacement, opts = {})
+      args = { "search" => search, "replacement" => replacement }
+      args["all"] = opts[:all] if opts.key?(:all)
+      args["firstFrom"] = opts[:first_from] if opts[:first_from]
+      chain_operation("withReplaced", args)
+    end
+
     def export(path, opts = {})
       args = { "path" => path }
       args["allowParentDirPath"] = opts[:allow_parent_dir_path] if opts.key?(:allow_parent_dir_path)
 
-      query = @query_builder.build_query_with_selection("export(#{format_arguments(args)})")
-      result = @client.execute(query)
-      extract_value_from_result(result, "export")
+      get_scalar("export", args)
     end
 
     def sync
       get_scalar("id")
       self
     end
-
-    private
-
-    def format_arguments(args)
-      return "" if args.empty?
-
-      args.map { |key, value| "#{key}: #{format_value(value)}" }.join(", ")
-    end
-
-    def format_value(value)
-      case value
-      when String
-        "\"#{value}\""
-      when Integer, Float
-        value.to_s
-      when TrueClass, FalseClass
-        value.to_s
-      when NilClass
-        "null"
-      when Array
-        "[#{value.map { |v| format_value(v) }.join(", ")}]"
-      when Hash
-        formatted_pairs = value.map { |k, v| "#{k}: #{format_value(v)}" }
-        "{ #{formatted_pairs.join(", ")} }"
-      when DaggerObject
-        value.id
-      else
-        "\"#{value}\""
-      end
-    end
   end
 end

data/lib/dagger_ruby/git_repository.rb

@@ -4,12 +4,6 @@ require_relative "dagger_object"
 
 module DaggerRuby
   class GitRepository < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("gitRepository")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "gitRepository"
     end
@@ -30,20 +24,16 @@ module DaggerRuby
       get_object("head", GitRef)
     end
 
-    def branches
-      get_scalar("branches")
-    end
-
-    def tags
-      get_scalar("tags")
-    end
-
-    def with_auth_token(token)
-      chain_operation("withAuthToken", { "token" => token.is_a?(DaggerObject) ? token.id : token })
+    def branches(patterns: nil)
+      args = {}
+      args["patterns"] = patterns if patterns
+      get_scalar("branches", args)
     end
 
-    def with_auth_header(header)
-      chain_operation("withAuthHeader", { "header" => header.is_a?(DaggerObject) ? header.id : header })
+    def tags(patterns: nil)
+      args = {}
+      args["patterns"] = patterns if patterns
+      get_scalar("tags", args)
     end
 
     def sync
@@ -53,12 +43,6 @@ module DaggerRuby
   end
 
   class GitRef < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("gitRef")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "gitRef"
     end
@@ -73,11 +57,14 @@ module DaggerRuby
 
     def tree(opts = {})
       args = {}
-      args["path"] = opts[:path] if opts[:path]
-      args["exclude"] = opts[:exclude] if opts[:exclude]
-      args["include"] = opts[:include] if opts[:include]
-
-      get_object("tree", Directory, args)
+      args["discardGitDir"] = opts[:discard_git_dir] if opts.key?(:discard_git_dir)
+      args["depth"] = opts[:depth] if opts[:depth]
+      args["includeTags"] = opts[:include_tags] if opts.key?(:include_tags)
+
+      directory = get_object("tree", Directory, args)
+      directory = directory.directory(opts[:path]) if opts[:path]
+      directory = directory.filter(exclude: opts[:exclude], include: opts[:include]) if opts[:exclude] || opts[:include]
+      directory
     end
 
     def sync

data/lib/dagger_ruby/host.rb

@@ -5,12 +5,6 @@ require_relative "dagger_object"
 
 module DaggerRuby
   class Host < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("host")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "host"
     end
@@ -19,22 +13,22 @@ module DaggerRuby
       args = { "path" => path }
       args["exclude"] = opts[:exclude] if opts[:exclude]
       args["include"] = opts[:include] if opts[:include]
+      args["noCache"] = opts[:no_cache] if opts.key?(:no_cache)
+      args["gitignore"] = opts[:gitignore] if opts[:gitignore]
 
       get_object("directory", Directory, args)
     end
 
-    def file(path)
-      get_object("file", File, { "path" => path })
+    def file(path, no_cache: nil)
+      args = { "path" => path }
+      args["noCache"] = no_cache unless no_cache.nil?
+      get_object("file", File, args)
     end
 
     def unix_socket(path)
       get_object("unixSocket", Socket, { "path" => path })
     end
 
-    def workdir
-      get_scalar("workdir")
-    end
-
     def sync
       get_scalar("id")
       self
@@ -42,12 +36,6 @@ module DaggerRuby
   end
 
   class Socket < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("socket")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "socket"
     end

data/lib/dagger_ruby/query_builder.rb

@@ -7,6 +7,10 @@ module DaggerRuby
   class QueryBuilder
     attr_reader :root_field, :operation_chain, :variables
 
+    def self.enum_value(value)
+      value.is_a?(Hash) ? value : value.to_sym
+    end
+
     def initialize(root_field = nil)
       @root_field = root_field
       @operation_chain = []
@@ -20,10 +24,6 @@ module DaggerRuby
       new_query
     end
 
-    def load_from_id(id)
-      chain_operation("loadFromId", { "id" => id })
-    end
-
     def variable(name, type)
       new_query = QueryBuilder.new(@root_field)
       new_query.instance_variable_set(:@operation_chain, @operation_chain.dup)
@@ -31,7 +31,8 @@ module DaggerRuby
       new_query
     end
 
-    def build_query_with_selection(field)
+    def build_query_with_selection(field, args = {})
+      selection = field_selection(field, args)
       query_parts = []
 
       if @variables.any?
@@ -43,21 +44,25 @@ module DaggerRuby
 
       if @root_field
         if @operation_chain.empty?
-          query_parts << "{ #{@root_field} { #{field} } }"
+          query_parts << "{ #{@root_field} { #{selection} } }"
         else
-          operations_str = build_operations_chain_with_selection(field)
+          operations_str = build_operations_chain_with_selection(selection)
           query_parts << "{ #{@root_field} { #{operations_str} } }"
         end
       elsif @operation_chain.any?
-        operations_str = build_operations_chain_with_selection(field)
+        operations_str = build_operations_chain_with_selection(selection)
         query_parts << "{ #{operations_str} }"
       else
-        query_parts << "{ #{field} }"
+        query_parts << "{ #{selection} }"
       end
 
       query_parts.join(" ")
     end
 
+    def field_selection(field, args = {})
+      "#{field}#{format_arguments(args)}"
+    end
+
     private
 
     def build_operations_chain_with_selection(field)

data/lib/dagger_ruby/secret.rb

@@ -4,24 +4,10 @@ require_relative "dagger_object"
 
 module DaggerRuby
   class Secret < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("secret")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "secret"
     end
 
-    def with_name(name)
-      chain_operation("withName", { "name" => name })
-    end
-
-    def with_plaintext(plaintext)
-      chain_operation("withPlaintext", { "plaintext" => plaintext })
-    end
-
     def name
       get_scalar("name")
     end

data/lib/dagger_ruby/service.rb

@@ -4,12 +4,6 @@ require_relative "dagger_object"
 
 module DaggerRuby
   class Service < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("service")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "service"
     end
@@ -19,13 +13,7 @@ module DaggerRuby
       args["port"] = opts[:port] if opts[:port]
       args["scheme"] = opts[:scheme] if opts[:scheme]
 
-      if args.empty?
-        get_scalar("endpoint")
-      else
-        query = @query_builder.build_query_with_selection("endpoint(#{format_arguments(args)})")
-        result = @client.execute(query)
-        extract_value_from_result(result, "endpoint")
-      end
+      get_scalar("endpoint", args)
     end
 
     def hostname
@@ -33,42 +21,26 @@ module DaggerRuby
     end
 
     def ports
-      get_scalar("ports")
+      get_selection("ports", "port protocol description experimentalSkipHealthcheck")
     end
 
     def start
-      query = @query_builder.build_query_with_selection("start")
-      result = @client.execute(query)
-      extract_value_from_result(result, "start")
+      get_scalar("start")
     end
 
     def stop(opts = {})
       args = {}
       args["kill"] = opts[:kill] if opts.key?(:kill)
 
-      query = if args.empty?
-                @query_builder.build_query_with_selection("stop")
-              else
-                @query_builder.build_query_with_selection("stop(#{format_arguments(args)})")
-              end
-
-      result = @client.execute(query)
-      extract_value_from_result(result, "stop")
+      get_scalar("stop", args)
     end
 
     def up(opts = {})
       args = {}
-      args["ports"] = opts[:ports] if opts[:ports]
+      args["ports"] = opts[:ports].map { |port| normalize_port_forward(port) } if opts[:ports]
       args["random"] = opts[:random] if opts.key?(:random)
 
-      query = if args.empty?
-                @query_builder.build_query_with_selection("up")
-              else
-                @query_builder.build_query_with_selection("up(#{format_arguments(args)})")
-              end
-
-      result = @client.execute(query)
-      extract_value_from_result(result, "up")
+      get_scalar("up", args)
     end
 
     def with_hostname(hostname)
@@ -82,31 +54,10 @@ module DaggerRuby
 
     private
 
-    def format_arguments(args)
-      return "" if args.empty?
-
-      args.map { |key, value| "#{key}: #{format_value(value)}" }.join(", ")
-    end
-
-    def format_value(value)
-      case value
-      when String
-        "\"#{value}\""
-      when Integer, Float
-        value.to_s
-      when TrueClass, FalseClass
-        value.to_s
-      when NilClass
-        "null"
-      when Array
-        "[#{value.map { |v| format_value(v) }.join(", ")}]"
-      when Hash
-        formatted_pairs = value.map { |k, v| "#{k}: #{format_value(v)}" }
-        "{ #{formatted_pairs.join(", ")} }"
-      when DaggerObject
-        value.id
-      else
-        "\"#{value}\""
+    def normalize_port_forward(port)
+      port.to_h do |key, value|
+        normalized = key.to_s == "protocol" ? QueryBuilder.enum_value(value) : value
+        [key, normalized]
       end
     end
   end

data/lib/dagger_ruby/version.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 module DaggerRuby
-  VERSION = "0.6.0"
+  VERSION = "0.9.0"
+  DAGGER_VERSION = "0.21.8"
 end

data/lib/dagger_ruby.rb

@@ -7,46 +7,55 @@ require_relative "dagger_ruby/errors"
 
 module DaggerRuby
   class << self
-    def connection(config = nil)
-      # If we're already in a dagger session, use it
-      if ENV["DAGGER_SESSION_PORT"] && ENV["DAGGER_SESSION_TOKEN"]
-        client = Client.new(config: config)
-        if block_given?
-          begin
-            yield client
-          ensure
-            client.close
-          end
-        else
-          client
-        end
-      else
-        # Otherwise, start a new dagger session
-        require "open3"
-
-        # Get the current script and its arguments
-        script = $PROGRAM_NAME
-        args = ARGV
-
-        # Construct the command that dagger should run
-        ruby_cmd = ["ruby", script, *args].join(" ")
-
-        # Get verbosity options from config or environment
-        quiet = config&.quiet || ENV["DAGGER_QUIET"]&.to_i
-        silent = config&.silent || ENV["DAGGER_SILENT"] == "true"
-        progress = config&.progress || ENV.fetch("DAGGER_PROGRESS", nil)
-
-        # Build dagger command with options
-        cmd_parts = ["dagger"]
-        cmd_parts += ["-q"] * quiet if quiet&.positive?
-        cmd_parts += ["--silent"] if silent
-        cmd_parts += ["--progress", progress] if progress
-        cmd_parts += ["run", ruby_cmd]
-        cmd = cmd_parts.join(" ")
-
-        # Execute the command
-        exec(cmd)
+    def connection(config = nil, &)
+      return connection_in_current_session(config, &) if dagger_session?
+
+      exec(*dagger_run_command(config))
+    end
+
+    private
+
+    def dagger_session?
+      ENV.fetch("DAGGER_SESSION_PORT", nil) && ENV.fetch("DAGGER_SESSION_TOKEN", nil)
+    end
+
+    def connection_in_current_session(config)
+      client = Client.new(config: config)
+      return client unless block_given?
+
+      begin
+        yield client
+      ensure
+        client.close
       end
     end
+
+    def dagger_run_command(config)
+      [
+        "dagger",
+        *quiet_flags(config),
+        *silent_flag(config),
+        *progress_option(config),
+        "run",
+        "--",
+        "ruby",
+        $PROGRAM_NAME,
+        *ARGV,
+      ]
+    end
+
+    def quiet_flags(config)
+      quiet = config&.quiet || ENV["DAGGER_QUIET"]&.to_i
+      quiet&.positive? ? ["-q"] * quiet : []
+    end
+
+    def silent_flag(config)
+      config&.silent || ENV["DAGGER_SILENT"] == "true" ? ["--silent"] : []
+    end
+
+    def progress_option(config)
+      progress = config&.progress || ENV.fetch("DAGGER_PROGRESS", nil)
+      progress ? ["--progress", progress] : []
+    end
   end
 end

metadata

@@ -1,12 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: dagger_ruby
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.9.0
 platform: ruby
 authors:
-- Gaurav Tiwari
-- Claude Sonnet 4 + GPT-4
-bindir: exe
+- BoringCache
+bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
@@ -16,47 +15,46 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.1'
+        version: '0.3'
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.21'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.6'
+        version: '2.21'
 - !ruby/object:Gem::Dependency
   name: logger
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '1.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
-description: DaggerRuby provides a fluent, idiomatic Ruby interface to Dagger's container-based
-  CI/CD engine. Define build pipelines programmatically with Ruby instead of YAML.
-  Features lazy execution, caching, secrets, and service orchestration.
+        version: '1.7'
+description: DaggerRuby provides a small, chainable Ruby interface for running container
+  builds, services, caches, secrets, and filesystem operations with the Dagger engine.
 email:
-- gaurav@gauravtiwari.co.uk
+- oss@boringcache.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -64,6 +62,7 @@ files:
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
+- SECURITY.md
 - dagger_ruby.gemspec
 - lib/dagger_ruby.rb
 - lib/dagger_ruby/cache_volume.rb
@@ -86,8 +85,11 @@ licenses:
 metadata:
   allowed_push_host: https://rubygems.org
   homepage_uri: https://github.com/boringcache/dagger_ruby
-  source_code_uri: https://github.com/boringcache/dagger_ruby
+  source_code_uri: https://github.com/boringcache/dagger_ruby/tree/v0.9.0
   changelog_uri: https://github.com/boringcache/dagger_ruby/blob/main/CHANGELOG.md
+  bug_tracker_uri: https://github.com/boringcache/dagger_ruby/issues
+  documentation_uri: https://github.com/boringcache/dagger_ruby#readme
+  security_policy_uri: https://github.com/boringcache/dagger_ruby/security/policy
   rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
@@ -96,14 +98,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 4.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.7
+rubygems_version: 4.0.16
 specification_version: 4
-summary: A Ruby SDK for Dagger - build powerful CI/CD pipelines using Ruby
+summary: A Ruby client for Dagger's GraphQL API
 test_files: []