dagger_ruby 0.1.0

data/lib/dagger_ruby/file.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+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
+
+    def with_name(name)
+      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")
+    end
+
+    def size
+      get_scalar("size")
+    end
+
+    def name
+      get_scalar("name")
+    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 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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+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
+
+    def branch(name)
+      get_object("branch", GitRef, { "name" => name })
+    end
+
+    def tag(name)
+      get_object("tag", GitRef, { "name" => name })
+    end
+
+    def commit(id)
+      get_object("commit", GitRef, { "id" => id })
+    end
+
+    def head
+      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 })
+    end
+
+    def with_auth_header(header)
+      chain_operation("withAuthHeader", { "header" => header.is_a?(DaggerObject) ? header.id : header })
+    end
+
+    def sync
+      get_scalar("id")
+      self
+    end
+  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
+
+    def commit
+      get_scalar("commit")
+    end
+
+    def ref
+      get_scalar("ref")
+    end
+
+    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)
+    end
+
+    def sync
+      get_scalar("id")
+      self
+    end
+  end
+end

data/lib/dagger_ruby/host.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+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
+
+    def directory(path, opts = {})
+      args = { "path" => path }
+      args["exclude"] = opts[:exclude] if opts[:exclude]
+      args["include"] = opts[:include] if opts[:include]
+
+      get_object("directory", Directory, args)
+    end
+
+    def file(path)
+      get_object("file", File, { "path" => path })
+    end
+
+    def unix_socket(path)
+      get_object("unixSocket", Socket, { "path" => path })
+    end
+
+    def workdir
+      get_scalar("workdir")
+    end
+
+    def sync
+      get_scalar("id")
+      self
+    end
+  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
+
+    def sync
+      get_scalar("id")
+      self
+    end
+  end
+end

