chordsketch 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a85b62f230b39c41fb4729e4730390f817c6b74a478fb1e81eade536a1f52c2a
+  data.tar.gz: 88ebdf8f9af317a632bda4ccee5d3f1858d296870590926f90299e23ac548335
+SHA512:
+  metadata.gz: 73edde31c61c7bb8a106b4fbd50c65c320785187c8911c2edc0762738c39ad6973e6b8a7111e5317691ff99641068756c6ff194b530f27dfb906b8c067903f07
+  data.tar.gz: 766614dcf8e2ce64906abe0471bc4299d0441529c72f4da77254a7a1f2ca329d1c0c237c51d3a662a4dafda5d9c5f4036822e1246fc398508a8083f0bf06c9ce

data/lib/chordsketch.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+# ChordPro file format parser and renderer.
+#
+# This gem provides native bindings to the ChordSketch Rust library
+# via UniFFI-generated Ruby code.
+#
+# @example Render ChordPro as text
+#   text = Chordsketch.parse_and_render_text("{title: Hello}\n[C]Hello", nil, nil)
+#
+# @example Render with transposition
+#   text = Chordsketch.parse_and_render_text(input, "guitar", 2)
+
+require "ffi"
+require "rbconfig"
+
+# Detect the platform and pre-load the correct native library before
+# requiring the UniFFI-generated bindings.
+module Chordsketch
+  # @api private
+  module NativeLoader
+    PLATFORM_MAP = {
+      /x86_64.*linux/                 => "x86_64-linux",
+      /aarch64.*linux/                => "aarch64-linux",
+      /arm64.*darwin|aarch64.*darwin/ => "aarch64-darwin",
+      /x86_64.*darwin/                => "x86_64-darwin",
+      /x64.*mingw|x64.*mswin/        => "x86_64-windows",
+    }.freeze
+
+    # Detect the platform-specific subdirectory for native libraries.
+    def self.detect_platform_dir
+      arch = RbConfig::CONFIG["arch"]
+      PLATFORM_MAP.each do |pattern, dir|
+        return dir if arch.match?(pattern)
+      end
+      raise "Unsupported platform: #{arch}. " \
+            "ChordSketch supports x86_64/aarch64 Linux, macOS, and x86_64 Windows."
+    end
+
+    # Resolve and validate the absolute path to the platform-specific
+    # native library, then expose it as `Chordsketch::NATIVE_LIB_PATH`
+    # so the UniFFI-generated bindings can pass it to `ffi_lib`.
+    #
+    # The previous approach of pre-loading via `FFI::DynamicLibrary.open`
+    # with `RTLD_GLOBAL` was unreliable: ffi gem 1.17+ explicitly opens
+    # its own handle by name in `ffi_lib` and ignores already-loaded
+    # global handles, so the bindings would fail with "Could not open
+    # library 'chordsketch_ffi'" even after a successful pre-load. See
+    # #1082.
+    def self.load!
+      platform_dir = detect_platform_dir
+      lib_dir = File.join(File.dirname(__FILE__), platform_dir)
+      lib_name = FFI.map_library_name("chordsketch_ffi")
+      lib_path = File.join(lib_dir, lib_name)
+
+      unless File.exist?(lib_path)
+        raise "Native library not found at #{lib_path}. " \
+              "Ensure the gem was built for your platform (#{platform_dir}). " \
+              "For local development, generate bindings with:\n" \
+              "  cargo run -p chordsketch-ffi --bin uniffi-bindgen generate \\\n" \
+              "    --library target/debug/libchordsketch_ffi.so \\\n" \
+              "    --language ruby --out-dir packages/ruby/lib/"
+      end
+
+      Chordsketch.const_set(:NATIVE_LIB_PATH, lib_path)
+    end
+  end
+end
+
+Chordsketch::NativeLoader.load!
+
+# Load the UniFFI-generated bindings. Their `ffi_lib` line is rewritten
+# to reference `Chordsketch::NATIVE_LIB_PATH` (set above) by a sed step
+# in the gem build pipeline. See `.github/workflows/ruby.yml` and #1082.
+require_relative "chordsketch_uniffi"

data/lib/chordsketch_uniffi.rb

