dagger_ruby 0.1.0

data/lib/dagger_ruby/container.rb

@@ -0,0 +1,392 @@
+# frozen_string_literal: true
+
+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
+
+
+    def from(address)
+      chain_operation("from", { "address" => address })
+    end
+
+    def with_directory(path, directory, opts = {})
+      args = { "path" => path, "directory" => directory.is_a?(DaggerObject) ? directory.id : directory }
+      args["exclude"] = opts[:exclude] if opts[:exclude]
+      args["include"] = opts[:include] if opts[:include]
+      args["owner"] = opts[:owner] if opts[:owner]
+      args["expand"] = opts[:expand] if opts.key?(:expand)
+
+      chain_operation("withDirectory", args)
+    end
+
+    def with_workdir(path)
+      chain_operation("withWorkdir", { "path" => path })
+    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["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]
+      if opts.key?(:experimental_privileged_nesting)
+        exec_args["experimentalPrivilegedNesting"] = opts[:experimental_privileged_nesting]
+      end
+      if opts.key?(:insecure_root_capabilities)
+        exec_args["insecureRootCapabilities"] = opts[:insecure_root_capabilities]
+      end
+      exec_args["expand"] = opts[:expand] if opts.key?(:expand)
+      exec_args["noInit"] = opts[:no_init] if opts.key?(:no_init)
+
+      chain_operation("withExec", exec_args)
+    end
+
+    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["owner"] = opts[:owner] if opts[:owner]
+      args["expand"] = opts[:expand] if opts.key?(:expand)
+
+      chain_operation("withMountedCache", args)
+    end
+
+    def with_env_variable(name, value, opts = {})
+      args = { "name" => name, "value" => value }
+      args["expand"] = opts[:expand] if opts.key?(:expand)
+
+      chain_operation("withEnvVariable", args)
+    end
+
+    def with_file(path, source, opts = {})
+      args = { "path" => path, "source" => source.is_a?(DaggerObject) ? source.id : source }
+      args["permissions"] = opts[:permissions] if opts[:permissions]
+      args["owner"] = opts[:owner] if opts[:owner]
+      args["expand"] = opts[:expand] if opts.key?(:expand)
+
+      chain_operation("withFile", args)
+    end
+
+    def with_new_file(path, contents, opts = {})
+      args = { "path" => path, "contents" => contents }
+      args["permissions"] = opts[:permissions] if opts[:permissions]
+      args["owner"] = opts[:owner] if opts[:owner]
+      args["expand"] = opts[:expand] if opts.key?(:expand)
+
+      chain_operation("withNewFile", args)
+    end
+
+    def with_secret_variable(name, secret)
+      args = { "name" => name, "secret" => secret.is_a?(DaggerObject) ? secret.id : secret }
+      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
+
+    def with_entrypoint(args, opts = {})
+      entrypoint_args = { "args" => args }
+      entrypoint_args["keepDefaultArgs"] = opts[:keep_default_args] if opts.key?(:keep_default_args)
+      chain_operation("withEntrypoint", entrypoint_args)
+    end
+
+    def with_user(name)
+      chain_operation("withUser", { "name" => name })
+    end
+
+    def with_registry_auth(address, username, secret)
+      puts "⚠️  Registry auth temporarily disabled due to GraphQL formatting issues"
+      self
+    end
+
+    def without_registry_auth(address)
+      chain_operation("withoutRegistryAuth", { "address" => address })
+    end
+
+    def with_service_binding(alias_name, service)
+      args = {
+        "alias" => alias_name,
+        "service" => service.is_a?(DaggerObject) ? service.id : service
+      }
+      chain_operation("withServiceBinding", args)
+    end
+
+    def as_service(opts = {})
+      args = {}
+      args["args"] = opts[:args] if opts[:args]
+      args["useEntrypoint"] = opts[:use_entrypoint] if opts.key?(:use_entrypoint)
+      args["experimentalPrivilegedNesting"] = opts[:experimental_privileged_nesting] if opts.key?(:experimental_privileged_nesting)
+      args["insecureRootCapabilities"] = opts[:insecure_root_capabilities] if opts.key?(:insecure_root_capabilities)
+      args["expand"] = opts[:expand] if opts.key?(:expand)
+      args["noInit"] = opts[:no_init] if opts.key?(:no_init)
+
+      require_relative "service" unless defined?(Service)
+      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]
+
+      chain_operation("import", args)
+    end
+
+    def terminal(opts = {})
+      args = {}
+      args["cmd"] = opts[:cmd] if opts[:cmd]
+      args["experimentalPrivilegedNesting"] = opts[:experimental_privileged_nesting] if opts.key?(:experimental_privileged_nesting)
+      args["insecureRootCapabilities"] = opts[:insecure_root_capabilities] if opts.key?(:insecure_root_capabilities)
+
+      if args.empty?
+        chain_operation("terminal")
+      else
+        chain_operation("terminal", args)
+      end
+    end
+
+    def with_exposed_port(port, opts = {})
+      args = { "port" => port }
+      args["protocol"] = opts[:protocol] if opts[:protocol]
+      args["description"] = opts[:description] if opts[:description]
+      if opts.key?(:experimental_skip_healthcheck)
+        args["experimentalSkipHealthcheck"] = opts[:experimental_skip_healthcheck]
+      end
+
+      chain_operation("withExposedPort", args)
+    end
+
+    def with_label(name, value)
+      args = { "name" => name, "value" => value }
+      chain_operation("withLabel", args)
+    end
+
+    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["expand"] = opts[:expand] if opts.key?(:expand)
+
+      chain_operation("withMountedDirectory", args)
+    end
+
+    def with_mounted_file(path, source, opts = {})
+      args = { "path" => path, "source" => source.is_a?(DaggerObject) ? source.id : source }
+      args["owner"] = opts[:owner] if opts[:owner]
+      args["expand"] = opts[:expand] if opts.key?(:expand)
+
+      chain_operation("withMountedFile", args)
+    end
+
+    def with_mounted_secret(path, source, opts = {})
+      args = { "path" => path, "source" => source.is_a?(DaggerObject) ? source.id : source }
+      args["owner"] = opts[:owner] if opts[:owner]
+      args["mode"] = opts[:mode] if opts[:mode]
+      args["expand"] = opts[:expand] if opts.key?(:expand)
+
+      chain_operation("withMountedSecret", args)
+    end
+
+    def without_directory(path)
+      chain_operation("withoutDirectory", { "path" => path })
+    end
+
+    def without_file(path)
+      chain_operation("withoutFile", { "path" => path })
+    end
+
+    def without_env_variable(name)
+      chain_operation("withoutEnvVariable", { "name" => name })
+    end
+
+    def without_exposed_port(port, opts = {})
+      args = { "port" => port }
+      args["protocol"] = opts[:protocol] if opts[:protocol]
+
+      chain_operation("withoutExposedPort", args)
+    end
+
+
+    def directory(path, opts = {})
+      args = { "path" => path }
+      args["expand"] = opts[:expand] if opts.key?(:expand)
+      get_object("directory", Directory, args)
+    end
+
+    def file(path, opts = {})
+      args = { "path" => path }
+      args["expand"] = opts[:expand] if opts.key?(:expand)
+      get_object("file", File, args)
+    end
+
+
+    def stdout
+      get_scalar("stdout")
+    end
+
+    def stderr
+      get_scalar("stderr")
+    end
+
+    def exit_code
+      get_scalar("exitCode")
+    end
+
+    def workdir
+      get_scalar("workdir")
+    end
+
+    def user
+      get_scalar("user")
+    end
+
+    def entrypoint
+      get_scalar("entrypoint")
+    end
+
+    def env_variables
+      get_scalar("envVariables")
+    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")
+    end
+
+    def labels
+      get_scalar("labels")
+    end
+
+    def label(name)
+      query = @query_builder.build_query_with_selection("label(name: \"#{name}\")")
+      result = @client.execute(query)
+      extract_value_from_result(result, "label")
+    end
+
+    def mounts
+      get_scalar("mounts")
+    end
+
+    def exposed_ports
+      get_scalar("exposedPorts")
+    end
+
+    def platform
+      get_scalar("platform")
+    end
+
+    def image_ref
+      get_scalar("imageRef")
+    end
+
+    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["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")
+    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")
+    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")
+    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]
+
+      query = @query_builder.build_query_with_selection("asTarball(#{format_arguments(args)})")
+      result = @client.execute(query)
+      extract_value_from_result(result, "asTarball")
+    end
+
+    def sync
+      get_scalar("id")  # Force execution by getting 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/dagger_object.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require_relative "query_builder"
+
+module DaggerRuby
+  class DaggerObject
+    attr_reader :query_builder, :client
+
+    def initialize(query_builder = nil, client = nil)
+      @query_builder = query_builder || QueryBuilder.new(self.class.root_field_name)
+      @client = client
+    end
+
+    def chain_operation(field, args = {})
+      new_query = @query_builder.chain_operation(field, args)
+      self.class.new(new_query, @client)
+    end
+
+    def id
+      @id ||= get_scalar("id")
+    end
+
+    protected
+
+    def get_scalar(field)
+      query = @query_builder.build_query_with_selection(field)
+      result = @client.execute_query(query)
+      extract_value_from_result(result, field)
+    end
+
+    def extract_value_from_result(result, field)
+      return nil if result.nil?
+
+      if @query_builder.root_field
+        current = result[@query_builder.root_field]
+        return nil if current.nil?
+      else
+        current = result
+      end
+
+      @query_builder.operation_chain.each do |op|
+        current = current[op[:field]]
+        return nil if current.nil?
+      end
+
+      current[field]
+    end
+
+    def get_object(field, klass, args = {})
+      new_query = @query_builder.chain_operation(field, args)
+      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") if array_field
+
+      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) || []
+    end
+
+    class << self
+      def from_id(id, client)
+        query = QueryBuilder.new(root_field_name)
+        query.load_from_id(id)
+        new(query, client)
+      end
+
+      def root_field_name
+        name.split("::").last.downcase
+      end
+    end
+  end
+end

