ndav 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6f7a33419819c6f7c3358aba6b51ebc8b0039c96a3ab8266ef88e75d9567bf0b
+  data.tar.gz: be7e0f8194bddf00e96e9c52d6cc3757add2e33068c1a478b2d23951ad1e4f34
+SHA512:
+  metadata.gz: 754b518b28f22bf7ca48e41cbfdaa3733fa61dfa4a42032b4a8947a6cc3e8fabfcd2f3c8e30842e04efe3e74e981077850459c6ab79484c1619205966e5e3a71
+  data.tar.gz: d142c31e77fd5586ed0ff6284383c912de4b8edc54811bd27243da05ebd3df8b693f4500100200837dbfd77098362dc4e0e2f3cddd3d95d1c12986ea5eee9ccd

data/.gitignore

@@ -0,0 +1,7 @@
+Gemfile.lock
+ext/Makefile
+*.so
+*bundle
+*dll
+*.o
+*.bundle.dSYM

data/.gitlab-ci.yml

@@ -0,0 +1,14 @@
+default:
+  image: ruby:4.0
+  before_script:
+    - bundle config set path.system true
+    - bundle install
+    - bundle env
+
+test:
+  cache:
+    key: gems
+    paths:
+      - /root/.local/share/gem/ruby
+  script:
+    - rake test

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec
+
+plugin "rubygems-requirements-system"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 2026 Kitati Makoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/README.md

@@ -0,0 +1,9 @@
+NDAV - N-Dimensional Array View
+===============================
+
+Wrapper for MemoryView and pointer.
+
+LICENSE
+-------
+
+BSD-2-Clause license. See LICENSE.txt file.

data/Rakefile

@@ -0,0 +1,49 @@
+require "rake/clean"
+require "rake/testtask"
+require "rubygems/tasks"
+
+DL_NAME = "ndav".ext(RbConfig::CONFIG["DLEXT"])
+DL_BUILD_PATH = File.join("ext", DL_NAME)
+DL_PATH = File.join("lib", DL_NAME)
+
+SRC = FileList["ext/**.{h,c,rb}"]
+
+task default: :test
+
+Rake::TestTask.new test: DL_PATH
+tasks = Gem::Tasks.new
+gemspec = tasks.build.gem.project.gemspec
+
+file DL_PATH => DL_BUILD_PATH do |t|
+  copy t.source, t.name
+end
+CLEAN.include DL_PATH
+
+MAKEFILE = "ext/Makefile"
+file DL_BUILD_PATH => MAKEFILE do |t|
+  chdir "ext" do
+    system "make", exception: true
+  end
+end
+
+if File.exist? MAKEFILE
+  task make_clean: MAKEFILE do
+    chdir "ext" do
+      system "make clean", exception: true
+    end
+  end
+  task clean: :make_clean
+
+  task make_dist_clean: MAKEFILE do
+    chdir "ext" do
+      system "make distclean"
+    end
+  end
+  task clobber: :make_dist_clean
+end
+
+file MAKEFILE => SRC do
+  chdir "ext" do
+    ruby "extconf.rb"
+  end
+end

data/ext/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile "ndav"

data/ext/ndav.c

