dagger_ruby 0.6.0 → 0.9.0

data/dagger_ruby.gemspec

@@ -5,24 +5,25 @@ require_relative "lib/dagger_ruby/version"
 Gem::Specification.new do |spec|
   spec.name = "dagger_ruby"
   spec.version = DaggerRuby::VERSION
-  spec.authors = ["Gaurav Tiwari", "Claude Sonnet 4 + GPT-4"]
-  spec.email = ["gaurav@gauravtiwari.co.uk"]
-
-  spec.summary = "A Ruby SDK for Dagger - build powerful CI/CD pipelines using Ruby"
-  # rubocop:disable Layout/LineLength
-  spec.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."
-  # rubocop:enable Layout/LineLength
+  spec.authors = ["BoringCache"]
+  spec.email = ["oss@boringcache.com"]
+
+  spec.summary = "A Ruby client for Dagger's GraphQL API"
+  spec.description = "DaggerRuby provides a small, chainable Ruby interface for running container builds, " \
+                     "services, caches, secrets, and filesystem operations with the Dagger engine."
   spec.homepage = "https://github.com/boringcache/dagger_ruby"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.1.0"
+  spec.required_ruby_version = ">= 4.0.0"
 
   spec.metadata["allowed_push_host"] = "https://rubygems.org"
 
   spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/boringcache/dagger_ruby"
-  spec.metadata["changelog_uri"] = "https://github.com/boringcache/dagger_ruby/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"] = "#{spec.homepage}/tree/v#{spec.version}"
+  spec.metadata["changelog_uri"] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+  spec.metadata["documentation_uri"] = "#{spec.homepage}#readme"
+  spec.metadata["security_policy_uri"] = "#{spec.homepage}/security/policy"
+  spec.metadata["rubygems_mfa_required"] = "true"
 
   # Specify which files should be added to the gem when it is released.
   spec.files = Dir.glob(%w[
@@ -31,18 +32,14 @@ Gem::Specification.new do |spec|
                           LICENSE*
                           CHANGELOG*
                           README*
-                          .yardopts
+                          SECURITY*
                         ]).reject { |f| File.directory?(f) }
 
-  spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Core dependencies - using only Ruby stdlib
-  spec.add_dependency "base64", "~> 0.1"
-  spec.add_dependency "json", "~> 2.6"
-  spec.add_dependency "logger", "~> 1.4"
+  spec.add_dependency "base64", "~> 0.3"
+  spec.add_dependency "json", "~> 2.21"
+  spec.add_dependency "logger", "~> 1.7"
 
   # Development dependencies are managed in Gemfile
-  spec.metadata["rubygems_mfa_required"] = "true"
 end

data/lib/dagger_ruby/cache_volume.rb

@@ -4,20 +4,10 @@ require_relative "dagger_object"
 
 module DaggerRuby
   class CacheVolume < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("cacheVolume")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "cacheVolume"
     end
 
-    def key
-      get_scalar("key")
-    end
-
     def sync
       get_scalar("id") # Force execution by getting ID
       self

data/lib/dagger_ruby/client.rb

@@ -61,17 +61,24 @@ module DaggerRuby
       Directory.new(QueryBuilder.new("directory"), self)
     end
 
-    def file
-      File.new(QueryBuilder.new("file"), self)
+    def file(name, contents, permissions: nil)
+      args = { "name" => name, "contents" => contents }
+      args["permissions"] = permissions if permissions
+      File.new(QueryBuilder.new.chain_operation("file", args), self)
     end
 
-    def secret
-      Secret.new(QueryBuilder.new("secret"), self)
+    def secret(uri, cache_key: nil)
+      args = { "uri" => uri }
+      args["cacheKey"] = cache_key if cache_key
+      Secret.new(QueryBuilder.new.chain_operation("secret", args), self)
     end
 
-    def cache_volume(name)
-      query = QueryBuilder.new
-      query = query.chain_operation("cacheVolume", { "key" => name })
+    def cache_volume(name, opts = {})
+      args = { "key" => name }
+      args["source"] = graphql_id(opts[:source]) if opts[:source]
+      args["sharing"] = QueryBuilder.enum_value(opts[:sharing]) if opts[:sharing]
+      args["owner"] = opts[:owner] if opts[:owner]
+      query = QueryBuilder.new.chain_operation("cacheVolume", args)
       CacheVolume.new(query, self)
     end
 
