hn_api_ruby 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7f1bbfe1d9c841e0bd586243032197e48878db8495d76ed5f58fe6e18abdd857
+  data.tar.gz: 9ccc4522030f04cbfc517ae6ba54dd7c486686926f997e4019fac7d43b7fff4d
+SHA512:
+  metadata.gz: f1157b553e0de5ed3fb76b997de222ebd5b6d42169f3b08da8a328a96c5adfdf220701779a74ce110763356e27a95b338744dbc459c5c018cbc0ef0ed735da91
+  data.tar.gz: 1e429cca606fbf9d0d1cbd27f795fe23c6316030dc659b78c9b2f040375274276bb55fb093abebb47da01dac3884fdd9267bee617e1f5e1bc4f6b2fc716052d3

data/hn_api_ruby/hn_api.rb

@@ -0,0 +1,854 @@
+# This file was autogenerated by some hot garbage in the `uniffi` crate.
+# Trust me, you don't want to mess with it!
+
+# Common helper code.
+#
+# Ideally this would live in a separate .rb file where it can be unittested etc
+# in isolation, and perhaps even published as a re-useable package.
+#
+# However, it's important that the detils of how this helper code works (e.g. the
+# way that different builtin types are passed across the FFI) exactly match what's
+# expected by the rust code on the other side of the interface. In practice right
+# now that means coming from the exact some version of `uniffi` that was used to
+# compile the rust component. The easiest way to ensure this is to bundle the Ruby
+# helpers directly inline like we're doing here.
+
+require 'ffi'
+
+module HnApi
+  class RustBuffer < FFI::Struct
+  layout :capacity, :int32,
+         :len,      :int32,
+         :data,     :pointer
+
+  def self.alloc(size)
+    return HnApi.rust_call(:ffi_hn_api_d6e5_rustbuffer_alloc, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return HnApi.rust_call(:ffi_hn_api_d6e5_rustbuffer_reserve, rbuf, additional)
+  end
+
+  def free
+    HnApi.rust_call(:ffi_hn_api_d6e5_rustbuffer_free, self)
+  end
+
+  def capacity
+    self[:capacity]
+  end
+
+  def len
+    self[:len]
+  end
+
+  def len=(value)
+    self[:len] = value
+  end
+
+  def data
+    self[:data]
+  end
+
+  def to_s
+    "RustBuffer(capacity=#{capacity}, len=#{len}, data=#{data.read_bytes len})"
+  end
+
+  # The allocated buffer will be automatically freed if an error occurs, ensuring that
+  # we don't accidentally leak it.
+  def self.allocWithBuilder
+    builder = RustBufferBuilder.new
+
+    begin
+      yield builder
+    rescue => e
+      builder.discard
+      raise e
+    end
+  end
+
+  # The RustBuffer will be freed once the context-manager exits, ensuring that we don't
+  # leak it even if an error occurs.
+  def consumeWithStream
+    stream = RustBufferStream.new self
+
+    yield stream
+
+    raise RuntimeError, 'junk data left in buffer after consuming' if stream.remaining != 0
+  ensure
+    free
+  end# The primitive String type.
+
+  def self.allocFromString(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write value.encode('utf-8')
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoString
+    consumeWithStream do |stream|
+      return stream.read(stream.remaining).force_encoding(Encoding::UTF_8)
+    end
+  end
+
+  # The Record type Story.
+
+  def self.alloc_from_TypeStory(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeStory(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeStory
+    consumeWithStream do |stream|
+      return stream.readTypeStory
+    end
+  end
+
+  # The Record type User.
+
+  def self.alloc_from_TypeUser(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_TypeUser(v)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoTypeUser
+    consumeWithStream do |stream|
+      return stream.readTypeUser
+    end
+  end
+
+  # The Optional<T> type for u32.
+
+  def self.alloc_from_Optionalu32(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalu32(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalu32
+    consumeWithStream do |stream|
+      return stream.readOptionalu32
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def self.alloc_from_Optionalstring(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionalstring(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalstring
+    consumeWithStream do |stream|
+      return stream.readOptionalstring
+    end
+  end
+
+  # The Optional<T> type for TypeStory.
+
+  def self.alloc_from_OptionalTypeStory(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeStory(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeStory
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeStory
+    end
+  end
+
+  # The Optional<T> type for TypeUser.
+
+  def self.alloc_from_OptionalTypeUser(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalTypeUser(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalTypeUser
+    consumeWithStream do |stream|
+      return stream.readOptionalTypeUser
+    end
+  end
+
+  # The Optional<T> type for Sequenceu32.
+
+  def self.alloc_from_OptionalSequenceu32(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_OptionalSequenceu32(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionalSequenceu32
+    consumeWithStream do |stream|
+      return stream.readOptionalSequenceu32
+    end
+  end
+
+  # The Sequence<T> type for u32.
+
+  def self.alloc_from_Sequenceu32(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Sequenceu32(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequenceu32
+    consumeWithStream do |stream|
+      return stream.readSequenceu32
+    end
+  end
+
+  
+end
+
+module UniFFILib
+  class ForeignBytes < FFI::Struct
+    layout :len,      :int32,
+           :data,     :pointer
+
+    def len
+      self[:len]
+    end
+
+    def data
+      self[:data]
+    end
+
+    def to_s
+      "ForeignBytes(len=#{len}, data=#{data.read_bytes(len)})"
+    end
+  end
+end
+
+private_constant :UniFFILib
+  
+# Helper for structured reading of values from a RustBuffer.
+class RustBufferStream
+
+  def initialize(rbuf)
+    @rbuf = rbuf
+    @offset = 0
+  end
+
+  def remaining
+    @rbuf.len - @offset
+  end
+
+  def read(size)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    data = @rbuf.data.get_bytes @offset, size
+
+    @offset += size
+
+    data
+  end
+
+  def readU32
+    unpack_from 4, 'L>'
+  end
+
+  def readU64
+    unpack_from 8, 'Q>'
+  end
+
+  def readString
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative string length' if size.negative?
+
+    read(size).force_encoding(Encoding::UTF_8)
+  end
+
+  # The Object type HnClient.
+
+  def readTypeHnClient
+    pointer = FFI::Pointer.new unpack_from 8, 'Q>'
+    return HnClient._uniffi_allocate(pointer)
+  end
+
+  # The Record type Story.
+
+  def readTypeStory
+    Story.new(
+      readU32,
+      readU32,
+      readString,
+      readOptionalSequenceu32,
+      readU32,
+      readString,
+      readOptionalstring,
+      readOptionalstring,
+      readU64
+    )
+  end
+
+  # The Record type User.
+
+  def readTypeUser
+    User.new(
+      readString,
+      readU64,
+      readU32,
+      readOptionalu32,
+      readOptionalstring,
+      readSequenceu32
+    )
+  end
+
+  # The Optional<T> type for u32.
+
+  def readOptionalu32
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readU32
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalu32'
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def readOptionalstring
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readString
+    else
+      raise InternalError, 'Unexpected flag byte for Optionalstring'
+    end
+  end
+
+  # The Optional<T> type for TypeStory.
+
+  def readOptionalTypeStory
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeStory
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeStory'
+    end
+  end
+
+  # The Optional<T> type for TypeUser.
+
+  def readOptionalTypeUser
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readTypeUser
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalTypeUser'
+    end
+  end
+
+  # The Optional<T> type for Sequenceu32.
+
+  def readOptionalSequenceu32
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readSequenceu32
+    else
+      raise InternalError, 'Unexpected flag byte for OptionalSequenceu32'
+    end
+  end
+
+  # The Sequence<T> type for u32.
+
+  def readSequenceu32
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readU32
+    end
+
+    items
+  end
+
+  
+
+  def unpack_from(size, format)
+    raise InternalError, 'read past end of rust buffer' if @offset + size > @rbuf.len
+
+    value = @rbuf.data.get_bytes(@offset, size).unpack format
+
+    @offset += size
+
+    # TODO: verify this
+    raise 'more than one element!!!' if value.size > 1
+
+    value[0]
+  end
+end
+
+private_constant :RustBufferStream
+  
+# Helper for structured writing of values into a RustBuffer.
+class RustBufferBuilder
+  def initialize
+    @rust_buf = RustBuffer.alloc 16
+    @rust_buf.len = 0
+  end
+
+  def finalize
+    rbuf = @rust_buf
+
+    @rust_buf = nil
+
+    rbuf
+  end
+
+  def discard
+    return if @rust_buf.nil?
+
+    rbuf = finalize
+    rbuf.free
+  end
+
+  def write(value)
+    reserve(value.bytes.size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, value.bytes
+    end
+  end
+
+  def write_U32(v)
+    pack_into(4, 'L>', v)
+  end
+
+  def write_U64(v)
+    pack_into(8, 'Q>', v)
+  end
+
+  def write_String(v)
+    v = v.to_s
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  # The Object type HnClient.
+
+  def write_TypeHnClient(obj)
+    pointer = HnClient._uniffi_lower obj
+    pack_into(8, 'Q>', pointer.address)
+  end
+
+  # The Record type Story.
+
+  def write_TypeStory(v)
+    self.write_U32(v.id)
+    self.write_U32(v.descendants)
+    self.write_String(v.by)
+    self.write_OptionalSequenceu32(v.kids)
+    self.write_U32(v.score)
+    self.write_String(v.title)
+    self.write_Optionalstring(v.url)
+    self.write_Optionalstring(v.text)
+    self.write_U64(v.time)
+  end
+
+  # The Record type User.
+
+  def write_TypeUser(v)
+    self.write_String(v.id)
+    self.write_U64(v.created)
+    self.write_U32(v.karma)
+    self.write_Optionalu32(v.delay)
+    self.write_Optionalstring(v.about)
+    self.write_Sequenceu32(v.submitted)
+  end
+
+  # The Optional<T> type for u32.
+
+  def write_Optionalu32(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_U32(v)
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def write_Optionalstring(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_String(v)
+    end
+  end
+
+  # The Optional<T> type for TypeStory.
+
+  def write_OptionalTypeStory(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeStory(v)
+    end
+  end
+
+  # The Optional<T> type for TypeUser.
+
+  def write_OptionalTypeUser(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_TypeUser(v)
+    end
+  end
+
+  # The Optional<T> type for Sequenceu32.
+
+  def write_OptionalSequenceu32(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_Sequenceu32(v)
+    end
+  end
+
+  # The Sequence<T> type for u32.
+
+  def write_Sequenceu32(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_U32(item)
+    end
+  end
+
+  
+
+  private
+
+  def reserve(num_bytes)
+    if @rust_buf.len + num_bytes > @rust_buf.capacity
+      @rust_buf = RustBuffer.reserve(@rust_buf, num_bytes)
+    end
+
+    yield
+
+    @rust_buf.len += num_bytes
+  end
+
+  def pack_into(size, format, value)
+    reserve(size) do
+      @rust_buf.data.put_array_of_char @rust_buf.len, [value].pack(format).bytes
+    end
+  end
+end
+
+private_constant :RustBufferBuilder
+
+  # Error definitions
+  class RustCallStatus < FFI::Struct
+  layout :code,    :int8,
+         :error_buf, RustBuffer
+
+  def code
+    self[:code]
+  end
+
+  def error_buf
+    self[:error_buf]
+  end
+
+  def to_s
+    "RustCallStatus(code=#{self[:code]})"
+  end
+end
+
+# These match the values from the uniffi::rustcalls module
+CALL_SUCCESS = 0
+CALL_ERROR = 1
+CALL_PANIC = 2
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+}
+
+private_constant :ERROR_MODULE_TO_READER_METHOD, :CALL_SUCCESS, :CALL_ERROR, :CALL_PANIC,
+                 :RustCallStatus
+
+def self.consume_buffer_into_error(error_module, rust_buffer)
+  rust_buffer.consumeWithStream do |stream|
+    reader_method = ERROR_MODULE_TO_READER_METHOD[error_module]
+    return stream.send(reader_method)
+  end
+end
+
+class InternalError < StandardError
+end
+
+def self.rust_call(fn_name, *args)
+  # Call a rust function
+  rust_call_with_error(nil, fn_name, *args)
+end
+
+def self.rust_call_with_error(error_module, fn_name, *args)
+  # Call a rust function and handle errors
+  #
+  # Use this when the rust function returns a Result<>.  error_module must be the error_module that corresponds to that Result.
+
+
+  # Note: RustCallStatus.new zeroes out the struct, which is exactly what we
+  # want to pass to Rust (code=0, error_buf=RustBuffer(len=0, capacity=0,
+  # data=NULL))
+  status = RustCallStatus.new
+  args << status
+
+  result = UniFFILib.public_send(fn_name, *args)
+
+  case status.code
+  when CALL_SUCCESS
+    result
+  when CALL_ERROR
+    if error_module.nil?
+      status.error_buf.free
+      raise InternalError, "CALL_ERROR with no error_module set"
+    else
+      raise consume_buffer_into_error(error_module, status.error_buf)
+    end
+  when CALL_PANIC
+    # When the rust code sees a panic, it tries to construct a RustBuffer
+    # with the message.  But if that code panics, then it just sends back
+    # an empty buffer.
+    if status.error_buf.len > 0
+      raise InternalError, status.error_buf.consumeIntoString()
+    else
+      raise InternalError, "Rust panic"
+    end
+  else
+    raise InternalError, "Unknown call status: #{status.code}"
+  end
+end
+
+private_class_method :consume_buffer_into_error
+
+  # This is how we find and load the dynamic library provided by the component.
+# For now we just look it up by name.
+module UniFFILib
+  extend FFI::Library
+
+  
+  ffi_lib 'hn_api'
+  
+
+  attach_function :ffi_hn_api_d6e5_HnClient_object_free,
+    [:pointer, RustCallStatus.by_ref],
+    :void
+  attach_function :hn_api_d6e5_HnClient_new,
+    [RustCallStatus.by_ref],
+    :pointer
+  attach_function :hn_api_d6e5_HnClient_get_user,
+    [:pointer, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :hn_api_d6e5_HnClient_get_new_stories,
+    [:pointer, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :hn_api_d6e5_HnClient_get_story,
+    [:pointer, :uint32, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_hn_api_d6e5_rustbuffer_alloc,
+    [:int32, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_hn_api_d6e5_rustbuffer_from_bytes,
+    [ForeignBytes, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_hn_api_d6e5_rustbuffer_free,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  attach_function :ffi_hn_api_d6e5_rustbuffer_reserve,
+    [RustBuffer.by_value, :int32, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  
+end
+
+  # Public interface members begin here.
+
+  
+  # Record type Story
+class Story
+  attr_reader :id, :descendants, :by, :kids, :score, :title, :url, :text, :time
+
+  def initialize(id, descendants, by, kids, score, title, url, text, time)
+    @id = id
+    @descendants = descendants
+    @by = by
+    @kids = kids
+    @score = score
+    @title = title
+    @url = url
+    @text = text
+    @time = time
+  end
+
+  def ==(other)
+    if @id != other.id
+      return false
+    end
+    if @descendants != other.descendants
+      return false
+    end
+    if @by != other.by
+      return false
+    end
+    if @kids != other.kids
+      return false
+    end
+    if @score != other.score
+      return false
+    end
+    if @title != other.title
+      return false
+    end
+    if @url != other.url
+      return false
+    end
+    if @text != other.text
+      return false
+    end
+    if @time != other.time
+      return false
+    end
+
+    true
+  end
+end
+  
+  # Record type User
+class User
+  attr_reader :id, :created, :karma, :delay, :about, :submitted
+
+  def initialize(id, created, karma, delay, about, submitted)
+    @id = id
+    @created = created
+    @karma = karma
+    @delay = delay
+    @about = about
+    @submitted = submitted
+  end
+
+  def ==(other)
+    if @id != other.id
+      return false
+    end
+    if @created != other.created
+      return false
+    end
+    if @karma != other.karma
+      return false
+    end
+    if @delay != other.delay
+      return false
+    end
+    if @about != other.about
+      return false
+    end
+    if @submitted != other.submitted
+      return false
+    end
+
+    true
+  end
+end
+  
+
+  
+
+  
+  class HnClient
+
+  # A private helper for initializing instances of the class from a raw pointer,
+  # bypassing any initialization logic and ensuring they are GC'd properly.
+  def self._uniffi_allocate(pointer)
+    pointer.autorelease = false
+    inst = allocate
+    inst.instance_variable_set :@pointer, pointer
+    ObjectSpace.define_finalizer(inst, _uniffi_define_finalizer_by_pointer(pointer, inst.object_id))
+    return inst
+  end
+
+  # A private helper for registering an object finalizer.
+  # N.B. it's important that this does not capture a reference
+  # to the actual instance, only its underlying pointer.
+  def self._uniffi_define_finalizer_by_pointer(pointer, object_id)
+    Proc.new do |_id|
+      HnApi.rust_call(
+        :ffi_hn_api_d6e5_HnClient_object_free,
+        pointer
+      )
+    end
+  end
+
+  # A private helper for lowering instances into a raw pointer.
+  # This does an explicit typecheck, because accidentally lowering a different type of
+  # object in a place where this type is expected, could lead to memory unsafety.
+  def self._uniffi_lower(inst)
+    if not inst.is_a? self
+      raise TypeError.new "Expected a HnClient instance, got #{inst}"
+    end
+    return inst.instance_variable_get :@pointer
+  end
+  def initialize()
+    pointer = HnApi.rust_call(:hn_api_d6e5_HnClient_new,)
+    @pointer = pointer
+    ObjectSpace.define_finalizer(self, self.class._uniffi_define_finalizer_by_pointer(pointer, self.object_id))
+  end
+
+  
+
+  def get_user(username)
+        username = username.to_s
+    result = HnApi.rust_call(:hn_api_d6e5_HnClient_get_user,@pointer,RustBuffer.allocFromString(username))
+    return result.consumeIntoOptionalTypeUser
+  end
+  def get_new_stories()
+    result = HnApi.rust_call(:hn_api_d6e5_HnClient_get_new_stories,@pointer,)
+    return result.consumeIntoSequenceu32
+  end
+  def get_story(id)
+        id = id.to_i
+    result = HnApi.rust_call(:hn_api_d6e5_HnClient_get_story,@pointer,id)
+    return result.consumeIntoOptionalTypeStory
+  end
+  
+end
+  
+end
+

data/hn_api_ruby/test.rb

@@ -0,0 +1,10 @@
+require_relative 'hn_api'
+
+
+client = HnApi::HnClient::new()
+res = client.get_new_stories()
+
+story = client.get_story(res[0])
+
+puts story.title
+puts story.url

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: hn_api_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Autogenerated
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-05-13 00:00:00.000000000 Z
+dependencies: []
+description: ''
+email: pmkelly4444@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- hn_api_ruby/hn_api.rb
+- hn_api_ruby/libhn_api.dylib
+- hn_api_ruby/test.rb
+homepage: https://rubygems.org/gems/hn_api_ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Hacker News API Client
+test_files: []