@@ -0,0 +1,145 @@
+#include "ndav.h"
+
+ID id_to_s;
+
+typedef struct fill_size_array_args_t {
+  VALUE src;
+  ssize_t *dest;
+  ssize_t size;
+} fill_size_array_args_t;
+
+static VALUE
+fill_size_array(VALUE rb_args)
+{
+  struct fill_size_array_args_t *args = (fill_size_array_args_t *)rb_args;
+  for (ssize_t i = 0; i < args->size; i++) {
+    VALUE val = rb_ary_entry(args->src, i);
+    args->dest[i] = NUM2SSIZET(val);
+  }
+  return Qnil;
+}
+
+static bool
+ndav_get_memory_view(const VALUE ndav, rb_memory_view_t *view, int flags)
+{
+  bool row_major_requested = (flags & RUBY_MEMORY_VIEW_ROW_MAJOR) == RUBY_MEMORY_VIEW_ROW_MAJOR;
+  bool column_major_requested = (flags & RUBY_MEMORY_VIEW_COLUMN_MAJOR) == RUBY_MEMORY_VIEW_COLUMN_MAJOR;
+  bool indirect_requested = (flags & RUBY_MEMORY_VIEW_INDIRECT) == RUBY_MEMORY_VIEW_INDIRECT;
+  if ((column_major_requested && !row_major_requested) || indirect_requested) {
+    return false;
+  }
+  bool writable_requested = (flags & RUBY_MEMORY_VIEW_WRITABLE) == RUBY_MEMORY_VIEW_WRITABLE;
+  // TODO: Handle flags
+
+  VALUE readonly = rb_iv_get(ndav, "@readonly");
+  if (NIL_P(readonly)) {
+    if (writable_requested) {
+      rb_warn("not writable");
+      return false;
+    }
+    view->readonly = true;
+  } else {
+    view->readonly = RTEST(readonly);
+  }
+  view->obj = ndav;
+  VALUE val = rb_funcall(ndav, id_to_s, 0);
+  char *data = StringValuePtr(val);
+  view->data = data;
+  // TODO: Commonalize
+  // TODO: Consider:
+  // * Use TypedData?
+  //   * If so, calling attr readers at Ruby layer has performance disadvantage.
+  //   * Freezing instance vars in #initialize and then embed them to TypedData may be a solution
+  VALUE item_size = rb_iv_get(ndav, "@item_size");
+  view->item_size = NUM2SSIZET(item_size);
+  VALUE byte_size = rb_iv_get(ndav, "@byte_size");
+  view->byte_size = NUM2SSIZET(byte_size);
+  VALUE ndim = rb_iv_get(ndav, "@ndim");
+  view->ndim = NUM2SSIZET(ndim);
+  VALUE format = rb_iv_get(ndav, "@format");
+  view->format = StringValueCStr(format);
+
+  int state;
+
+  // TODO: Commonalize
+  VALUE shape = rb_iv_get(ndav, "@shape");
+  if (!RB_TYPE_P(shape, T_ARRAY)) {
+    rb_warn("@shape is not an array");
+    return false;
+  }
+  ssize_t *view_shape = ALLOC_N(ssize_t, view->ndim);
+  fill_size_array_args_t shape_args = {
+    shape,
+    view_shape,
+    view->ndim,
+  };
+  rb_protect(fill_size_array, (VALUE)&shape_args, &state);
+  if (state) {
+    xfree(view_shape);
+    rb_jump_tag(state);
+    return false;
+  }
+  view->shape = view_shape;
+
+  VALUE strides = rb_iv_get(ndav, "@strides");
+  if (!RB_TYPE_P(strides, T_ARRAY)) {
+    rb_warn("@strides is not an array");
+    xfree((void *)view->shape);
+    return false;
+  }
+  ssize_t *view_strides = ALLOC_N(ssize_t, view->ndim);
+  fill_size_array_args_t strides_args = {
+    strides,
+    view_strides,
+    view->ndim
+  };
+  rb_protect(fill_size_array, (VALUE)&strides_args, &state);
+  if (state) {
+    xfree((void *)view_shape);
+    xfree((void *)view_strides);
+    rb_jump_tag(state);
+    return false;
+  }
+  view->strides = view_strides;
+
+  view->sub_offsets = NULL;
+
+  return true;
+}
+
+static bool
+ndav_release_memory_view(const VALUE ndav, rb_memory_view_t *view)
+{
+  if (view->shape) {
+    xfree((void *)view->shape);
+    view->shape = NULL;
+  }
+  if (view->strides) {
+    xfree((void *)view->strides);
+    view->strides = NULL;
+  }
+
+  return true;
+}
+
+static bool
+ndav_memory_view_available_p(const VALUE obj)
+{
+  VALUE fmv = rb_iv_get(obj, "@fmv");
+  return !NIL_P(fmv);
+}
+
+const struct rb_memory_view_entry ndav_view_entry = {
+  ndav_get_memory_view,
+  ndav_release_memory_view,
+  ndav_memory_view_available_p
+};
+
+void
+Init_ndav(void)
+{
+  id_to_s = rb_intern("to_s");
+
+  VALUE cNDAV = rb_define_class("NDAV", rb_cObject);
+  rb_memory_view_register(cNDAV, &ndav_view_entry);
+}