@@ -81,21 +88,12 @@ module DaggerRuby
 
     def git(url, opts = {})
       args = { "url" => url }
-      args["keepGitDir"] = opts[:keep_git_dir] if opts.key?(:keep_git_dir)
       args["sshKnownHosts"] = opts[:ssh_known_hosts] if opts[:ssh_known_hosts]
-      if opts[:ssh_auth_socket]
-        args["sshAuthSocket"] =
-          opts[:ssh_auth_socket].is_a?(DaggerObject) ? opts[:ssh_auth_socket].id : opts[:ssh_auth_socket]
-      end
+      args["sshAuthSocket"] = graphql_id(opts[:ssh_auth_socket]) if opts[:ssh_auth_socket]
       args["httpAuthUsername"] = opts[:http_auth_username] if opts[:http_auth_username]
-      if opts[:http_auth_token]
-        args["httpAuthToken"] =
-          opts[:http_auth_token].is_a?(DaggerObject) ? opts[:http_auth_token].id : opts[:http_auth_token]
-      end
-      if opts[:http_auth_header]
-        args["httpAuthHeader"] =
-          opts[:http_auth_header].is_a?(DaggerObject) ? opts[:http_auth_header].id : opts[:http_auth_header]
-      end
+      args["httpAuthToken"] = graphql_id(opts[:http_auth_token]) if opts[:http_auth_token]
+      args["httpAuthHeader"] = graphql_id(opts[:http_auth_header]) if opts[:http_auth_header]
+      args["experimentalServiceHost"] = graphql_id(opts[:service_host]) if opts[:service_host]
 
       query = QueryBuilder.new
       query = query.chain_operation("git", args)
@@ -106,10 +104,9 @@ module DaggerRuby
       args = { "url" => url }
       args["name"] = opts[:name] if opts[:name]
       args["permissions"] = opts[:permissions] if opts[:permissions]
-      if opts[:auth_header]
-        args["authHeader"] =
-          opts[:auth_header].is_a?(DaggerObject) ? opts[:auth_header].id : opts[:auth_header]
-      end
+      args["checksum"] = opts[:checksum] if opts[:checksum]
+      args["authHeader"] = graphql_id(opts[:auth_header]) if opts[:auth_header]
+      args["experimentalServiceHost"] = graphql_id(opts[:service_host]) if opts[:service_host]
 
       query = QueryBuilder.new
       query = query.chain_operation("http", args)
@@ -143,6 +140,10 @@ module DaggerRuby
 
     private
 
+    def graphql_id(value)
+      value.is_a?(DaggerObject) ? value.id : value
+    end
+
     def handle_response(response)
       case response.code.to_i
       when 200

data/lib/dagger_ruby/config.rb

@@ -4,13 +4,13 @@ module DaggerRuby
   class Config
     attr_reader :log_output, :workdir, :timeout, :quiet, :silent, :progress
 
-    def initialize(log_output: nil, workdir: nil, timeout: nil, quiet: nil, silent: nil, progress: nil)
-      @log_output = log_output
-      @workdir = workdir
-      @timeout = timeout || 600
-      @quiet = quiet || ENV["DAGGER_QUIET"]&.to_i
-      @silent = silent || ENV["DAGGER_SILENT"] == "true"
-      @progress = progress || ENV.fetch("DAGGER_PROGRESS", nil)
+    def initialize(options = {})
+      @log_output = options[:log_output]
+      @workdir = options[:workdir]
+      @timeout = options[:timeout] || 600
+      @quiet = options[:quiet] || ENV["DAGGER_QUIET"]&.to_i
+      @silent = options[:silent] || ENV["DAGGER_SILENT"] == "true"
+      @progress = options[:progress] || ENV.fetch("DAGGER_PROGRESS", nil)
     end
   end
 end

data/lib/dagger_ruby/container.rb

@@ -4,12 +4,6 @@ require_relative "dagger_object"
 
 module DaggerRuby
   class Container < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("container")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "container"
     end
