edlib 0.0.6 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 41a9c8bdf279436f3ca2da4840a62d875c62ab5630c0411c7751446dd7c6db48
-  data.tar.gz: 62436d4433d308d71e76ec5095a57d85c1da88a3a6addf1531cb00e65ed37d72
+  metadata.gz: b4014e8ff49033ae36755f0752dba89486afc104ad67cf528358a3e1d12d2cfd
+  data.tar.gz: 4241313686e900f0d5751f10375f5afc347208737f66d19830c8b89add5e02f0
 SHA512:
-  metadata.gz: 9afed6c6ab4e8a59906a98441c464f093ad45a4b92464b0efba67166d925cf0243e4e484b063264940a2afb4867a181deb7dc55733cfb8ae0f082b472f47f286
-  data.tar.gz: c472407d2aa613f12c75c554d525c3adafa21f689921c82e9fac3d43395ce3759f5240fafa06fe4c6985bac7d6ba5bf42944c746e55c0584b067ba57d8b455fb
+  metadata.gz: 586d9f3730505eb43b61eee2d875af40d8aa0f2cc852fd342ebea69566e83f8255f291d4f29b2c731591ec0c29d7057cfff3065707e537acedcf7fcd66cb4cd2
+  data.tar.gz: f18b99c6456cc9c62a052ea0cf873832d537001a8d92add2073faf14f77fe103b09de3d0888d02a2ab92d4ce4c5982ea4125dccd93263b150172db6af925788c

data/README.md

@@ -38,6 +38,26 @@ a.align("AACG", "TCAACCTG")
 |task                 |DISTANCE, LOC, PATH ["DISTANCE"]                                                    |
 |additional_equalities|List of pairs of characters, where each pair defines two characters as equal. [NULL]|
 
+
+```ruby
+a.align("AACG", "TCAACCTG", nice: true)
+
+# {
+#   :edit_distance=>1,                                                 
+#   :alphabet_length=>4,                                               
+#   :locations=>[[2, 4], [2, 5]],                                      
+#   :alignment=>[0, 0, 0, 1],                                          
+#   :cigar=>"3=1I",                                                    
+#   :query_aligned=>"AACG",                                            
+#   :match_aligned=>"|||-",                                            
+#   :target_aligned=>"AAC-"
+# }        
+```
+
+## Documentation
+
+https://kojix2.github.io/ruby-edlib/
+
 ## Development
 
 Pull requests welcome!

data/ext/edlib/edlib.cpp

@@ -889,10 +889,10 @@ static int myersCalcEditDistanceNW(const Word* const Peq, const int W, const int
                 (*alignData)->Ps[maxNumBlocks * c + b] = bl->P;
                 (*alignData)->Ms[maxNumBlocks * c + b] = bl->M;
                 (*alignData)->scores[maxNumBlocks * c + b] = bl->score;
-                (*alignData)->firstBlocks[c] = firstBlock;
-                (*alignData)->lastBlocks[c] = lastBlock;
                 bl++;
             }
+            (*alignData)->firstBlocks[c] = firstBlock;
+            (*alignData)->lastBlocks[c] = lastBlock;
         }
         //----------------------------------------------------------//
         //---- If this is stop column, save it and finish ----//
@@ -901,9 +901,9 @@ static int myersCalcEditDistanceNW(const Word* const Peq, const int W, const int
                 (*alignData)->Ps[b] = (blocks + b)->P;
                 (*alignData)->Ms[b] = (blocks + b)->M;
                 (*alignData)->scores[b] = (blocks + b)->score;
-                (*alignData)->firstBlocks[0] = firstBlock;
-                (*alignData)->lastBlocks[0] = lastBlock;
             }
+            (*alignData)->firstBlocks[0] = firstBlock;
+            (*alignData)->lastBlocks[0] = lastBlock;
             *bestScore_ = -1;
             *position_ = targetStopPosition;
             delete[] blocks;

data/ext/edlib/edlibext.c

@@ -1,18 +1,37 @@
 #include "ruby.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;
 
 // 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 = "RbAlignConfig",
