mmapper 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 624fb225f474ed8da83938adf19dd4e1a3727c8c4c0660d316f6896f620ca5d1
-  data.tar.gz: 97607d8736e460e4f788efde73cd35652b5abe850a8dfcc0accfaf68ab29ede1
+  metadata.gz: 6bd38094ddc8cb154aea8cded45f5775c2b4bc873dbf037c805230635332ee23
+  data.tar.gz: c19ed16231032e3e11e82723aed9fca20c8d0d51b2a0c5054ec4b8ddf88ceffe
 SHA512:
-  metadata.gz: a91ef5d57628aa47c30b5b0dd4957d41373440b7691792baa93647e57b279bcb2d466ce63f24f43285b6f93e0c711fcac882e6b54e2ebf8ddd5c043a8604a3d7
-  data.tar.gz: a5e0e6825d701945192923dadabbe87984a04aa2a3e74031a4e5d183abfd0f43619e531e585422416fea6711e4535e562be813b657f1fc0017fd82a0808a6726
+  metadata.gz: 6d485802f03e104bbfaccd82c2b7e7efa0ee332dd95f41962b1a41558f4fcbe5484c8c0c50ff583d84e1e92a535ae1f51740c53bd0207b98645153b60ad8f094
+  data.tar.gz: e520f6a7f6ca6f718fa02093563a7752f5afd2e15525f63fbfbd2d4fb065ced6539c133e25ab6887aac5863169118eb8fa6e9a98bc66d174dc728c28cd712286

data/ext/extconf.rb

@@ -1,29 +1,3 @@
 require 'mkmf'
-require 'fileutils'
 
-LIB_DIR = File.expand_path(File.dirname(__FILE__))
-
-# Detect OS and set correct library name
-LIB_NAME =
-  case RUBY_PLATFORM
-  when /darwin/ then "libmmapper.dylib"
-  when /mingw|mswin/ then "mmapper.dll"
-  else "libmmapper.so"
-  end
-
-LIB_PATH = File.join(LIB_DIR, LIB_NAME)
-
-# Ensure Go module is initialized
-Dir.chdir(LIB_DIR) do
-  unless File.exist?("go.mod")
-    puts "Initializing Go module..."
-    system("go mod init mmapper") || raise("Failed to initialize Go module")
-  end
-
-  puts "Building Go shared library for #{RUBY_PLATFORM}..."
-  unless system("go build -o #{LIB_NAME} -buildmode=c-shared .")
-    raise "Go build failed!"
-  end
-end
-
-create_makefile('mmapper')
+create_makefile('mmapper/mmapper')

data/ext/mmapper.c