data/ext/ndav.h

@@ -0,0 +1,2 @@
+#include <ruby.h>
+#include <ruby/memory_view.h>

data/lib/ndav/converter.rb

@@ -0,0 +1,21 @@
+class NDAV
+  class << self
+    alias from_memory_view new
+    alias from_fiddle_memory_view new
+    alias from_fiddle_pointer new
+  end
+
+  module Converter
+    class << self
+      def NDAV(array, *, **)
+        if array.kind_of? ::NDAV
+          array
+        elsif array.respond_to?(:to_ndav)
+          array.to_ndav(*, **)
+        else
+          ::NDAV.new(array, *, **)
+        end
+      end
+    end
+  end
+end

data/lib/ndav/ffi.rb

@@ -0,0 +1,93 @@
+require "ffi"
+
+class NDAV
+  module FFI
+    TYPE_SIZE_TO_FORMAT = {
+      1 => "c",
+      2 => "s",
+      4 => "l",
+      8 => "q"
+    }
+
+    module MemoryPointer
+      module FromNDAV
+        # NOTE: Copies data
+        def from_ndav(array)
+          from_string(array.to_s)
+        end
+      end
+
+      module ToNDAV
+        def to_ndav(format: nil, lifetime: nil, **)
+          ::NDAV.from_ffi_memory_pointer(self, shape: [size / type_size], format: format || TYPE_SIZE_TO_FORMAT[type_size], lifetime: lifetime || self, **)
+        end
+      end
+
+      module Converter
+        def NDAV(array, *, **)
+          if array.kind_of? ::FFI::MemoryPointer
+            array.to_ndav(**)
+          else
+            super
+          end
+        end
+      end
+    end
+
+    module Pointer
+      module FromNDAV
+        def from_ndav(array)
+          new(array.item_size, array.to_ptr.to_i)
+        end
+      end
+
+      module ToDAV
+        def to_ndav(format: nil, lifetime: nil, **)
+          ::NDAV.from_ffi_pointer(self, shape: [size / type_size], format: format || TYPE_SIZE_TO_FORMAT[type_size], lifetime: lifetime || self, **)
+        end
+      end
+
+      module Converter
+        def NDAV(array, *, **)
+          # use instance_of? instead of kind_of? because MemoryPointer < Pointer
+          if array.instance_of? ::FFI::Pointer
+            array.to_ndav(**)
+          else
+            super
+          end
+        end
+      end
+    end
+
+    module FromFFI
+      def from_ffi_memory_pointer(array, shape:, format:, **)
+        byte_size = shape.reduce(ITEM_SIZES[format], :*)
+        ptr = ::Fiddle::Pointer.new(array.address, byte_size)
+        new(ptr, shape:, format:, **)
+      end
+
+      def from_ffi_pointer(array, lifetime:, **)
+        from_ffi_memory_pointer(array, lifetime:, **)
+      end
+    end
+
+    module ToFFI
+      def to_ffi_memory_pointer
+        ::FFI::MemoryPointer.from_ndav(self)
+      end
+
+      def to_ffi_pointer
+        ::FFI::Pointer.from_ndav(self)
+      end
+    end
+
+    ::FFI::MemoryPointer.extend MemoryPointer::FromNDAV
+    ::FFI::MemoryPointer.include MemoryPointer::ToNDAV
+    ::FFI::Pointer.extend Pointer::FromNDAV
+    ::FFI::Pointer.include Pointer::ToDAV
+    ::NDAV.extend FromFFI
+    ::NDAV.include ToFFI
+    ::NDAV::Converter.singleton_class.prepend Pointer::Converter
+    ::NDAV::Converter.singleton_class.prepend MemoryPointer::Converter
+  end
+end

data/lib/ndav.rb