-	.function = {
-		.dfree = aligner_config_free,
-		.dsize = aligner_config_memsize,
-	},
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+		.wrap_struct_name = "RbAlignConfig",
+		.function = {
+				.dfree = aligner_config_free,
+				.dsize = aligner_config_memsize,
+		},
+		.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
 static VALUE
@@ -73,12 +92,7 @@ get_k(EdlibAlignConfig *config)
 	return INT2NUM(config->k);
 }
 
-static VALUE
-aligner_get_k(VALUE self)
-{
-	EdlibAlignConfig *config = aligner_get_config(self);
-	return get_k(config);
-}
+ALIGNER_GET_(k)
 
 static VALUE
 set_k(EdlibAlignConfig *config, VALUE k)
@@ -87,35 +101,25 @@ set_k(EdlibAlignConfig *config, VALUE k)
 	return k;
 }
 
-static VALUE
-aligner_set_k(VALUE self, VALUE k)
-{
-	EdlibAlignConfig *config = aligner_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 = aligner_get_config(self);
-	return get_mode(config);
-}
+ALIGNER_GET_(mode)
 
 static VALUE
 set_mode(EdlibAlignConfig *config, VALUE mode)
@@ -127,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
 		{
@@ -159,35 +164,25 @@ set_mode(EdlibAlignConfig *config, VALUE mode)
 	return mode;
 }
 
-static VALUE
-aligner_set_mode(VALUE self, VALUE mode)
-{
-	EdlibAlignConfig *config = aligner_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 = aligner_get_config(self);
-	return get_task(config);
-}
+ALIGNER_GET_(task)
 
 static VALUE
 set_task(EdlibAlignConfig *config, VALUE task)
@@ -199,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
 		{
@@ -231,12 +227,7 @@ set_task(EdlibAlignConfig *config, VALUE task)
 	return task;
 }
 
-static VALUE
-aligner_set_task(VALUE self, VALUE task)
-{
-	EdlibAlignConfig *config = aligner_get_config(self);
-	return set_task(config, task);
-}
+ALIGNER_SET_(task)
 
 static VALUE
 get_additional_equalities(EdlibAlignConfig *config)
@@ -255,18 +246,13 @@ get_additional_equalities(EdlibAlignConfig *config)
 	return equalities;
 }
 