data/lib/dagger_ruby/query_builder.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "errors"
+require "json"
+
+module DaggerRuby
+  class QueryBuilder
+    attr_reader :root_field, :operation_chain, :variables
+
+    def initialize(root_field = nil)
+      @root_field = root_field
+      @operation_chain = []
+      @variables = {}
+    end
+
+    def chain_operation(field, args = {})
+      new_query = QueryBuilder.new(@root_field)
+      new_query.instance_variable_set(:@operation_chain, @operation_chain + [ { field: field, args: args } ])
+      new_query.instance_variable_set(:@variables, @variables.dup)
+      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)
+      new_query.instance_variable_set(:@variables, @variables.merge(name => type))
+      new_query
+    end
+
+    def build_query_with_selection(field)
+      query_parts = []
+
+      if @variables.any?
+        vars = @variables.map { |name, type| "$#{name}: #{type}" }.join(", ")
+        query_parts << "query(#{vars})"
+      else
+        query_parts << "query"
+      end
+
+      if @root_field
+        if @operation_chain.empty?
+          query_parts << "{ #{@root_field} { #{field} } }"
+        else
+          operations_str = build_operations_chain_with_selection(field)
+          query_parts << "{ #{@root_field} { #{operations_str} } }"
+        end
+      elsif @operation_chain.any?
+        operations_str = build_operations_chain_with_selection(field)
+        query_parts << "{ #{operations_str} }"
+      else
+        query_parts << "{ #{field} }"
+      end
+
+      query_parts.join(" ")
+    end
+
+    private
+
+    def build_operations_chain_with_selection(field)
+      current_op = @operation_chain.first
+      result = "#{current_op[:field]}#{format_arguments(current_op[:args])}"
+
+      if @operation_chain.length > 1
+        result << " { "
+        @operation_chain[1..-1].each do |op|
+          result << "#{op[:field]}#{format_arguments(op[:args])} { "
+        end
+        result << field
+        result << " }" * @operation_chain.length
+      else
+        result << " { #{field} }"
+      end
+
+      result
+    end
+
+    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
+        if value.start_with?("$")
+          value
+        else
+          "\"#{escape_string(value)}\""
+        end
+      when Integer, Float, TrueClass, FalseClass
+        value.to_s
+      when NilClass
+        "null"
+      when Array
+        "[#{value.map { |v| format_value(v) }.join(', ')}]"
+      when Hash
+        if value[:type] && value[:value]
+          value[:value].to_s
+        else
+          "{#{value.map { |k, v| "#{k}: #{format_value(v)}" }.join(', ')}}"
+        end
+      else
+        value.to_s
+      end
+    end
+
+    def escape_string(str)
+      str.gsub(/["\\\n\r\t]/) do |c|
+        case c
+        when '"' then '\\"'
+        when "\\" then "\\\\"
+        when "\n" then '\\n'
+        when "\r" then '\\r'
+        when "\t" then '\\t'
+        end
+      end
+    end
+  end
+end

data/lib/dagger_ruby/secret.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+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
+
+    def plaintext
+      get_scalar("plaintext")
+    end
+
+    def sync
+      get_scalar("id")
+      self
+    end
+  end
+end

data/lib/dagger_ruby/service.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+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
+
+    def endpoint(opts = {})
+      args = {}
+      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
+    end
+
+    def hostname
+      get_scalar("hostname")
+    end
+
+    def ports
+      get_scalar("ports")
+    end
+
+    def start
+      query = @query_builder.build_query_with_selection("start")
+      result = @client.execute(query)
+      extract_value_from_result(result, "start")
+    end
+
+    def stop(opts = {})
+      args = {}
+      args["kill"] = opts[:kill] if opts.key?(:kill)
+
+      if args.empty?
+        query = @query_builder.build_query_with_selection("stop")
+      else
+        query = @query_builder.build_query_with_selection("stop(#{format_arguments(args)})")
+      end
+
+      result = @client.execute(query)
+      extract_value_from_result(result, "stop")
+    end
+
+    def up(opts = {})
+      args = {}
+      args["ports"] = opts[:ports] if opts[:ports]
+      args["random"] = opts[:random] if opts.key?(:random)
+
+      if args.empty?
+        query = @query_builder.build_query_with_selection("up")
+      else
+        query = @query_builder.build_query_with_selection("up(#{format_arguments(args)})")
+      end
+
+      result = @client.execute(query)
+      extract_value_from_result(result, "up")
+    end
+
+    def with_hostname(hostname)
+      chain_operation("withHostname", { "hostname" => hostname })
+    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/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DaggerRuby
+  VERSION = "0.1.0"
+end

data/lib/dagger_ruby.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "dagger_ruby/version"
+require_relative "dagger_ruby/client"
+require_relative "dagger_ruby/config"
+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 = $0
+        args = ARGV
+
+        # Construct the command that dagger should run
+        ruby_cmd = [ "ruby", script, *args ].join(" ")
+
+        # Run dagger with our command
+        cmd = [ "dagger", "run", ruby_cmd ].join(" ")
+
+        # Execute the command
+        exec(cmd)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: dagger_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Gaurav Tiwari
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+description: A Ruby SDK for Dagger that provides a simple interface to build and deploy
+  applications
+email:
+- gaurav@gauravtiwari.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- dagger_ruby.gemspec
+- lib/dagger_ruby.rb
+- lib/dagger_ruby/cache_volume.rb
+- lib/dagger_ruby/client.rb
+- lib/dagger_ruby/config.rb
+- lib/dagger_ruby/container.rb
+- lib/dagger_ruby/dagger_object.rb
+- lib/dagger_ruby/directory.rb
+- lib/dagger_ruby/errors.rb
+- lib/dagger_ruby/file.rb
+- lib/dagger_ruby/git_repository.rb
+- lib/dagger_ruby/host.rb
+- lib/dagger_ruby/query_builder.rb
+- lib/dagger_ruby/secret.rb
+- lib/dagger_ruby/service.rb
+- lib/dagger_ruby/version.rb
+homepage: https://github.com/boring-build/dagger-ruby
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/boring-build/dagger-ruby
+  source_code_uri: https://github.com/boring-build/dagger-ruby
+  changelog_uri: https://github.com/boring-build/dagger-ruby/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: A Ruby SDK for Dagger
+test_files: []