@@ -0,0 +1,88 @@
+require "fiddle"
+require "ndav.so"
+require "ndav/converter"
+
+# TODO: Manage flags of internal data object
+class NDAV
+  # TODO: Want to use return value of rb_memory_view_parse_item_format
+  ITEM_SIZES = ["c", "C", "s", "S", "l", "L", "q", "Q", "f", "d", "s!", "S!", "n", "v", "i", "i!", "I", "I!", "l!", "L!", "N", "V", "e", "g", "q!", "Q!", "E", "G"].collect {|format|
+    [format, [0].pack(format).bytesize]
+  }.to_h
+
+  attr_reader :ndim, :shape, :format, :item_size, :byte_size, :strides, :lifetime
+
+  # TODO: More options to trick for the case of MemoryView export is wrong but developer don't fix it
+  def initialize(input, shape: nil, format: nil, lifetime: nil)
+    @fmv = input.kind_of?(::Fiddle::MemoryView) ? input : ::Fiddle::MemoryView.new(input)
+    @lifetime = [@fmv.obj, lifetime].compact
+    @lifetime = nil if @lifetime.empty?
+
+    @format = format || @fmv.format
+    raise ArgumentError, %Q|unsupported format: #{@format.to_s.dump}, currently supported: #{ITEM_SIZES.keys}| unless ITEM_SIZES.key?(@format)
+
+    item_size_by_format = ITEM_SIZES[@format]
+
+    @byte_size = @fmv.byte_size
+    @item_size = input.kind_of?(::Fiddle::Pointer) ? item_size_by_format : @fmv.item_size || item_size_by_format
+    @shape = shape || @fmv.shape
+    case [@shape, @byte_size]
+    in [nil, nil]
+      raise ArgumentError, "either shape or byte_size must be present in input or arguments"
+    in [*, nil]
+      @byte_size = @shape.reduce(@item_size, :*)
+    in [nil, *]
+      n, r = @byte_size.divmod(@item_size)
+      raise ArgumentError, "byte_size must be n-times of item_size" unless r.zero?
+      @shape = [n]
+    else
+      # noop
+    end
+    @strides = @fmv.strides || @shape.reverse_each.reduce([[], @item_size]) {|(strides, stride), s|
+      strides.unshift(stride)
+      [strides, stride * s]
+    }[0]
+    @ndim = @shape.size
+    @readonly = @fmv.readonly?
+
+    validate
+  end
+
+  def readonly?
+    @readonly
+  end
+
+  # Zero-copy
+  def to_s
+    # MemoryView#to_s is zero-copy
+    # Assign to @data to keep reference to the string to prevent GC
+    @data ||= @fmv.to_s
+  end
+
+  def to_ptr
+    ::Fiddle::Pointer[to_s]
+  end
+  alias to_fiddle_pointer to_ptr
+
+  private
+
+  def validate
+    unless @item_size == ITEM_SIZES[@format]
+      raise ArgumentError, "item_size does not match format"
+    end
+
+    if @fmv.sub_offsets
+      raise ArgumentError, "suboffsets not supported"
+    end
+
+    stride = @item_size
+    @shape.reverse_each.with_index do |s, i|
+      unless @strides[@ndim - 1 - i] == stride
+        raise ArgumentError, "only row-major contiguous strides is supported"
+      end
+      stride *= s
+    end
+    unless stride == @byte_size
+      raise ArgumentError, "strides not match byte_size"
+    end
+  end
+end

data/ndav.gemspec

@@ -0,0 +1,22 @@
+Gem::Specification.new do |s|
+  s.name = "ndav"
+  s.version = "0.0.1"
+  s.summary = "N-Dimensional Array View"
+  s.authors = ["Kitaiti Makoto"]
+  s.licenses = ["BSD-2-Clause"]
+
+  s.files = Dir.chdir(__dir__) {`git ls-files -z`.split("\x0")}
+  s.extensions = ["ext/extconf.rb"]
+
+  s.add_runtime_dependency "fiddle"
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "test-unit"
+  s.add_development_dependency "test-unit-notify"
+  s.add_development_dependency "test-unit-rr"
+  s.add_development_dependency "terminal-notifier" if RUBY_PLATFORM.match?(/darwin/)
+  s.add_development_dependency "rubygems-tasks"
+  s.add_development_dependency "rubygems-requirements-system"
+  s.add_development_dependency "red-arrow"
+  s.add_development_dependency "ffi"
+end