-static VALUE
-aligner_get_additional_equalities(VALUE self)
-{
-	EdlibAlignConfig *config = aligner_get_config(self);
-	return get_additional_equalities(config);
-}
+ALIGNER_GET_(additional_equalities)
 
 static VALUE
 set_additional_equalities(EdlibAlignConfig *config, EdlibEqualityPair *eqpairs, VALUE equalities)
 {
 	Check_Type(equalities, T_ARRAY);
-	int len = RARRAY_LEN(equalities);
+	size_t len = RARRAY_LEN(equalities);
 	if (len == 0)
 	{
 		if (eqpairs != NULL)
@@ -278,9 +264,25 @@ set_additional_equalities(EdlibAlignConfig *config, EdlibEqualityPair *eqpairs,
 		config->additionalEqualitiesLength = 0;
 		return equalities;
 	}
+
+	// Check if len is too large
+	if (len > SIZE_MAX / sizeof(EdlibEqualityPair))
+	{
+		rb_raise(rb_eArgError, "Requested array is too large");
+	}
+
 	char *first_arr = malloc(len * sizeof(char));
 	char *second_arr = malloc(len * sizeof(char));
-	for (int i = 0; i < len; i++)
+	if (first_arr == NULL || second_arr == NULL)
+	{
+		if (first_arr != NULL)
+			free(first_arr);
+		if (second_arr != NULL)
+			free(second_arr);
+		rb_raise(rb_eNoMemError, "Failed to allocate memory for equality pairs");
+	}
+
+	for (size_t i = 0; i < len; i++)
 	{
 		VALUE pair = rb_ary_entry(equalities, i);
 		Check_Type(pair, T_ARRAY);
@@ -309,7 +311,7 @@ set_additional_equalities(EdlibAlignConfig *config, EdlibEqualityPair *eqpairs,
 
 	eqpairs = (EdlibEqualityPair *)malloc(sizeof(EdlibEqualityPair) * len);
 
-	for (int i = 0; i < len; i++)
+	for (size_t i = 0; i < len; i++)
 	{
 		eqpairs[i].first = first_arr[i];
 		eqpairs[i].second = second_arr[i];
@@ -355,7 +357,7 @@ aligner_initialize_raw(VALUE self, VALUE k, VALUE mode, VALUE task, VALUE additi
 	config->k = NUM2INT(k);
 	set_mode(config, mode);
 	set_task(config, task);
-	
+
 	if (additional_equalities != Qnil)
 	{
 		set_additional_equalities(config, eqpairs, additional_equalities);
@@ -379,11 +381,11 @@ aligner_align(VALUE self, VALUE query, VALUE target)
 	}
 
 	EdlibAlignResult result = edlibAlign(
-		StringValueCStr(query),
-		RSTRING_LEN(query),
-		StringValueCStr(target),
-		RSTRING_LEN(target),
-		*config);
+			StringValueCStr(query),
+			RSTRING_LEN(query),
+			StringValueCStr(target),
+			RSTRING_LEN(target),
+			*config);
 
 	if (result.status != 0)
 	{
@@ -455,5 +457,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

@@ -9,34 +9,7 @@ typedef struct
     EdlibEqualityPair *equalityPairs;
 } RbAlignConfig;
 
-static VALUE aligner_config_allocate(VALUE klass);
-static size_t aligner_config_memsize(const void *ptr);
-static void aligner_config_free(void *ptr);
-
 static EdlibAlignConfig *aligner_get_config(VALUE self);
 static EdlibEqualityPair *aligner_get_equalityPairs(VALUE self);
 
-static VALUE get_k(EdlibAlignConfig *config);
-static VALUE aligner_get_k(VALUE self);
-static VALUE set_k(EdlibAlignConfig *config, VALUE k);
-static VALUE aligner_set_k(VALUE self, VALUE k);
-static VALUE get_mode(EdlibAlignConfig *config);
-static VALUE aligner_get_mode(VALUE self);
-static VALUE set_mode(EdlibAlignConfig *config, VALUE mode);
-static VALUE aligner_set_mode(VALUE self, VALUE mode);
-static VALUE get_task(EdlibAlignConfig *config);
-static VALUE aligner_get_task(VALUE self);
-static VALUE set_task(EdlibAlignConfig *config, VALUE task);
-static VALUE aligner_set_task(VALUE self, VALUE task);
-static VALUE get_additional_equalities(EdlibAlignConfig *config);
-static VALUE aligner_get_additional_equalities(VALUE self);
-static VALUE set_additional_equalities(EdlibAlignConfig *config, EdlibEqualityPair *eqpairs, VALUE equalities);
-static VALUE aligner_set_additional_equalities(VALUE self, VALUE equalities);
-
-static VALUE aligner_config_hash(VALUE self);
-
-static VALUE aligner_initialize_raw(VALUE self, VALUE k, VALUE mode, VALUE task, VALUE additional_equalities);
-static VALUE aligner_align(VALUE self, VALUE query, VALUE target);
-void Init_edlibext(void);
-
 #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.6'
+  VERSION = '0.0.8'
 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.6
+  version: 0.0.8
 platform: ruby
 authors:
 - kojix2
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-11-02 00:00:00.000000000 Z
+date: 2024-08-17 00:00:00.000000000 Z
 dependencies: []
 description: 'Lightweight, super fast C/C++ library for sequence alignment using edit
   (Levenshtein) distance. '
@@ -31,7 +31,7 @@ homepage: https://github.com/kojix2/ruby-edlib
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -46,8 +46,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
-signing_key: 
+rubygems_version: 3.5.11
+signing_key:
 specification_version: 4
 summary: ruby-edlib is a wrapper for edlib.
 test_files: []