edlib 0.0.5 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5c9cf154ed1668d991a4476b501981a245a9b758950699fcba36062f73d312dd
-  data.tar.gz: 716d869b8fc5dc870b9bbcdf3bfb2bceb99567b4e22197214cd99a948e850b86
+  metadata.gz: 72ca7381d858e17e8ba5e2641d072cb4f391410b97ef9138504efa6851020373
+  data.tar.gz: 180e15f4a09149af7031536817a635be580d55afd25896341cb44cf54a9902be
 SHA512:
-  metadata.gz: b32f9755d963c17fba0c1b76364f9969f3a84fdb5c5e123020b02733699b313ff4d46e6203956640ad795c5686b0d00ff914645cd68a711add89e9d8250430eb
-  data.tar.gz: a776f6b8c67c9f9a7f16440cd8630688f2bba4bca8822e2b76b32f4b6f2095cf31ce259dbc92b6ea923503403c135becd85a8e7e953caa52a4c51df16e2bcbfa
+  metadata.gz: 5f53003d5e12d9d55b40201f435a278b4a99d6e01569cf0f5e96a263822058257d3dd1b65c7c0f48d39a92177c271131d7752bf982c68893316e5dccbdeefc9f
+  data.tar.gz: 27e1ec9237c5f86fe8775100dbda7e2b9851071a9043cace94b927a65e372afa0b7cbbca741d51266b1f2a0493917eeaf1b4b60da92600def529b2e4ac724edb

data/README.md