@@ -19,26 +13,31 @@ module DaggerRuby
     end
 
     def with_directory(path, directory, opts = {})
-      args = { "path" => path, "directory" => directory.is_a?(DaggerObject) ? directory.id : directory }
+      args = { "path" => path, "source" => directory.is_a?(DaggerObject) ? directory.id : directory }
       args["exclude"] = opts[:exclude] if opts[:exclude]
       args["include"] = opts[:include] if opts[:include]
+      args["gitignore"] = opts[:gitignore] if opts[:gitignore]
       args["owner"] = opts[:owner] if opts[:owner]
       args["expand"] = opts[:expand] if opts.key?(:expand)
+      args["permissions"] = opts[:permissions] if opts[:permissions]
 
       chain_operation("withDirectory", args)
     end
 
-    def with_workdir(path)
-      chain_operation("withWorkdir", { "path" => path })
+    def with_workdir(path, expand: nil)
+      args = { "path" => path }
+      args["expand"] = expand unless expand.nil?
+      chain_operation("withWorkdir", args)
     end
 
     def with_exec(args, opts = {})
       exec_args = { "args" => args }
       exec_args["useEntrypoint"] = opts[:use_entrypoint] if opts.key?(:use_entrypoint)
       exec_args["stdin"] = opts[:stdin] if opts[:stdin]
+      exec_args["redirectStdin"] = opts[:redirect_stdin] if opts[:redirect_stdin]
       exec_args["redirectStdout"] = opts[:redirect_stdout] if opts[:redirect_stdout]
       exec_args["redirectStderr"] = opts[:redirect_stderr] if opts[:redirect_stderr]
-      exec_args["expect"] = opts[:expect] if opts[:expect]
+      exec_args["expect"] = QueryBuilder.enum_value(opts[:expect]) if opts[:expect]
       if opts.key?(:experimental_privileged_nesting)
         exec_args["experimentalPrivilegedNesting"] = opts[:experimental_privileged_nesting]
       end
@@ -54,7 +53,7 @@ module DaggerRuby
     def with_mounted_cache(path, cache, opts = {})
       args = { "path" => path, "cache" => cache.is_a?(DaggerObject) ? cache.id : cache }
       args["source"] = opts[:source] if opts[:source]
-      args["sharing"] = opts[:sharing] if opts[:sharing]
+      args["sharing"] = QueryBuilder.enum_value(opts[:sharing]) if opts[:sharing]
       args["owner"] = opts[:owner] if opts[:owner]
       args["expand"] = opts[:expand] if opts.key?(:expand)
 
@@ -91,10 +90,7 @@ module DaggerRuby
       chain_operation("withSecretVariable", args)
     end
 
-    def with_secret_env(name, secret)
-      args = { "name" => name, "secret" => secret.is_a?(DaggerObject) ? secret.id : secret }
-      chain_operation("withSecretEnv", args)
-    end
+    alias with_secret_env with_secret_variable
 
     def with_entrypoint(args, opts = {})
       entrypoint_args = { "args" => args }
@@ -106,9 +102,13 @@ module DaggerRuby
       chain_operation("withUser", { "name" => name })
     end
 
-    def with_registry_auth(_address, _username, _secret)
-      puts "⚠️  Registry auth temporarily disabled due to GraphQL formatting issues"
-      self
+    def with_registry_auth(address, username, secret)
+      args = {
+        "address" => address,
+        "username" => username,
+        "secret" => secret.is_a?(DaggerObject) ? secret.id : secret,
+      }
+      chain_operation("withRegistryAuth", args)
     end
 
     def without_registry_auth(address)
@@ -139,21 +139,6 @@ module DaggerRuby
       get_object("asService", Service, args)
     end
 
-    def build(context, opts = {})
-      args = { "context" => context.is_a?(DaggerObject) ? context.id : context }
-      args["dockerfile"] = opts[:dockerfile] if opts[:dockerfile]
-      args["target"] = opts[:target] if opts[:target]
-      args["buildArgs"] = opts[:build_args] if opts[:build_args]
-
-      if opts[:secrets]
-        raise NotImplementedError, "Build secrets are not yet supported. Use with_mounted_secret instead."
-      end
-
-      args["noInit"] = opts[:no_init] if opts.key?(:no_init)
-
-      chain_operation("build", args)
-    end
-
     def import(source, opts = {})
       args = { "source" => source.is_a?(DaggerObject) ? source.id : source }
       args["tag"] = opts[:tag] if opts[:tag]