data/lib/dagger_ruby/directory.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+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
+
+    def with_file(path, source, opts = {})
+      args = { "path" => path, "source" => source.is_a?(DaggerObject) ? source.id : source }
+      args["permissions"] = opts[:permissions] if opts[:permissions]
+
+      chain_operation("withFile", args)
+    end
+
+    def with_new_file(path, contents, opts = {})
+      args = { "path" => path, "contents" => contents }
+      args["permissions"] = opts[:permissions] if opts[:permissions]
+
+      chain_operation("withNewFile", args)
+    end
+
+    def with_directory(path, directory, opts = {})
+      args = { "path" => path, "directory" => directory.is_a?(DaggerObject) ? directory.id : directory }
+      args["exclude"] = opts[:exclude] if opts[:exclude]
+      args["include"] = opts[:include] if opts[:include]
+
+      chain_operation("withDirectory", args)
+    end
+
+    def with_new_directory(path, opts = {})
+      args = { "path" => path }
+      args["permissions"] = opts[:permissions] if opts[:permissions]
+
+      chain_operation("withNewDirectory", args)
+    end
+
+    def without_file(path)
+      chain_operation("withoutFile", { "path" => path })
+    end
+
+    def without_directory(path)
+      chain_operation("withoutDirectory", { "path" => path })
+    end
+
+    def diff(other)
+      chain_operation("diff", { "other" => other.is_a?(DaggerObject) ? other.id : other })
+    end
+
+    def sync
+      get_scalar("id")
+      self
+    end
+
+    def file(path)
+      get_object("file", File, { "path" => path })
+    end
+
+    def directory(path)
+      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")
+    end
+
+    def entries(path = ".")
+      query = @query_builder.build_query_with_selection("entries(path: \"#{path}\")")
+      result = @client.execute(query)
+      extract_value_from_result(result, "entries")
+    end
+
+    def glob(pattern)
+      query = @query_builder.build_query_with_selection("glob(pattern: \"#{pattern}\")")
+      result = @client.execute(query)
+      extract_value_from_result(result, "glob")
+    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["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)
+
+      require_relative "container" unless defined?(Container)
+      get_object("dockerBuild", Container, args)
+    end
+
+    def terminal(opts = {})
+      args = {}
+      args["container"] = opts[:container].is_a?(DaggerObject) ? opts[:container].id : opts[:container] if opts[:container]
+      args["cmd"] = opts[:cmd] if opts[:cmd]
+      args["experimentalPrivilegedNesting"] = opts[:experimental_privileged_nesting] if opts.key?(:experimental_privileged_nesting)
+      args["insecureRootCapabilities"] = opts[:insecure_root_capabilities] if opts.key?(:insecure_root_capabilities)
+
+      if args.empty?
+        chain_operation("terminal")
+      else
+        chain_operation("terminal", args)
+      end
+    end
+
+    def self.load_from_host(path, opts = {}, client)
+      args = { "path" => path }
+      args["exclude"] = opts[:exclude] if opts[:exclude]
+      args["include"] = opts[:include] if opts[:include]
+
+      host_query = QueryBuilder.new("host")
+      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

data/lib/dagger_ruby/errors.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module DaggerRuby
+  class DaggerError < StandardError; end
+  class GraphQLError < DaggerError; end
+  class HTTPError < DaggerError; end
+  class InvalidQueryError < DaggerError; end
+  class ConnectionError < DaggerError; end
+end