@@ -2,6 +2,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/edlib.svg)](https://badge.fury.io/rb/edlib)
 [![test](https://github.com/kojix2/ruby-edlib/actions/workflows/ci.yml/badge.svg)](https://github.com/kojix2/ruby-edlib/actions/workflows/ci.yml)
+[![DOI](https://zenodo.org/badge/559318048.svg)](https://zenodo.org/badge/latestdoi/559318048)
 
 [Edlib](https://github.com/Martinsos/edlib) - A lightweight and super fast C/C++ library for sequence alignment using edit distance
 

data/ext/edlib/edlibext.c

@@ -1,70 +1,98 @@
 #include "ruby.h"
-#include "edlib.h"
+#include "edlibext.h"
+
+#define ALIGNER_GET_(name) \
+	static VALUE \
+	aligner_get_##name(VALUE self) \
+	{ \
+	    EdlibAlignConfig *config = aligner_get_config(self); \
+		return get_##name(config); \
+	}
+
+#define ALIGNER_SET_(name) \
+	static VALUE \
+	aligner_set_##name(VALUE self, VALUE value) \
+	{ \
+	    EdlibAlignConfig *config = aligner_get_config(self); \
+		return set_##name(config, value); \
+	}
 
 VALUE mEdlib;
 VALUE cAligner;
-EdlibEqualityPair *eqpairs;
 
-static size_t config_memsize(const void *ptr);
-static void config_free(void *ptr);
+// Aligner class
+
+static size_t aligner_config_memsize(const void *ptr);
+static void aligner_config_free(void *ptr);
 
 static const rb_data_type_t config_type = {
-	.wrap_struct_name = "EdlibAlignConfig",
+	.wrap_struct_name = "RbAlignConfig",
 	.function = {
-		.dfree = config_free,
-		.dsize = config_memsize,
+		.dfree = aligner_config_free,
+		.dsize = aligner_config_memsize,
 	},
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
 static VALUE
-config_allocate(VALUE klass)
+aligner_config_allocate(VALUE klass)
 {
-	EdlibAlignConfig *config;
-	VALUE obj = TypedData_Make_Struct(klass, EdlibAlignConfig,
-									  &config_type, config);
+	RbAlignConfig *aligner_config;
+
+	VALUE obj = TypedData_Make_Struct(klass, RbAlignConfig, &config_type, aligner_config);
+	aligner_config->config = (EdlibAlignConfig *)malloc(sizeof(EdlibAlignConfig));
+	aligner_config->equalityPairs = NULL;
 	return obj;
 }
 
 static void
-config_free(void *ptr)
+aligner_config_free(void *ptr)
 {
-	if (eqpairs != NULL)
+	RbAlignConfig *aligner_config = ptr;
+	if (aligner_config->config != NULL)
 	{
-		free(eqpairs);
-		eqpairs = NULL;
+		free(aligner_config->config);
+	}
+	if (aligner_config->equalityPairs != NULL)
+	{
+		free(aligner_config->equalityPairs);
 	}
-	xfree(ptr);
+
+	free(ptr);
 }
 
 static size_t
-config_memsize(const void *ptr)
+aligner_config_memsize(const void *ptr)
 {
-	const EdlibAlignConfig *config = ptr;
-	return sizeof(ptr) + 2 * sizeof(char) * (config->additionalEqualitiesLength);
+	const RbAlignConfig *aligner_config = ptr;
+	return sizeof(ptr) + sizeof(aligner_config->config) + 2 * sizeof(char) * aligner_config->config->additionalEqualitiesLength;
 }
 
 static EdlibAlignConfig *
-get_config(VALUE self)
+aligner_get_config(VALUE self)
 {
-	EdlibAlignConfig *ptr = NULL;
-	TypedData_Get_Struct(self, EdlibAlignConfig, &config_type, ptr);
+	RbAlignConfig *aligner_config = NULL;
+	TypedData_Get_Struct(self, RbAlignConfig, &config_type, aligner_config);
+	return aligner_config->config;
+}
 
-	return ptr;
+static EdlibEqualityPair *
+aligner_get_equalityPairs(VALUE self)
+{
+	RbAlignConfig *aligner_config = NULL;
+	TypedData_Get_Struct(self, RbAlignConfig, &config_type, aligner_config);
+	return aligner_config->equalityPairs;
 }
 
+// Config
+
 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);
-}
+ALIGNER_GET_(k)
 
 static VALUE
 set_k(EdlibAlignConfig *config, VALUE k)
@@ -73,35 +101,25 @@ set_k(EdlibAlignConfig *config, VALUE k)
 	return k;
 }
 
-static VALUE
-aligner_set_k(VALUE self, VALUE k)
-{
-	EdlibAlignConfig *config = get_config(self);
-	return set_k(config, k);
-}
+ALIGNER_SET_(k)
 
 static VALUE
 get_mode(EdlibAlignConfig *config)
 {
 	switch (config->mode)
 	{
-	case 0:
+	case EDLIB_MODE_NW:
 		return rb_str_new2("NW");
-	case 1:
+	case EDLIB_MODE_SHW:
 		return rb_str_new2("SHW");
-	case 2:
+	case EDLIB_MODE_HW:
 		return rb_str_new2("HW");
 	default:
 		return Qnil;
 	}
 }
 
-static VALUE
-aligner_get_mode(VALUE self)
-{
-	EdlibAlignConfig *config = get_config(self);
-	return get_mode(config);
-}
+ALIGNER_GET_(mode)
 
 static VALUE
 set_mode(EdlibAlignConfig *config, VALUE mode)
@@ -113,18 +131,19 @@ set_mode(EdlibAlignConfig *config, VALUE mode)
 	switch (TYPE(mode))
 	{
 	case T_STRING:;
-		rb_funcall(mode, rb_intern("upcase!"), 0);
-		if (strcmp(RSTRING_PTR(mode), "NW") == 0)
+	    VALUE mode_str = rb_funcall(mode, rb_intern("upcase"), 0);
+	    char *mode_s = RSTRING_PTR(mode_str);
+		if (strcmp(mode_s, "NW") == 0)
 		{
-			config->mode = 0;
+			config->mode = EDLIB_MODE_NW;
 		}
-		else if (strcmp(RSTRING_PTR(mode), "SHW") == 0)
+		else if (strcmp(mode_s, "SHW") == 0)
 		{
-			config->mode = 1;
+			config->mode = EDLIB_MODE_SHW;
 		}
-		else if (strcmp(RSTRING_PTR(mode), "HW") == 0)
+		else if (strcmp(mode_s, "HW") == 0)
 		{
-			config->mode = 2;
+			config->mode = EDLIB_MODE_HW;
 		}
 		else
 		{
@@ -145,35 +164,25 @@ set_mode(EdlibAlignConfig *config, VALUE mode)
 	return mode;
 }
 
-static VALUE
-aligner_set_mode(VALUE self, VALUE mode)
-{
-	EdlibAlignConfig *config = get_config(self);
-	return set_mode(config, mode);
-}
+ALIGNER_SET_(mode)
 
 static VALUE
 get_task(EdlibAlignConfig *config)
 {
 	switch (config->task)
 	{
-	case 0:
+	case EDLIB_TASK_DISTANCE:
 		return rb_str_new2("DISTANCE");
-	case 1:
+	case EDLIB_TASK_LOC:
 		return rb_str_new2("LOC");
-	case 2:
+	case EDLIB_TASK_PATH:
 		return rb_str_new2("PATH");
 	default:
 		return Qnil;
 	}
 }
 
-static VALUE
-aligner_get_task(VALUE self)
-{
-	EdlibAlignConfig *config = get_config(self);
-	return get_task(config);
-}
+ALIGNER_GET_(task)
 
 static VALUE
 set_task(EdlibAlignConfig *config, VALUE task)
@@ -185,18 +194,19 @@ set_task(EdlibAlignConfig *config, VALUE task)
 	switch (TYPE(task))
 	{
 	case T_STRING:;
-		rb_funcall(task, rb_intern("upcase!"), 0);
-		if (strcmp(RSTRING_PTR(task), "DISTANCE") == 0)
+		VALUE task_str = rb_funcall(task, rb_intern("upcase"), 0);
+		char *task_s = RSTRING_PTR(task_str);
+		if (strcmp(task_s, "DISTANCE") == 0)
 		{
-			config->task = 0;
+			config->task = EDLIB_TASK_DISTANCE;
 		}
-		else if (strcmp(RSTRING_PTR(task), "LOC") == 0)
+		else if (strcmp(task_s, "LOC") == 0)
 		{
-			config->task = 1;
+			config->task = EDLIB_TASK_LOC;
 		}
-		else if (strcmp(RSTRING_PTR(task), "PATH") == 0)
+		else if (strcmp(task_s, "PATH") == 0)
 		{
-			config->task = 2;
+			config->task = EDLIB_TASK_PATH;
 		}
 		else
 		{
@@ -217,12 +227,7 @@ set_task(EdlibAlignConfig *config, VALUE task)
 	return task;
 }
 
-static VALUE
-aligner_set_task(VALUE self, VALUE task)
-{
-	EdlibAlignConfig *config = get_config(self);
-	return set_task(config, task);
-}
+ALIGNER_SET_(task)
 
 static VALUE
 get_additional_equalities(EdlibAlignConfig *config)
@@ -241,21 +246,17 @@ get_additional_equalities(EdlibAlignConfig *config)
 	return equalities;
 }
 
-static VALUE
-aligner_get_additional_equalities(VALUE self)
-{
-	EdlibAlignConfig *config = get_config(self);
-	return get_additional_equalities(config);
-}
+ALIGNER_GET_(additional_equalities)
 
 static VALUE
-set_additional_equalities(EdlibAlignConfig *config, VALUE equalities)
+set_additional_equalities(EdlibAlignConfig *config, EdlibEqualityPair *eqpairs, VALUE equalities)
 {
 	Check_Type(equalities, T_ARRAY);
 	int len = RARRAY_LEN(equalities);
 	if (len == 0)
 	{
-		if(eqpairs != NULL) {
+		if (eqpairs != NULL)
+		{
 			free(eqpairs);
 			eqpairs = NULL;
 		}
@@ -312,14 +313,15 @@ set_additional_equalities(EdlibAlignConfig *config, VALUE equalities)
 static VALUE
 aligner_set_additional_equalities(VALUE self, VALUE equalities)
 {
-	EdlibAlignConfig *config = get_config(self);
-	return set_additional_equalities(config, equalities);
+	EdlibAlignConfig *config = aligner_get_config(self);
+	EdlibEqualityPair *eqpairs = aligner_get_equalityPairs(self);
+	return set_additional_equalities(config, eqpairs, equalities);
 }
 
 static VALUE
 aligner_config_hash(VALUE self)
 {
-	EdlibAlignConfig *config = get_config(self);
+	EdlibAlignConfig *config = aligner_get_config(self);
 
 	VALUE hash = rb_hash_new();
 
@@ -332,16 +334,17 @@ aligner_config_hash(VALUE self)
 }
 
 static VALUE
-aligner_initialize(VALUE self, VALUE k, VALUE mode, VALUE task, VALUE additional_equalities)
+aligner_initialize_raw(VALUE self, VALUE k, VALUE mode, VALUE task, VALUE additional_equalities)
 {
-	EdlibAlignConfig *config = get_config(self);
-
+	EdlibAlignConfig *config = aligner_get_config(self);
+	EdlibEqualityPair *eqpairs = aligner_get_equalityPairs(self);
 	config->k = NUM2INT(k);
 	set_mode(config, mode);
 	set_task(config, task);
+	
 	if (additional_equalities != Qnil)
 	{
-		set_additional_equalities(config, additional_equalities);
+		set_additional_equalities(config, eqpairs, additional_equalities);
 	}
 	else
 	{
@@ -355,7 +358,7 @@ aligner_initialize(VALUE self, VALUE k, VALUE mode, VALUE task, VALUE additional
 static VALUE
 aligner_align(VALUE self, VALUE query, VALUE target)
 {
-	EdlibAlignConfig *config = get_config(self);
+	EdlibAlignConfig *config = aligner_get_config(self);
 	if (!config)
 	{
 		rb_raise(rb_eRuntimeError, "config is NULL");
@@ -427,8 +430,8 @@ void Init_edlibext(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_alloc_func(cAligner, aligner_config_allocate);
+	rb_define_private_method(cAligner, "initialize_raw", aligner_initialize_raw, 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);
@@ -438,5 +441,5 @@ void Init_edlibext(void)
 	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);
+	rb_define_method(cAligner, "align_raw", aligner_align, 2);
 }

data/ext/edlib/edlibext.h

@@ -0,0 +1,15 @@
+#ifndef EDLIBEXT_H
+#define EDLIBEXT_H
+
+#include "edlib.h"
+
+typedef struct
+{
+    EdlibAlignConfig *config;
+    EdlibEqualityPair *equalityPairs;
+} RbAlignConfig;
+
+static EdlibAlignConfig *aligner_get_config(VALUE self);
+static EdlibEqualityPair *aligner_get_equalityPairs(VALUE self);
+
+#endif // EDLIBEXT_H

data/ext/edlib/extconf.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mkmf'
 
 create_makefile('edlib/edlibext')

data/lib/edlib/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Edlib
-  VERSION = '0.0.5'
+  VERSION = '0.0.7'
 end

data/lib/edlib.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'edlib/edlibext'
 
 module Edlib
@@ -9,5 +11,68 @@ module Edlib
       task = task.upcase if task.is_a? String
       initialize_raw(k, mode, task, additional_equalities)
     end
+
+    def align(query, target, nice: false)
+      if nice
+        align_nice(query, target)
+      else
+        align_raw(query, target)
+      end
+    end
+
+    private
+
+    def align_nice(query, target)
+      result = align(query, target)
+      result.merge(nice(result, query, target))
+    end
+
+    def nice(result, query, target, gap_symbol: '-')
+      raise 'result does not have :locations and :cigar' unless result.key?(:locations) && result.key?(:cigar)
+
+      target_pos = result[:locations][0][0]
+      query_pos = 0
+      query_aln = String.new
+      match_aln = String.new
+      target_aln = String.new
+      cigar = result[:cigar]
+      cigar.scan(/(\d+)(\D)/).each do |num, op|
+        num = num.to_i
+        case op
+        when '='
+          target_aln << target[target_pos, num]
+          target_pos += num
+          query_aln << query[query_pos, num]
+          query_pos += num
+          match_aln << '|' * num
+        when 'X'
+          target_aln << target[target_pos, num]
+          target_pos += num
+          query_aln << query[query_pos, num]
+          query_pos += num
+          match_aln << '.' * num
+        when 'D'
+          target_aln << target[target_pos, num]
+          target_pos += num
+          query_aln << gap_symbol * num
+          query_pos += 0
+          match_aln << gap_symbol * num
+        when 'I'
+          target_aln << gap_symbol * num
+          target_pos += 0
+          query_aln << query[query_pos, num]
+          query_pos += num
+          match_aln << gap_symbol * num
+        else
+          raise "Unknown CIGAR operation: #{op}"
+        end
+      end
+
+      {
+        query_aligned: query_aln,
+        match_aligned: match_aln,
+        target_aligned: target_aln
+      }
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: edlib
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.7
 platform: ruby
 authors:
 - kojix2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-10-31 00:00:00.000000000 Z
+date: 2022-11-07 00:00:00.000000000 Z
 dependencies: []
 description: 'Lightweight, super fast C/C++ library for sequence alignment using edit
   (Levenshtein) distance. '
@@ -23,6 +23,7 @@ files:
 - ext/edlib/edlib.cpp
 - ext/edlib/edlib.h
 - ext/edlib/edlibext.c
+- ext/edlib/edlibext.h
 - ext/edlib/extconf.rb
 - lib/edlib.rb
 - lib/edlib/version.rb