@@ -179,7 +164,7 @@ module DaggerRuby
 
     def with_exposed_port(port, opts = {})
       args = { "port" => port }
-      args["protocol"] = opts[:protocol] if opts[:protocol]
+      args["protocol"] = QueryBuilder.enum_value(opts[:protocol]) if opts[:protocol]
       args["description"] = opts[:description] if opts[:description]
       if opts.key?(:experimental_skip_healthcheck)
         args["experimentalSkipHealthcheck"] = opts[:experimental_skip_healthcheck]
@@ -196,6 +181,7 @@ module DaggerRuby
     def with_mounted_directory(path, source, opts = {})
       args = { "path" => path, "source" => source.is_a?(DaggerObject) ? source.id : source }
       args["owner"] = opts[:owner] if opts[:owner]
+      args["readOnly"] = opts[:read_only] if opts.key?(:read_only)
       args["expand"] = opts[:expand] if opts.key?(:expand)
 
       chain_operation("withMountedDirectory", args)
@@ -232,7 +218,7 @@ module DaggerRuby
 
     def without_exposed_port(port, opts = {})
       args = { "port" => port }
-      args["protocol"] = opts[:protocol] if opts[:protocol]
+      args["protocol"] = QueryBuilder.enum_value(opts[:protocol]) if opts[:protocol]
 
       chain_operation("withoutExposedPort", args)
     end
@@ -274,23 +260,19 @@ module DaggerRuby
     end
 
     def env_variables
-      get_scalar("envVariables")
+      get_selection("envVariables", "name value")
     end
 
     def env_variable(name)
-      query = @query_builder.build_query_with_selection("envVariable(name: \"#{name}\")")
-      result = @client.execute(query)
-      extract_value_from_result(result, "envVariable")
+      get_scalar("envVariable", { "name" => name })
     end
 
     def labels
-      get_scalar("labels")
+      get_selection("labels", "name value")
     end
 
     def label(name)
-      query = @query_builder.build_query_with_selection("label(name: \"#{name}\")")
-      result = @client.execute(query)
-      extract_value_from_result(result, "label")
+      get_scalar("label", { "name" => name })
     end
 
     def mounts
@@ -298,7 +280,7 @@ module DaggerRuby
     end
 
     def exposed_ports
-      get_scalar("exposedPorts")
+      get_selection("exposedPorts", "port protocol description experimentalSkipHealthcheck")
     end
 
     def platform
@@ -311,48 +293,41 @@ module DaggerRuby
 
     def export(path, opts = {})
       args = { "path" => path }
-      args["platformVariants"] = opts[:platform_variants] if opts[:platform_variants]
-      args["forcedCompression"] = opts[:forced_compression] if opts[:forced_compression]
-      args["mediaTypes"] = opts[:media_types] if opts[:media_types]
+      args["platformVariants"] = graphql_ids(opts[:platform_variants]) if opts[:platform_variants]
+      args["forcedCompression"] = QueryBuilder.enum_value(opts[:forced_compression]) if opts[:forced_compression]
+      args["mediaTypes"] = QueryBuilder.enum_value(opts[:media_types]) if opts[:media_types]
       args["expand"] = opts[:expand] if opts.key?(:expand)
 
-      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 export_to_file(path, opts = {})
-      args = { "path" => path }
-      args["platformVariants"] = opts[:platform_variants] if opts[:platform_variants]
-      args["forcedCompression"] = opts[:forced_compression] if opts[:forced_compression]
-      args["mediaTypes"] = opts[:media_types] if opts[:media_types]
-      args["expand"] = opts[:expand] if opts.key?(:expand)
-
-      query = @query_builder.build_query_with_selection("exportToFile(#{format_arguments(args)})")
-      result = @client.execute(query)
-      extract_value_from_result(result, "exportToFile")
+      export(path, opts)
     end
 
     def publish(address, opts = {})
       args = { "address" => address }