@@ -0,0 +1,98 @@
+#include "ruby.h"
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+typedef struct {
+  int fd;
+  size_t size;
+  void *map;
+} mmap_file;
+
+static VALUE cMmapFile;
+
+static void mmap_file_free(void *ptr) {
+  mmap_file *m = (mmap_file *)ptr;
+  if (m->map)
+    munmap(m->map, m->size);
+  if (m->fd >= 0)
+    close(m->fd);
+  free(m);
+}
+
+static VALUE mmap_file_alloc(VALUE klass) {
+  mmap_file *m = ALLOC(mmap_file);
+  m->fd = -1;
+  m->map = NULL;
+  m->size = 0;
+  return Data_Wrap_Struct(klass, NULL, mmap_file_free, m);
+}
+
+static VALUE mmap_file_initialize(VALUE self, VALUE path) {
+  mmap_file *m;
+  const char *c_path = StringValueCStr(path);
+  Data_Get_Struct(self, mmap_file, m);
+
+  m->fd = open(c_path, O_RDWR);
+  if (m->fd < 0)
+    rb_sys_fail("open");
+
+  m->size = lseek(m->fd, 0, SEEK_END);
+  lseek(m->fd, 0, SEEK_SET);
+
+  m->map = mmap(NULL, m->size, PROT_READ | PROT_WRITE, MAP_SHARED, m->fd, 0);
+  if (m->map == MAP_FAILED)
+    rb_sys_fail("mmap");
+
+  return self;
+}
+
+static VALUE mmap_file_read(VALUE self, VALUE offset_val, VALUE length_val) {
+  mmap_file *m;
+  Data_Get_Struct(self, mmap_file, m);
+
+  long offset = NUM2LONG(offset_val);
+  long length = NUM2LONG(length_val);
+
+  if (offset < 0 || offset + length > (long)m->size)
+    rb_raise(rb_eArgError, "read out of bounds");
+
+  return rb_str_new((char *)m->map + offset, length);
+}
+
+static VALUE mmap_file_write(VALUE self, VALUE offset_val, VALUE str_val) {
+  mmap_file *m;
+  Data_Get_Struct(self, mmap_file, m);
+
+  long offset = NUM2LONG(offset_val);
+  StringValue(str_val);
+  long len = RSTRING_LEN(str_val);
+
+  if (offset < 0 || offset + len > (long)m->size)
+    rb_raise(rb_eArgError, "write out of bounds");
+
+  memcpy((char *)m->map + offset, RSTRING_PTR(str_val), len);
+  msync(m->map, m->size, MS_SYNC);
+
+  return Qtrue;
+}
+
+static VALUE mmap_file_size(VALUE self) {
+  mmap_file *m;
+  Data_Get_Struct(self, mmap_file, m);
+  return LONG2NUM(m->size);
+}
+
+void Init_mmapper(void) {
+  VALUE mMmapper = rb_define_module("Mmapper");
+  cMmapFile = rb_define_class_under(mMmapper, "File", rb_cObject);
+
+  rb_define_alloc_func(cMmapFile, mmap_file_alloc);
+  rb_define_method(cMmapFile, "initialize", mmap_file_initialize, 1);
+  rb_define_method(cMmapFile, "read", mmap_file_read, 2);
+  rb_define_method(cMmapFile, "write", mmap_file_write, 2);
+  rb_define_method(cMmapFile, "size", mmap_file_size, 0);
+}

data/lib/mmapper.rb

@@ -1,45 +1,61 @@
-require 'ffi'
+require 'mmapper/mmapper'
 
 module Mmapper
-  extend FFI::Library
-
-  LIB_DIR = File.expand_path("../../ext", __FILE__)
+  class File
+    def find_matching_line(prefix)
+      low = 0
+      high = size
 
-  LIB_NAME =
-    case RUBY_PLATFORM
-    when /darwin/ then "libmmapper.dylib"
-    when /mingw|mswin/ then "mmapper.dll"
-    else "libmmapper.so"
-    end
+      while low < high
+        mid = (low + high) / 2
+        line_start = find_line_start(mid)
+        line = read_line_at(line_start)
 
-  LIB_PATH = File.join(LIB_DIR, LIB_NAME)
+        return nil if line.nil?
 
-  unless File.exist?(LIB_PATH)
-    Dir.chdir(LIB_DIR) do
-      puts "Compiling Go shared library for #{RUBY_PLATFORM}..."
-      system("go build -o #{LIB_NAME} -buildmode=c-shared .") || raise("Go build failed")
-    end
-  end
+        if line < prefix
+          low = mid + 1
+        else
+          high = mid
+        end
 
-  ffi_lib LIB_PATH
+      end
 
-  attach_function :create_mmapper, :CreateMmapper, [:string], :int
-  attach_function :find_matching_line, :FindMatchingLine, [:int, :string], :string
+      final_line_start = find_line_start(low)
+      line = read_line_at(final_line_start)
 
-  class Instance
-    def initialize(filename)
-      @mmapper_id = Mmapper.create_mmapper(filename)
-      raise "Failed to load file: #{filename}" if @mmapper_id < 0
+      if line&.start_with?(prefix)
+        line
+      else
+        nil
+      end
     end
 
-    def find_matching_line(prefix)
-      result = Mmapper.find_matching_line(@mmapper_id, prefix)
-      return nil if result.nil? || result.empty?
-      result
+    private
+
+    def find_line_start(pos)
+      pos = [pos, size - 1].min
+      pos -= 1 while pos > 0 && read(pos, 1) != "\n"
+      pos += 1 if pos != 0
+      pos
     end
-  end
 
