buildonce 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 10b4f7f6a4fad6b16798b07d81b82d29734ed7815a9404d15296098b8aa00500
+  data.tar.gz: a68fb31adae628d07f8032dd04f2f29aa2bbcabdd4e20edd5fb819936540b2b7
+SHA512:
+  metadata.gz: 2a88cbca813751e8b465ab009d5467a9f3175e8216323a45cacdd643e578a6a57d6b38a2bd8f77bd24211c48522881fc0ebbb879fc3076588c46d37dfe98f3f9
+  data.tar.gz: 3119508b9426c066cf5e109433e4e79fcd9e40bb9ae20e1255f2eed83913266c89aa9899c5f5640b673aedf10952083d477949c4872ada851bb1c64790c567f5

data/README.md

@@ -0,0 +1,18 @@
+# Once Ruby SDK
+
+`buildonce` exposes Once primitives to Ruby. It loads the same
+native Once library used by the other SDKs and does not expose script
+execution.
+
+```ruby
+require "buildonce"
+
+cache = Once::Cache.new
+digest = cache.put_blob("hello")
+bytes = cache.get_blob(digest)
+
+raise unless bytes == "hello"
+```
+
+The gem looks for a bundled native library under `prebuilds/`. Set
+`ONCE_LIBRARY_PATH` to load a custom `libonce` build.

data/lib/buildonce.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "json"
+require "once/native"
+
+module Once
+  class Error < StandardError; end
+
+  ActionResult = Struct.new(:exit_code, :stdout, :stderr, :outputs, keyword_init: true) do
+    def to_h
+      {
+        exit_code: exit_code,
+        stdout: stdout,
+        stderr: stderr,
+        outputs: outputs || {},
+      }
+    end
+  end
+
+  CacheStats = Struct.new(:blob_count, :blob_bytes, :action_count, :action_bytes, keyword_init: true)
+
+  class Cache
+    def version
+      pointer = Native.once_version
+      return "" if pointer.null?
+
+      pointer.read_string
+    ensure
+      Native.once_string_free(pointer) if pointer && !pointer.null?
+    end
+
+    def digest(bytes)
+      buffer = bytes.to_s.b
+      pointer = buffer.empty? ? FFI::Pointer::NULL : FFI::MemoryPointer.from_string(buffer)
+      decode_response(Native.once_digest_bytes(pointer, buffer.bytesize))
+    end
+
+    def put_blob(bytes)
+      buffer = bytes.to_s.b
+      decode_request(:once_cache_put_blob_json, bytes: buffer.bytes)
+    end
+
+    def get_blob(digest)
+      response = decode_request(:once_cache_get_blob_json, digest: digest)
+      response.fetch("bytes").pack("C*")
+    end
+
+    def has_blob?(digest)
+      decode_request(:once_cache_has_blob_json, digest: digest)
+    end
+
+    def put_action_result(result, action_digest:)
+      decode_request(
+        :once_cache_put_action_result_json,
+        action_digest: action_digest,
+        result: normalize_action_result(result),
+      )
+    end
+
+    def get_action_result(action_digest)
+      response = decode_request(:once_cache_get_action_result_json, action_digest: action_digest)
+      response && action_result_from_native(response)
+    end
+
+    def forget_action(action_digest)
+      decode_request(:once_cache_forget_action_json, action_digest: action_digest)
+    end
+
+    def stats
+      response = decode_request(:once_cache_stats_json, {})
+      CacheStats.new(
+        blob_count: response.fetch("blob_count"),
+        blob_bytes: response.fetch("blob_bytes"),
+        action_count: response.fetch("action_count"),
+        action_bytes: response.fetch("action_bytes"),
+      )
+    end
+
+    private
+
+    def decode_request(function, request)
+      decode_response(Native.public_send(function, JSON.generate(request)))
+    end
+
+    def decode_response(pointer)
+      raise Error, "native Once function returned null" if pointer.null?
+
+      response = JSON.parse(pointer.read_string)
+      return response.fetch("value") if response.fetch("status") == "ok"
+
+      raise Error, response.fetch("message")
+    ensure
+      Native.once_string_free(pointer) if pointer && !pointer.null?
+    end
+
+    def normalize_action_result(result)
+      result = result.to_h if result.respond_to?(:to_h)
+      {
+        exit_code: result.fetch(:exit_code) { result.fetch("exit_code") },
+        stdout: result[:stdout] || result["stdout"],
+        stderr: result[:stderr] || result["stderr"],
+        outputs: result[:outputs] || result["outputs"] || {},
+      }
+    end
+
+    def action_result_from_native(result)
+      ActionResult.new(
+        exit_code: result.fetch("exit_code"),
+        stdout: result["stdout"],
+        stderr: result["stderr"],
+        outputs: result.fetch("outputs", {}),
+      )
+    end
+  end
+
+  def self.digest(bytes)
+    Cache.new.digest(bytes)
+  end
+end

data/lib/once/native.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "ffi"
+require "rbconfig"
+
+module Once
+  module Native
+    extend FFI::Library
+
+    def self.library_path
+      return ENV.fetch("ONCE_LIBRARY_PATH") if ENV["ONCE_LIBRARY_PATH"]
+
+      candidate = File.expand_path(
+        File.join("..", "..", "prebuilds", platform_key, library_name),
+        __dir__,
+      )
+      return candidate if File.file?(candidate)
+
+      raise LoadError,
+            "missing native Once library for #{platform_key}; set ONCE_LIBRARY_PATH or install a gem that includes this platform"
+    end
+
+    def self.platform_key
+      host = RbConfig::CONFIG.fetch("host_os")
+      arch = RbConfig::CONFIG.fetch("host_cpu")
+      os = case host
+           when /darwin/
+             "darwin"
+           when /mswin|mingw|cygwin/
+             "win32"
+           when /linux/
+             "linux"
+           else
+             host
+           end
+      cpu = case arch
+            when /arm64|aarch64/
+              "arm64"
+            when /x86_64|amd64/
+              "x64"
+            else
+              arch
+            end
+      "#{os}-#{cpu}"
+    end
+
+    def self.library_name
+      case platform_key
+      when /^darwin-/
+        "libonce.dylib"
+      when /^win32-/
+        "once.dll"
+      else
+        "libonce.so"
+      end
+    end
+
+    ffi_lib library_path
+
+    attach_function :once_version, [], :pointer
+    attach_function :once_string_free, [:pointer], :void
+    attach_function :once_digest_bytes, %i[pointer size_t], :pointer
+    attach_function :once_cache_put_blob_json, [:string], :pointer
+    attach_function :once_cache_get_blob_json, [:string], :pointer
+    attach_function :once_cache_has_blob_json, [:string], :pointer
+    attach_function :once_cache_put_action_result_json, [:string], :pointer
+    attach_function :once_cache_get_action_result_json, [:string], :pointer
+    attach_function :once_cache_forget_action_json, [:string], :pointer
+    attach_function :once_cache_stats_json, [:string], :pointer
+  end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: buildonce
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tuist GmbH
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+description: Embeds Once primitives in Ruby through the native Once library.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/buildonce.rb
+- lib/once/native.rb
+- prebuilds/darwin-arm64/libonce.dylib
+homepage: https://github.com/tuist/once
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/tuist/once
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Ruby SDK for Once
+test_files: []