-      args["platformVariants"] = opts[:platform_variants] if opts[:platform_variants]
-      args["forcedCompression"] = opts[:forced_compression] if opts[:forced_compression]
-      args["mediaTypes"] = opts[:media_types] if opts[:media_types]
-
-      query = @query_builder.build_query_with_selection("publish(#{format_arguments(args)})")
-      result = @client.execute(query)
-      extract_value_from_result(result, "publish")
+      args["platformVariants"] = graphql_ids(opts[:platform_variants]) if opts[:platform_variants]
+      args["forcedCompression"] = QueryBuilder.enum_value(opts[:forced_compression]) if opts[:forced_compression]
+      args["mediaTypes"] = QueryBuilder.enum_value(opts[:media_types]) if opts[:media_types]
+
+      if opts[:registry_service]
+        args["registryService"] = if opts[:registry_service].is_a?(DaggerObject)
+                                    opts[:registry_service].id
+                                  else
+                                    opts[:registry_service]
+                                  end
+      end
+      get_scalar("publish", args)
     end
 
     def as_tarball(opts = {})
       args = {}
-      args["platformVariants"] = opts[:platform_variants] if opts[:platform_variants]
-      args["forcedCompression"] = opts[:forced_compression] if opts[:forced_compression]
-      args["mediaTypes"] = opts[:media_types] if opts[:media_types]
+      args["platformVariants"] = graphql_ids(opts[:platform_variants]) if opts[:platform_variants]
+      args["forcedCompression"] = QueryBuilder.enum_value(opts[:forced_compression]) if opts[:forced_compression]
+      args["mediaTypes"] = QueryBuilder.enum_value(opts[:media_types]) if opts[:media_types]
 
-      query = @query_builder.build_query_with_selection("asTarball(#{format_arguments(args)})")
-      result = @client.execute(query)
-      extract_value_from_result(result, "asTarball")
+      get_object("asTarball", File, args)
     end
 
     def sync
@@ -362,32 +337,8 @@ 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}\""
-      end
+    def graphql_ids(values)
+      values.map { |value| value.is_a?(DaggerObject) ? value.id : value }
     end
   end
 end

data/lib/dagger_ruby/dagger_object.rb

@@ -23,8 +23,15 @@ module DaggerRuby
 
     protected
 
-    def get_scalar(field)
-      query = @query_builder.build_query_with_selection(field)
+    def get_scalar(field, args = {})
+      query = @query_builder.build_query_with_selection(field, args)
+      result = @client.execute_query(query)
+      extract_value_from_result(result, field)
+    end
+
+    def get_selection(field, selection, args = {})
+      selected_field = "#{QueryBuilder.new.field_selection(field, args)} { #{selection} }"
+      query = @query_builder.build_query_with_selection(selected_field)
       result = @client.execute_query(query)
       extract_value_from_result(result, field)
     end
@@ -52,42 +59,25 @@ module DaggerRuby
       klass.new(new_query, @client)
     end
 
-    def get_object_array(field, klass, _args = {})
-      query = @query_builder.build_query_with_selection(field)
-
-      array_field = query.selections.find { |s| s.field == field }
-      array_field&.select("id")
-
-      result = @client.execute(query)
-      ids = extract_array_from_result(result, field)
-
-      ids.map { |id_data| klass.from_id(id_data["id"], @client) }
-    end
-
-    private
-
-    def extract_array_from_result(result, field)
-      current = result["data"]
-
-      if @query_builder.root_field
-        current = current[@query_builder.root_field]
-        @query_builder.operation_chain.each do |operation|
-          current = current[operation[:field]] if current
-        end
-      end
-      current&.[](field) || []
+    def get_object_array(field, klass, args = {})
+      get_selection(field, "id", args).to_a.map { |data| klass.from_id(data.fetch("id"), @client) }
     end
 
     class << self
       def from_id(id, client)
-        query = QueryBuilder.new(root_field_name)
-        query.load_from_id(id)
+        query = QueryBuilder.new.chain_operation("load#{graphql_type_name}FromID", { "id" => id })
         new(query, client)
       end
 
       def root_field_name
         name.split("::").last.downcase
       end
