edlib 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ad1a2f931b436577baac1923b324837f50aa133efbe48843f0956711b6e3fe4c
+  data.tar.gz: 62c9924efcf428902528e6ce29e1be6d7d874bd5db406b29bdeee00b3491e800
+SHA512:
+  metadata.gz: ca119f2d471a21d8cb8da7820d2a1723396040d8a62c18c4cbcdb9b7c8879ed7a8792d57193e110a122c3b9d2d5b883aeab869cdc7d465e4aeec687c23896c5d
+  data.tar.gz: 596c89f8fe1112bb876edfb89849d6f634b4aa1d84ea3f47a6a24dbdb78070f86f063a0d38ef5aaccc4e4ea66edfd5d9c699ccb778dcf0f8812794018be944e7

data/README.md

@@ -0,0 +1,39 @@
+# ruby-edlib
+
+[Edlib](https://github.com/Martinsos/edlib) - A lightweight and super fast C/C++ library for sequence alignment using edit distance
+
+## Installation
+
+```
+sudo apt install edlib-dev
+gem install edlib
+```
+
+## API
+
+```ruby
+require "edlib"
+
+a = Edlib::Aligner.new(mode: :hw, task: :path)
+a.align("AACG", "TCAACCTG")
+# => {:edit_distance=>1, :alphabet_length=>4, :locations=>[[2, 4], [2, 5]], :alignment=>[0, 0, 0, 1], :cigar=>"3=1I"}
+```
+
+|keyword argument     |description|
+|---------------------|-----------------------------------------------------------------------------|
+|k                    |edit distance is not larger than k [-1]                                             |
+|mode                 |global (NW) , prefix (SHW) , infix (HW) ["NW"]                                      |
+|task                 |DISTANCE, LOC, PATH ["DISTANCE"]                                                    |
+|additional_equalities|List of pairs of characters, where each pair defines two characters as equal. [NULL]|
+
+## Development
+
+* Pull requests welcome
+
+```sh
+git clone https://github.com/kojix2/ruby-edlib # Please fork repo
+cd ruby-edlib
+bundle install
+bundle exec rake compile
+bundle exec rake test
+```

data/ext/edlib/edlib.c

@@ -0,0 +1,400 @@
+#include "ruby.h"
+#include "edlib.h"
+
+VALUE mEdlib;
+VALUE cAligner;
+
+static size_t config_memsize(const void *ptr);
+
+static const rb_data_type_t config_type = {
+	.wrap_struct_name = "EdlibAlignConfig",
+	.function = {
+		.dfree = RUBY_DEFAULT_FREE,
+		.dsize = config_memsize,
+	},
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE
+config_allocate(VALUE klass)
+{
+	EdlibAlignConfig *config;
+	VALUE obj = TypedData_Make_Struct(klass, EdlibAlignConfig,
+									  &config_type, config);
+	return obj;
+}
+
+static size_t
+config_memsize(const void *ptr)
+{
+	const EdlibAlignConfig *config = ptr;
+	return sizeof(ptr) + 2 * sizeof(char) * (config->additionalEqualitiesLength);
+}
+
+static EdlibAlignConfig *get_config(VALUE self)
+{
+	EdlibAlignConfig *ptr = NULL;
+	TypedData_Get_Struct(self, EdlibAlignConfig, &config_type, ptr);
+
+	return ptr;
+}
+
+static VALUE
+get_k(EdlibAlignConfig *config)
+{
+	return INT2NUM(config->k);
+}
+
+static VALUE
+aligner_get_k(VALUE self)
+{
+	EdlibAlignConfig *config = get_config(self);
+	return get_k(config);
+}
+
+static VALUE
+set_k(EdlibAlignConfig *config, VALUE k)
+{
+	config->k = NUM2INT(k);
+	return k;
+}
+
+static VALUE
+aligner_set_k(VALUE self, VALUE k)
+{
+	EdlibAlignConfig *config = get_config(self);
+	return set_k(config, k);
+}
+
+static VALUE
+get_mode(EdlibAlignConfig *config)
+{
+	switch (config->mode)
+	{
+	case 0:
+		return rb_str_new2("NW");
+	case 1:
+		return rb_str_new2("SHW");
+	case 2:
+		return rb_str_new2("HW");
+	default:
+		return Qnil;
+	}
+}
+
+static VALUE
+aligner_get_mode(VALUE self)
+{
+	EdlibAlignConfig *config = get_config(self);
+	return get_mode(config);
+}
+
+static VALUE
+set_mode(EdlibAlignConfig *config, VALUE mode)
+{
+	switch (TYPE(mode))
+	{
+	case T_STRING:
+		if (strcmp(RSTRING_PTR(mode), "NW") == 0)
+		{
+			config->mode = 0;
+		}
+		else if (strcmp(RSTRING_PTR(mode), "SHW") == 0)
+		{
+			config->mode = 1;
+		}
+		else if (strcmp(RSTRING_PTR(mode), "HW") == 0)
+		{
+			config->mode = 2;
+		}
+		else
+		{
+			rb_raise(rb_eArgError, "Invalid mode");
+		}
+		break;
+	case T_FIXNUM:;
+		int m = NUM2INT(mode);
+		if (m < 0 || m > 2)
+		{
+			rb_raise(rb_eArgError, "Invalid mode");
+		}
+		config->mode = NUM2INT(mode);
+		break;
+	default:
+		rb_raise(rb_eArgError, "Invalid mode");
+	}
+	return mode;
+}
+
+static VALUE
+aligner_set_mode(VALUE self, VALUE mode)
+{
+	EdlibAlignConfig *config = get_config(self);
+	return set_mode(config, mode);
+}
+
+static VALUE
+get_task(EdlibAlignConfig *config)
+{
+	switch (config->task)
+	{
+	case 0:
+		return rb_str_new2("DISTANCE");
+	case 1:
+		return rb_str_new2("LOC");
+	case 2:
+		return rb_str_new2("PATH");
+	default:
+		return Qnil;
+	}
+}
+
+static VALUE
+aligner_get_task(VALUE self)
+{
+	EdlibAlignConfig *config = get_config(self);
+	return get_task(config);
+}
+
+static VALUE
+set_task(EdlibAlignConfig *config, VALUE task)
+{
+	switch (TYPE(task))
+	{
+	case T_STRING:
+		if (strcmp(RSTRING_PTR(task), "DISTANCE") == 0)
+		{
+			config->task = 0;
+		}
+		else if (strcmp(RSTRING_PTR(task), "LOC") == 0)
+		{
+			config->task = 1;
+		}
+		else if (strcmp(RSTRING_PTR(task), "PATH") == 0)
+		{
+			config->task = 2;
+		}
+		else
+		{
+			rb_raise(rb_eArgError, "Invalid task");
+		}
+		break;
+	case T_FIXNUM:;
+		int t = NUM2INT(task);
+		if (t < 0 || t > 2)
+		{
+			rb_raise(rb_eArgError, "Invalid task");
+		}
+		config->task = NUM2INT(task);
+		break;
+	default:
+		rb_raise(rb_eArgError, "Invalid task");
+	}
+	return task;
+}
+
+static VALUE
+aligner_set_task(VALUE self, VALUE task)
+{
+	EdlibAlignConfig *config = get_config(self);
+	return set_task(config, task);
+}
+
+static VALUE
+get_additional_equalities(EdlibAlignConfig *config)
+{
+	VALUE equalities = rb_ary_new();
+
+	for (int i = 0; i < config->additionalEqualitiesLength; i++)
+	{
+		EdlibEqualityPair pair = config->additionalEqualities[i];
+		VALUE pair_ary = rb_ary_new();
+		rb_ary_push(pair_ary, rb_str_new(&pair.first, 1));
+		rb_ary_push(pair_ary, rb_str_new(&pair.second, 1));
+		rb_ary_push(equalities, pair_ary);
+	}
+
+	return equalities;
+}
+
+static VALUE
+aligner_get_additional_equalities(VALUE self)
+{
+	EdlibAlignConfig *config = get_config(self);
+	return get_additional_equalities(config);
+}
+
+static VALUE
+set_additional_equalities(EdlibAlignConfig *config, VALUE equalities)
+{
+	Check_Type(equalities, T_ARRAY);
+	EdlibEqualityPair *pairs = (EdlibEqualityPair *)malloc(sizeof(EdlibEqualityPair) * RARRAY_LEN(equalities));
+
+	for (int i = 0; i < RARRAY_LEN(equalities); i++)
+	{
+		VALUE pair = rb_ary_entry(equalities, i);
+		Check_Type(pair, T_ARRAY);
+		if (RARRAY_LEN(pair) != 2)
+		{
+			rb_raise(rb_eArgError, "Invalid equality pair");
+		}
+		VALUE s1 = rb_ary_entry(pair, 0);
+		VALUE s2 = rb_ary_entry(pair, 1);
+		Check_Type(s1, T_STRING);
+		Check_Type(s2, T_STRING);
+		if (RSTRING_LEN(s1) != 1 || RSTRING_LEN(s2) != 1)
+		{
+			rb_raise(rb_eArgError, "String length must be 1");
+		}
+		char c1 = RSTRING_PTR(s1)[0];
+		char c2 = RSTRING_PTR(s2)[0];
+
+		pairs[i].first = c1;
+		pairs[i].second = c2;
+	}
+
+	config->additionalEqualities = pairs;
+	free(pairs);
+
+	config->additionalEqualitiesLength = RARRAY_LEN(equalities);
+
+	return equalities;
+}
+
+static VALUE
+aligner_set_additional_equalities(VALUE self, VALUE equalities)
+{
+	EdlibAlignConfig *config = get_config(self);
+	return set_additional_equalities(config, equalities);
+}
+
+static VALUE
+aligner_config_hash(VALUE self)
+{
+	EdlibAlignConfig *config = get_config(self);
+
+	VALUE hash = rb_hash_new();
+
+	rb_hash_aset(hash, ID2SYM(rb_intern("k")), get_k(config));
+	rb_hash_aset(hash, ID2SYM(rb_intern("mode")), get_mode(config));
+	rb_hash_aset(hash, ID2SYM(rb_intern("task")), get_task(config));
+	rb_hash_aset(hash, ID2SYM(rb_intern("additional_equalities")), get_additional_equalities(config));
+
+	return hash;
+}
+
+static VALUE
+aligner_initialize(VALUE self, VALUE k, VALUE mode, VALUE task, VALUE additional_equalities)
+{
+	EdlibAlignConfig *config = get_config(self);
+
+	config->k = NUM2INT(k);
+	set_mode(config, mode);
+	set_task(config, task);
+	if (additional_equalities != Qnil)
+	{
+		set_additional_equalities(config, additional_equalities);
+	}
+	else
+	{
+		config->additionalEqualities = NULL;
+		config->additionalEqualitiesLength = 0;
+	}
+
+	return self;
+}
+
+static VALUE
+aligner_align(VALUE self, VALUE query, VALUE target)
+{
+	EdlibAlignConfig *config = get_config(self);
+	if (!config)
+	{
+		rb_raise(rb_eRuntimeError, "config is NULL");
+	}
+	EdlibAlignConfig cfg = edlibNewAlignConfig(
+		config->k,
+		config->mode,
+		config->task,
+		config->additionalEqualities,
+		config->additionalEqualitiesLength);
+
+	EdlibAlignResult result = edlibAlign(
+		StringValueCStr(query),
+		RSTRING_LEN(query),
+		StringValueCStr(target),
+		RSTRING_LEN(target),
+		cfg);
+
+	if (result.status != 0)
+	{
+		rb_raise(rb_eRuntimeError, "edlibAlign failed");
+	}
+
+	VALUE edit_distance = INT2NUM(result.editDistance);
+	VALUE alphabet_length = INT2NUM(result.alphabetLength);
+	VALUE locations = rb_ary_new();
+	VALUE alignment = rb_ary_new();
+	VALUE cigar;
+
+	int *el = result.endLocations;
+	int *sl = result.startLocations;
+	for (int i = 0; i < result.numLocations; i++)
+	{
+		VALUE ary = rb_ary_new();
+		if (sl)
+		{
+			rb_ary_push(ary, INT2NUM(sl[i]));
+		}
+		else
+		{
+			rb_ary_push(ary, Qnil);
+		}
+		if (el)
+		{
+			rb_ary_push(ary, INT2NUM(el[i]));
+		}
+		else
+		{
+			rb_ary_push(ary, Qnil);
+		}
+		rb_ary_push(locations, ary);
+	}
+
+	for (int i = 0; i < result.alignmentLength; i++)
+	{
+		rb_ary_push(alignment, UINT2NUM(result.alignment[i]));
+	}
+
+	char *ccigar = edlibAlignmentToCigar(result.alignment, result.alignmentLength, 1); // EDLIB_CIGAR_EXTENDED
+	cigar = rb_str_new2(ccigar);
+
+	VALUE hash = rb_hash_new();
+	rb_hash_aset(hash, ID2SYM(rb_intern("edit_distance")), edit_distance);
+	rb_hash_aset(hash, ID2SYM(rb_intern("alphabet_length")), alphabet_length);
+	rb_hash_aset(hash, ID2SYM(rb_intern("locations")), locations);
+	rb_hash_aset(hash, ID2SYM(rb_intern("alignment")), alignment);
+	rb_hash_aset(hash, ID2SYM(rb_intern("cigar")), cigar);
+
+	edlibFreeAlignResult(result);
+
+	return hash;
+}
+
+void Init_edlib(void)
+{
+	mEdlib = rb_define_module("Edlib");
+	cAligner = rb_define_class_under(mEdlib, "Aligner", rb_cObject);
+	rb_define_alloc_func(cAligner, config_allocate);
+	rb_define_private_method(cAligner, "initialize_raw", aligner_initialize, 4);
+	rb_define_method(cAligner, "k", aligner_get_k, 0);
+	rb_define_method(cAligner, "k=", aligner_set_k, 1);
+	rb_define_method(cAligner, "mode", aligner_get_mode, 0);
+	rb_define_method(cAligner, "mode=", aligner_set_mode, 1);
+	rb_define_method(cAligner, "task", aligner_get_task, 0);
+	rb_define_method(cAligner, "task=", aligner_set_task, 1);
+	rb_define_method(cAligner, "additional_equalities", aligner_get_additional_equalities, 0);
+	rb_define_method(cAligner, "additional_equalities=", aligner_set_additional_equalities, 1);
+	rb_define_method(cAligner, "config", aligner_config_hash, 0);
+	rb_define_method(cAligner, "align", aligner_align, 2);
+}

data/ext/edlib/extconf.rb

@@ -0,0 +1,6 @@
+require "mkmf"
+
+dir_config('edlib')
+if have_header('edlib.h') and have_library('edlib')
+  create_makefile('edlib/edlib')
+end

data/lib/edlib/version.rb

@@ -0,0 +1,3 @@
+module Edlib
+  VERSION = "0.0.1"
+end

data/lib/edlib.rb

@@ -0,0 +1,13 @@
+require_relative 'edlib/edlib'
+
+module Edlib
+  class Aligner
+    def initialize(k:-1, mode: 'NW', task: 'DISTANCE', additional_equalities: nil)
+      mode = mode.to_s if mode.is_a? Symbol
+      task = task.to_s if task.is_a? Symbol
+      mode = mode.upcase if mode.is_a? String
+      task = task.upcase if task.is_a? String
+      initialize_raw(k, mode, task, additional_equalities)
+    end
+  end
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: edlib
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- kojix2
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-10-30 00:00:00.000000000 Z
+dependencies: []
+description: 'Lightweight, super fast C/C++ library for sequence alignment using edit
+  (Levenshtein) distance. '
+email:
+- 2xijok@gmail.com
+executables: []
+extensions:
+- ext/edlib/extconf.rb
+extra_rdoc_files: []
+files:
+- README.md
+- ext/edlib/edlib.c
+- ext/edlib/extconf.rb
+- lib/edlib.rb
+- lib/edlib/version.rb
+homepage: https://github.com/kojix2/ruby-edlib
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.7
+signing_key: 
+specification_version: 4
+summary: ruby-edlib is a wrapper for edlib.
+test_files: []