-  def self.load_file(filename)
-    Instance.new(filename)
+    def read_line_at(pos)
+      buf = +''
+      chunk_size = 64
+      while pos < size
+        safe_len = [size - pos, chunk_size].min
+        chunk = read(pos, safe_len)
+        newline_idx = chunk.index("\n")
+        if newline_idx
+          buf << chunk[0..newline_idx]
+          break
+        else
+          buf << chunk
+          pos += chunk_size
+        end
+      end
+      buf.empty? ? nil : buf.chomp
+    end
   end
 end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: mmapper
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Carl Dawson
 bindir: bin
 cert_chain: []
-date: 2025-01-31 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: Wraps a Go extension for mmap-ing files.
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Wraps a C extension for mmap-ing files.
 email:
 - email@carldaws.com
 executables: []
@@ -33,7 +19,7 @@ extra_rdoc_files: []
 files:
 - README.md
 - ext/extconf.rb
-- ext/mmap.go
+- ext/mmapper.c
 - lib/mmapper.rb
 homepage: https://github.com/carldaws/mmapper
 licenses:
@@ -53,7 +39,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.6.7
 specification_version: 4
-summary: Mmap-ed files using Go and FFI.
+summary: Mmap-ed files in Ruby using a C native extension
 test_files: []

data/ext/mmap.go

@@ -1,127 +0,0 @@
-package main
-
-/*
-#include <stdlib.h>
-*/
-import "C"
-
-import (
-	"bytes"
-	"os"
-	"sync"
-	"syscall"
-)
-
-// Mmapper holds the mmap data for a file
-type Mmapper struct {
-	mmapData []byte
-	fileSize int
-}
-
-// Store instances
-var (
-	mu        sync.Mutex
-	mmappers  = make(map[int]*Mmapper)
-	nextID    = 1
-)
-
-// mmapFile maps a file into memory.
-func mmapFile(filename string) (*Mmapper, error) {
-	file, err := os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-	defer file.Close()
-
-	fi, err := file.Stat()
-	if err != nil {
-		return nil, err
-	}
-
-	size := fi.Size()
-	if size == 0 {
-		return nil, os.ErrInvalid
-	}
-
-	data, err := syscall.Mmap(int(file.Fd()), 0, int(size), syscall.PROT_READ, syscall.MAP_SHARED)
-	if err != nil {
-		return nil, err
-	}
-
-	return &Mmapper{mmapData: data, fileSize: int(size)}, nil
-}
-
-// findLineStart moves backward to find the start of a line.
-func findLineStart(data []byte, pos int) int {
-	for pos > 0 && data[pos-1] != '\n' {
-		pos--
-	}
-	return pos
-}
-
-// readLine reads a full line starting from a given position.
-func readLine(data []byte, start int, fileSize int) string {
-	end := start
-	for end < fileSize && data[end] != '\n' {
-		end++
-	}
-	return string(data[start:end])
-}
-
-// binarySearchPrefix performs a binary search for a prefix.
-func binarySearchPrefix(m *Mmapper, prefix string) string {
-	low, high := 0, m.fileSize-1
-	var match string
-
-	for low <= high {
-		mid := (low + high) / 2
-		mid = findLineStart(m.mmapData, mid)
-
-		line := readLine(m.mmapData, mid, m.fileSize)
-		if bytes.HasPrefix([]byte(line), []byte(prefix)) {
-			match = line
-			high = mid - 1
-		} else if line < prefix {
-			low = mid + len(line) + 1
-		} else {
-			high = mid - 1
-		}
-	}
-	return match
-}
-
-//export CreateMmapper
-func CreateMmapper(filename *C.char) C.int {
-	m, err := mmapFile(C.GoString(filename))
-	if err != nil {
-		return -1 // Error case
-	}
-
-	mu.Lock()
-	id := nextID
-	nextID++
-	mmappers[id] = m
-	mu.Unlock()
-
-	return C.int(id)
-}
-
-//export FindMatchingLine
-func FindMatchingLine(mmapperID C.int, prefix *C.char) *C.char {
-	mu.Lock()
-	m, exists := mmappers[int(mmapperID)]
-	mu.Unlock()
-
-	if !exists {
-		return nil
-	}
-
-	match := binarySearchPrefix(m, C.GoString(prefix))
-	if match == "" {
-		return nil
-	}
-
-	return C.CString(match)
-}
-
-func main() {}