data/test/helper.rb

@@ -0,0 +1,22 @@
+require "test/unit"
+require "test/unit/notify"
+
+require "fiddle"
+require "arrow"
+require "ndav"
+require "ndav/ffi"
+
+class TestBase < Test::Unit::TestCase
+  private
+
+  def assert_int_array(array)
+    assert_equal 1, array.ndim
+    assert_equal "s", array.format
+    assert_equal [3], array.shape
+    assert_equal [2], array.strides
+    assert_equal 2, array.item_size
+    assert_equal 6, array.byte_size
+    assert_true array.readonly?
+    assert_equal [1, 2, 3].pack("s*"), array.to_s
+  end
+end

data/test/test_converter.rb

@@ -0,0 +1,23 @@
+require_relative "helper"
+
+class TestConverter < TestBase
+  def setup
+    @array = Arrow::Int16Array.new([1, 2, 3])
+  end
+
+  def test_ndav_from_ndav
+    ndav = NDAV.new(@array)
+
+    assert_same ndav, NDAV::Converter::NDAV(ndav)
+  end
+
+  def test_ndav_from_memory_view
+    assert_int_array NDAV::Converter::NDAV(@array)
+  end
+
+  def test_ndav_from_fiddle_memory_view
+    fmv = Fiddle::MemoryView.new(@array)
+
+    assert_int_array NDAV::Converter::NDAV(fmv)
+  end
+end

data/test/test_export.rb

@@ -0,0 +1,16 @@
+require_relative "helper"
+
+class TestExport < TestBase
+  def test_export
+    mv = Fiddle::MemoryView.new(NDAV.new(Arrow::Int16Array.new([1, 2, 3])))
+    assert_equal 1, mv.ndim
+    assert_equal "s", mv.format
+    assert_equal [3], mv.shape
+    assert_equal [2], mv.strides
+    assert_equal 2, mv.item_size
+    assert_equal 6, mv.byte_size
+    assert_true mv.readonly?
+    assert_equal [1, 2, 3], mv.to_s.unpack("s*")
+    assert_nil mv.sub_offsets
+  end
+end

data/test/test_ffi.rb

@@ -0,0 +1,69 @@
+require_relative "helper"
+
+class TestFFI < TestBase
+  def test_ndav_from_ffi_memory_pointer
+    ptr = ::FFI::MemoryPointer.new(:int16, 3)
+    ptr.write_array_of_int16([1, 2, 3])
+    ndav = ::NDAV.from_ffi_memory_pointer(ptr, shape: [3], format: "s")
+
+    assert_int_array ndav
+  end
+
+  def test_ndav_from_ffi_pointer
+    str = [1, 2, 3].pack("s*")
+    address = ::Fiddle::Pointer[str].to_i
+    ptr = ::FFI::Pointer.new(:int16, address)
+    ndav = ::NDAV.from_ffi_pointer(ptr, shape: [3], format: "s", lifetime: str)
+
+    assert_int_array ndav
+  end
+
+  def test_ndav_to_ffi_memory_pointer
+    ndav = ::NDAV.new(Arrow::Int16Array.new([1, 2, 3]))
+    ptr = ndav.to_ffi_memory_pointer
+
+    assert_equal [1, 2, 3].pack("s*"), ptr.read_string(ndav.byte_size)
+  end
+
+  def test_ndav_to_ffi_pointer
+    ndav = ::NDAV.new(Arrow::Int16Array.new([1, 2, 3]))
+    ptr = ndav.to_ffi_pointer
+
+    assert_equal [1, 2, 3].pack("s*"), ptr.read_string(ndav.byte_size)
+    assert_equal ndav.to_ptr.to_i, ptr.address
+  end
+
+  def test_ffi_memory_pointer_from_ndav
+    ndav = ::NDAV.new(Arrow::Int16Array.new([1, 2, 3]))
+    ptr = ::FFI::MemoryPointer.from_ndav(ndav)
+
+    assert_equal [1, 2, 3].pack("s*"), ptr.read_string(ndav.byte_size)
+  end
+
+  def test_ffi_pointer_from_ndav
+    ndav = ::NDAV.new(Arrow::Int16Array.new([1, 2, 3]))
+    ptr = ::FFI::Pointer.from_ndav(ndav)
+
+    assert_equal [1, 2, 3].pack("s*"), ptr.read_string(ndav.byte_size)
+    assert_equal ndav.to_ptr.to_i, ptr.address
+  end
+
+  class TestConverter < self
+    def test_ndav_from_ffi_memory_pointer
+      ptr = ::FFI::MemoryPointer.new(:int16, 3)
+      ptr.write_array_of_int16([1, 2, 3])
+      ndav = ::NDAV::Converter::NDAV(ptr)
+
+      assert_int_array ndav
+    end
+
+    def test_ndav_from_ffi_pointer
+      str = [1, 2, 3].pack("s*")
+      address = ::Fiddle::Pointer[str].to_i
+      ptr = ::FFI::Pointer.new(:int16, address)
+      ndav = ::NDAV::Converter::NDAV(ptr, shape: [3])
+
+      assert_int_array ndav
+    end
+  end
+end