+
+      private
+
+      def graphql_type_name
+        name.split("::").last
+      end
     end
   end
 end

data/lib/dagger_ruby/directory.rb

@@ -4,12 +4,6 @@ require_relative "dagger_object"
 
 module DaggerRuby
   class Directory < DaggerObject
-    def self.from_id(id, client)
-      query = QueryBuilder.new("directory")
-      query.load_from_id(id)
-      new(query, client)
-    end
-
     def self.root_field_name
       "directory"
     end
@@ -29,9 +23,12 @@ module DaggerRuby
     end
 
     def with_directory(path, directory, opts = {})
-      args = { "path" => path, "directory" => directory.is_a?(DaggerObject) ? directory.id : directory }
+      args = { "path" => path, "source" => directory.is_a?(DaggerObject) ? directory.id : directory }
       args["exclude"] = opts[:exclude] if opts[:exclude]
       args["include"] = opts[:include] if opts[:include]
+      args["gitignore"] = opts[:gitignore] if opts[:gitignore]
+      args["owner"] = opts[:owner] if opts[:owner]
+      args["permissions"] = opts[:permissions] if opts[:permissions]
 
       chain_operation("withDirectory", args)
     end
@@ -55,6 +52,14 @@ module DaggerRuby
       chain_operation("diff", { "other" => other.is_a?(DaggerObject) ? other.id : other })
     end
 
+    def filter(opts = {})
+      args = {}
+      args["exclude"] = opts[:exclude] if opts[:exclude]
+      args["include"] = opts[:include] if opts[:include]
+      args["gitignore"] = opts[:gitignore] if opts[:gitignore]
+      chain_operation("filter", args)
+    end
+
     def sync
       get_scalar("id")
       self
@@ -68,42 +73,30 @@ module DaggerRuby
       get_object("directory", Directory, { "path" => path })
     end
 
-    def as_tarball(opts = {})
-      args = {}
-      args["forcedCompression"] = opts[:forced_compression] if opts[:forced_compression]
-
-      get_object("asTarball", File, 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")
+      args["wipe"] = opts[:wipe] if opts.key?(:wipe)
+      get_scalar("export", args)
     end
 
     def entries(path = ".")
-      query = @query_builder.build_query_with_selection("entries(path: \"#{path}\")")
-      result = @client.execute(query)
-      extract_value_from_result(result, "entries")
+      get_scalar("entries", { "path" => path })
     end
 
     def glob(pattern)
-      query = @query_builder.build_query_with_selection("glob(pattern: \"#{pattern}\")")
-      result = @client.execute(query)
-      extract_value_from_result(result, "glob")
+      get_scalar("glob", { "pattern" => pattern })
     end
 
     def docker_build(opts = {})
-      args = {}
-      args["dockerfile"] = opts[:dockerfile] if opts[:dockerfile]
-      args["platform"] = opts[:platform] if opts[:platform]
-      args["buildArgs"] = opts[:build_args] if opts[:build_args]
-      args["target"] = opts[:target] if opts[:target]
+      args = {
+        "dockerfile" => opts[:dockerfile],
+        "platform" => opts[:platform],
+        "buildArgs" => opts[:build_args],
+        "target" => opts[:target],
+      }.compact
       args["secrets"] = opts[:secrets].map { |s| s.is_a?(DaggerObject) ? s.id : s } if opts[:secrets]
       args["noInit"] = opts[:no_init] if opts.key?(:no_init)
+      args["ssh"] = opts[:ssh].is_a?(DaggerObject) ? opts[:ssh].id : opts[:ssh] if opts[:ssh]
 
       require_relative "container" unless defined?(Container)
       get_object("dockerBuild", Container, args)
@@ -129,7 +122,7 @@ module DaggerRuby
       end
     end
 
-    def self.load_from_host(path, opts = {}, client)
+    def self.load_from_host(path, client, opts = {})
       args = { "path" => path }
       args["exclude"] = opts[:exclude] if opts[:exclude]
       args["include"] = opts[:include] if opts[:include]
@@ -138,35 +131,5 @@ module DaggerRuby
       host_dir_query = host_query.chain_operation("directory", args)
       Directory.new(host_dir_query, client)
     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