@@ -0,0 +1,703 @@
+# 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 details 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 Chordsketch
+  def self.uniffi_in_range(i, type_name, min, max)
+  raise TypeError, "no implicit conversion of #{i} into Integer" unless i.respond_to?(:to_int)
+  i = i.to_int
+  raise RangeError, "#{type_name} requires #{min} <= value < #{max}" unless (min <= i && i < max)
+  i
+end
+
+def self.uniffi_utf8(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v = v.to_str.encode(Encoding::UTF_8)
+  raise Encoding::InvalidByteSequenceError, "not a valid UTF-8 encoded string" unless v.valid_encoding?
+  v
+end
+
+def self.uniffi_bytes(v)
+  raise TypeError, "no implicit conversion of #{v} into String" unless v.respond_to?(:to_str)
+  v.to_str
+end
+
+  class RustBuffer < FFI::Struct
+  layout :capacity, :uint64,
+         :len,      :uint64,
+         :data,     :pointer
+
+  def self.alloc(size)
+    return Chordsketch.rust_call(:ffi_chordsketch_ffi_rustbuffer_alloc, size)
+  end
+
+  def self.reserve(rbuf, additional)
+    return Chordsketch.rust_call(:ffi_chordsketch_ffi_rustbuffer_reserve, rbuf, additional)
+  end
+
+  def free
+    Chordsketch.rust_call(:ffi_chordsketch_ffi_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 primitive Bytes type.
+
+  def self.allocFromBytes(value)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Bytes(value)
+      return builder.finalize
+    end
+  end
+
+  def consumeIntoBytes
+    consumeWithStream do |stream|
+      return stream.readBytes
+    end
+  end
+
+  
+
+  # The Optional<T> type for i8.
+
+  def self.check_lower_Optionali8(v)
+    if not v.nil?
+      
+    end
+  end
+
+  def self.alloc_from_Optionali8(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Optionali8(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoOptionali8
+    consumeWithStream do |stream|
+      return stream.readOptionali8
+    end
+  end
+
+  # The Optional<T> type for string.
+
+  def self.check_lower_Optionalstring(v)
+    if not v.nil?
+      
+    end
+  end
+
+  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 Sequence<T> type for string.
+
+  def self.check_lower_Sequencestring(v)
+    v.each do |item|
+      
+    end
+  end
+
+  def self.alloc_from_Sequencestring(v)
+    RustBuffer.allocWithBuilder do |builder|
+      builder.write_Sequencestring(v)
+      return builder.finalize()
+    end
+  end
+
+  def consumeIntoSequencestring
+    consumeWithStream do |stream|
+      return stream.readSequencestring
+    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 readI8
+    unpack_from 1, 'c'
+  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
+
+  def readBytes
+    size = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative byte string length' if size.negative?
+
+    read(size).force_encoding(Encoding::BINARY)
+  end
+
+  
+
+  
+
+  # The Error type ChordSketchError
+
+  def readTypeChordSketchError
+    variant = unpack_from 4, 'l>'
+    
+    if variant == 1
+        return ChordSketchError::NoSongsFound.new
+    end
+    if variant == 2
+        return ChordSketchError::InvalidConfig.new(
+            readString()
+        )
+    end
+
+    raise InternalError, 'Unexpected variant tag for TypeChordSketchError'
+  end
+  
+
+  # The Optional<T> type for i8.
+
+  def readOptionali8
+    flag = unpack_from 1, 'c'
+
+    if flag == 0
+      return nil
+    elsif flag == 1
+      return readI8
+    else
+      raise InternalError, 'Unexpected flag byte for Optionali8'
+    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 Sequence<T> type for string.
+
+  def readSequencestring
+    count = unpack_from 4, 'l>'
+
+    raise InternalError, 'Unexpected negative sequence length' if count.negative?
+
+    items = []
+
+    count.times do
+      items.append readString
+    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_I8(v)
+    v = Chordsketch::uniffi_in_range(v, "i8", -2**7, 2**7)
+    pack_into(1, 'c', v)
+  end
+
+  def write_String(v)
+    v = Chordsketch::uniffi_utf8(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  def write_Bytes(v)
+    v = Chordsketch::uniffi_bytes(v)
+    pack_into 4, 'l>', v.bytes.size
+    write v
+  end
+
+  
+
+  # The Optional<T> type for i8.
+
+  def write_Optionali8(v)
+    if v.nil?
+      pack_into(1, 'c', 0)
+    else
+      pack_into(1, 'c', 1)
+      self.write_I8(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 Sequence<T> type for string.
+
+  def write_Sequencestring(items)
+    pack_into(4, 'l>', items.size)
+
+    items.each do |item|
+      self.write_String(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
+
+
+module ChordSketchError
+  class NoSongsFound < StandardError
+    def initialize()
+        super()
+      end
+
+    def to_s
+     "#{self.class.name}()"
+    end
+  end
+  class InvalidConfig < StandardError
+    def initialize(reason)
+        @reason = reason
+        super()
+      end
+
+    attr_reader :reason
+    
+
+    def to_s
+     "#{self.class.name}(reason=#{@reason.inspect})"
+    end
+  end
+
+end
+
+
+# Map error modules to the RustBuffer method name that reads them
+ERROR_MODULE_TO_READER_METHOD = {
+
+  ChordSketchError => :readTypeChordSketchError,
+
+}
+
+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 Chordsketch::NATIVE_LIB_PATH
+  
+
+  attach_function :uniffi_chordsketch_ffi_fn_func_parse_and_render_html,
+    [RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_chordsketch_ffi_fn_func_parse_and_render_pdf,
+    [RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_chordsketch_ffi_fn_func_parse_and_render_text,
+    [RustBuffer.by_value, RustBuffer.by_value, RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_chordsketch_ffi_fn_func_validate,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_chordsketch_ffi_fn_func_version,
+    [RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_chordsketch_ffi_rustbuffer_alloc,
+    [:uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_chordsketch_ffi_rustbuffer_from_bytes,
+    [ForeignBytes, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :ffi_chordsketch_ffi_rustbuffer_free,
+    [RustBuffer.by_value, RustCallStatus.by_ref],
+    :void
+  attach_function :ffi_chordsketch_ffi_rustbuffer_reserve,
+    [RustBuffer.by_value, :uint64, RustCallStatus.by_ref],
+    RustBuffer.by_value
+  attach_function :uniffi_chordsketch_ffi_checksum_func_parse_and_render_html,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_chordsketch_ffi_checksum_func_parse_and_render_pdf,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_chordsketch_ffi_checksum_func_parse_and_render_text,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_chordsketch_ffi_checksum_func_validate,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :uniffi_chordsketch_ffi_checksum_func_version,
+    [RustCallStatus.by_ref],
+    :uint16
+  attach_function :ffi_chordsketch_ffi_uniffi_contract_version,
+    [RustCallStatus.by_ref],
+    :uint32
+  
+end
+
+  # Public interface members begin here.
+
+  
+  
+
+  
+  
+
+def self.parse_and_render_html(input, config_json, transpose)
+    input = Chordsketch::uniffi_utf8(input)
+    
+    
+    config_json = (config_json ? Chordsketch::uniffi_utf8(config_json) : nil)
+    RustBuffer.check_lower_Optionalstring(config_json)
+    
+    transpose = (transpose ? Chordsketch::uniffi_in_range(transpose, "i8", -2**7, 2**7) : nil)
+    RustBuffer.check_lower_Optionali8(transpose)
+    
+  result = Chordsketch.rust_call_with_error(ChordSketchError,:uniffi_chordsketch_ffi_fn_func_parse_and_render_html,RustBuffer.allocFromString(input),RustBuffer.alloc_from_Optionalstring(config_json),RustBuffer.alloc_from_Optionali8(transpose))
+  return result.consumeIntoString
+end
+
+
+  
+  
+
+def self.parse_and_render_pdf(input, config_json, transpose)
+    input = Chordsketch::uniffi_utf8(input)
+    
+    
+    config_json = (config_json ? Chordsketch::uniffi_utf8(config_json) : nil)
+    RustBuffer.check_lower_Optionalstring(config_json)
+    
+    transpose = (transpose ? Chordsketch::uniffi_in_range(transpose, "i8", -2**7, 2**7) : nil)
+    RustBuffer.check_lower_Optionali8(transpose)
+    
+  result = Chordsketch.rust_call_with_error(ChordSketchError,:uniffi_chordsketch_ffi_fn_func_parse_and_render_pdf,RustBuffer.allocFromString(input),RustBuffer.alloc_from_Optionalstring(config_json),RustBuffer.alloc_from_Optionali8(transpose))
+  return result.consumeIntoBytes
+end
+
+
+  
+  
+
+def self.parse_and_render_text(input, config_json, transpose)
+    input = Chordsketch::uniffi_utf8(input)
+    
+    
+    config_json = (config_json ? Chordsketch::uniffi_utf8(config_json) : nil)
+    RustBuffer.check_lower_Optionalstring(config_json)
+    
+    transpose = (transpose ? Chordsketch::uniffi_in_range(transpose, "i8", -2**7, 2**7) : nil)
+    RustBuffer.check_lower_Optionali8(transpose)
+    
+  result = Chordsketch.rust_call_with_error(ChordSketchError,:uniffi_chordsketch_ffi_fn_func_parse_and_render_text,RustBuffer.allocFromString(input),RustBuffer.alloc_from_Optionalstring(config_json),RustBuffer.alloc_from_Optionali8(transpose))
+  return result.consumeIntoString
+end
+
+
+  
+  
+
+def self.validate(input)
+    input = Chordsketch::uniffi_utf8(input)
+    
+    
+  result = Chordsketch.rust_call(:uniffi_chordsketch_ffi_fn_func_validate,RustBuffer.allocFromString(input))
+  return result.consumeIntoSequencestring
+end
+
+
+  
+  
+
+def self.version()
+  result = Chordsketch.rust_call(:uniffi_chordsketch_ffi_fn_func_version,)
+  return result.consumeIntoString
+end
+
+
+  
+
+  
+end
+

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: chordsketch
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- koedame
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+description: Parse and render ChordPro files to text, HTML, and PDF. Native bindings
+  via UniFFI for high performance.
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/aarch64-darwin/libchordsketch_ffi.dylib
+- lib/aarch64-linux/libchordsketch_ffi.so
+- lib/chordsketch.rb
+- lib/chordsketch_uniffi.rb
+- lib/x86_64-darwin/libchordsketch_ffi.dylib
+- lib/x86_64-linux/libchordsketch_ffi.so
+- lib/x86_64-windows/chordsketch_ffi.dll
+homepage: https://github.com/koedame/chordsketch
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/koedame/chordsketch
+  bug_tracker_uri: https://github.com/koedame/chordsketch/issues
+  changelog_uri: https://github.com/koedame/chordsketch/releases
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: ChordPro file format parser and renderer
+test_files: []