data/test/test_ndav.rb

@@ -0,0 +1,31 @@
+require_relative "helper"
+
+class TestNDAV < TestBase
+  def setup
+    @array = Arrow::Int16Array.new([1, 2, 3])
+  end
+
+  def test_ndav
+    ndav = NDAV.new(@array)
+
+    assert_instance_of NDAV, ndav
+    assert_int_array ndav
+    assert_instance_of ::Fiddle::Pointer, ndav.to_ptr
+  end
+
+  def test_memory_view
+    ndav = NDAV.new(@array)
+    mv = Fiddle::MemoryView.new(ndav)
+
+    assert_int_array mv
+  end
+
+  def test_fiddle_pointer
+    ptr = Fiddle::Pointer[[1, 2, 3].pack("s*")]
+    ndav = NDAV.new(ptr, format: "s")
+
+    assert_equal ptr, ndav.to_ptr
+    assert_equal ptr, ndav.to_fiddle_pointer
+    assert_int_array ndav
+  end
+end

data/test/test_package.rb

@@ -0,0 +1,26 @@
+require_relative "helper"
+require "tempfile"
+require "tmpdir"
+
+class TestPackage < TestBase
+  def test_build
+    Tempfile.create do |file|
+      assert system("gem", "build", "ndav.gemspec", "--output", file.to_path, exception: true)
+      assert file.size > 0
+      assert_path_exist file
+    end
+  end
+
+  def test_install
+    gemspec = Gem::Specification.load("ndav.gemspec")
+    Dir.mktmpdir do |dir|
+      dir = File.realpath(dir)
+      gemfile = File.join(dir, gemspec.file_name)
+      system "gem", "build", "ndav.gemspec", "--output", gemfile, exception: true
+      install_dir = File.join(dir, "install")
+      FileUtils.mkdir install_dir
+      system "gem", "install", "--install-dir", install_dir, "--no-document", gemfile, exception: true
+      assert_path_exist File.join(install_dir, "extensions", Gem::Platform.local.to_s, RbConfig::CONFIG['ruby_version'], gemspec.full_name, "ndav.#{RbConfig::CONFIG["DLEXT"]}")
+    end
+  end
+end

metadata

@@ -0,0 +1,196 @@
+--- !ruby/object:Gem::Specification
+name: ndav
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kitaiti Makoto
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: fiddle
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit-notify
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit-rr
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-requirements-system
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: red-arrow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+executables: []
+extensions:
+- ext/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitlab-ci.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/extconf.rb
+- ext/ndav.c
+- ext/ndav.h
+- lib/ndav.rb
+- lib/ndav/converter.rb
+- lib/ndav/ffi.rb
+- ndav.gemspec
+- test/helper.rb
+- test/test_converter.rb
+- test/test_export.rb
+- test/test_ffi.rb
+- test/test_ndav.rb
+- test/test_package.rb
+licenses:
+- BSD-2-Clause
+metadata: {}
+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: 4.0.6
+specification_version: 4
+summary: N-Dimensional Array View
+test_files: []