dagger_ruby 0.7.0 → 0.10.0

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
@@ -32,6 +26,9 @@ module DaggerRuby
       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

data/lib/dagger_ruby/errors.rb

@@ -6,4 +6,5 @@ module DaggerRuby
   class HTTPError < DaggerError; end
   class InvalidQueryError < DaggerError; end
   class ConnectionError < DaggerError; end
+  class VersionMismatchError < ConnectionError; end
 end

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.7.0"
+  VERSION = "0.10.0"
+  DAGGER_VERSION = "0.21.8"
 end