germ 0.1

data/ext/fasta_aux/FastaAux.c

@@ -0,0 +1,137 @@
+#include "ruby.h"
+#include "ruby/io.h"
+#include "stdio.h"
+#include <string.h>
+
+VALUE FastaAux = Qnil;
+
+void Init_fasta_aux();
+VALUE method_get_seq_starts(VALUE self);
+VALUE method_get_nmer_freq(VALUE self, VALUE seq, VALUE n);
+VALUE method_get_seq_chunk(VALUE self, VALUE pos1, VALUE pos2);
+FILE *get_io_ptr(VALUE self);
+
+FILE *get_io_ptr(VALUE self) {
+	VALUE io;
+	io = rb_iv_get(self,"@io");
+	return rb_io_stdio_file(RFILE(io)->fptr);
+}
+
+void Init_fasta_aux() {
+	FastaAux = rb_define_module("FastaAux");
+	rb_define_method(FastaAux, "get_seq_starts", method_get_seq_starts, 0);
+	rb_define_method(FastaAux, "get_seq_chunk", method_get_seq_chunk, 2);
+	rb_define_method(FastaAux, "get_nmer_freq", method_get_nmer_freq, 2);
+}
+
+#define BUF_SIZE 1200 // should be at least large enough to hold a >chr line
+
+VALUE method_get_seq_chunk(VALUE self, VALUE pos1, VALUE pos2) {
+	// extract the sequence between pos1 and pos2
+	FILE * fd;
+	char *buf;
+	unsigned int p1, p2;
+	VALUE s;
+	p1 = NUM2UINT(pos1);
+	p2 = NUM2UINT(pos2);
+	fd = get_io_ptr(self);
+	buf = ALLOC_N(char,p2-p1+1);
+	fseek(fd,p1,SEEK_SET);
+	fread(buf,1,p2-p1+1,fd);
+	s = rb_str_new(buf,p2-p1+1);
+	xfree(buf);
+	return s;
+}
+
+VALUE method_get_seq_starts(VALUE self) {
+	VALUE arr, pos;
+	FILE *fd;
+	int size;
+	char buf[BUF_SIZE];
+	char block[BUF_SIZE];
+	int bptr = 0;
+	unsigned int bytepos = 0;
+	arr = rb_ary_new();
+	pos = rb_ary_new();
+	fd = get_io_ptr(self);
+	rb_iv_set(self,"@seq_names",arr);
+	rb_iv_set(self,"@seq_starts",pos);
+	while (size = fread(buf,1,BUF_SIZE,fd)) { // = getc(fd)) != EOF) {
+		int i = 0;
+		for (i=0;i<size;i++) {
+			if (bptr && buf[i] == '\n') {
+				// you have a dirty fragment from the previous guy, add the rest of this one
+				if (i > 0) memcpy(block+bptr,buf,i);
+				rb_ary_push(arr, rb_str_new(block+1,bptr+i-1));
+				rb_ary_push(pos, UINT2NUM(bytepos+i+1));
+				bptr = 0;
+			}
+			if (buf[i] == '>') {
+				while (i < size && buf[i] != '\n') {
+					// push it onto the existing block
+					block[bptr++] = buf[i++];
+				}
+				if (i < size) {
+					rb_ary_push(arr, rb_str_new(block+1,bptr-1));
+					rb_ary_push(pos, UINT2NUM(bytepos+i+1));
+					bptr = 0;
+				}
+			}
+		}
+		bytepos += size;
+	}
+	return Qnil;
+}
+
+int get_nmer_code(char *seq,int size)
+{
+	int i;
+	uint r = 0;
+	for (i=0;i<size;i++) {
+		if (seq[i] == 'N') return -1;
+		if (seq[i] == 'a' || seq[i] == 'A') r = (r << 2) | 0;
+		if (seq[i] == 't' || seq[i] == 'T') r = (r << 2) | 1;
+		if (seq[i] == 'g' || seq[i] == 'G') r = (r << 2) | 2;
+		if (seq[i] == 'c' || seq[i] == 'C') r = (r << 2) | 3;
+	}
+	return r;
+}
+
+VALUE code_to_nmer(int code,int size)
+{
+	char buf[512];
+	int i;
+	const char *c = "ATGC";
+	for (i=size-1;i>=0;i--) {
+		buf[i] = c[code & 3];
+		code = code >> 2;
+	}
+	return rb_str_new(buf,size);
+}
+
+VALUE method_get_nmer_freq(VALUE self, VALUE sq, VALUE nm) {
+	int n,i,code;
+	int size;
+	char *seq;
+	int *buf,bsize;
+	VALUE h;
+
+	n = NUM2INT(nm);
+	bsize = 1<<(n*2);
+	buf = ALLOC_N(int,bsize);
+	memset(buf,0,bsize*sizeof(int));
+	seq = RSTRING_PTR(sq);
+	size = RSTRING_LEN(sq);
+	for (i=0;i<=size-n;i++) {
+		code = get_nmer_code(seq+i,n);
+		if (code == -1) continue;
+		buf[code]++;
+	}
+	h = rb_hash_new();
+	for (i=0;i<bsize;i++) {
+		if (!buf[i]) continue;
+		rb_hash_aset( h, code_to_nmer(i,n), INT2NUM(buf[i]) );
+	}
+	xfree(buf);
+	return h;
+}

data/ext/fasta_aux/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+extension_name = 'fasta_aux'
+
+dir_config(extension_name)
+
+create_makefile(extension_name)

data/ext/hash_table_aux/HashTableAux.c

@@ -0,0 +1,246 @@
+#include "ruby.h"
+#include "ruby/io.h"
+#include "stdio.h"
+#include <string.h>
+#include <ctype.h>
+
+VALUE HashTableAux = Qnil;
+
+VALUE method_load_file(VALUE self, VALUE file);
+
+void Init_hash_table_aux();
+
+void Init_hash_table_aux() {
+	HashTableAux = rb_define_module("HashTableAux");
+	rb_define_method(HashTableAux, "load_file", method_load_file, 1);
+}
+
+#define BUF_SIZE 1200
+
+long get_file_size(FILE *fp)
+{
+	long fp_size;
+	fseek(fp, 0, SEEK_END);
+	fp_size = ftell(fp);
+	rewind(fp);
+	return fp_size;
+}
+char *get_file_contents(FILE *fp,long fp_size)
+{
+	char *contents;
+	contents = ALLOC_N(char,fp_size);
+	fread(contents,sizeof(char), fp_size, fp);
+	return contents;
+}
+
+VALUE get_token_array(char *buf, char sep) {
+	char *token, *head;
+	VALUE ary = rb_ary_new();
+
+	head = buf;
+	while( *head && (token = strchr(head,sep) ) ) {
+		rb_ary_push(ary, rb_str_new(head, token - head));
+		head = token + 1;
+	}
+	if (*head) {
+		rb_ary_push(ary, rb_str_new2(head));
+	}
+	return ary;
+}
+
+VALUE convert_to_symbols(VALUE ary) {
+	int i;
+	for (i=0;i<RARRAY_LEN(ary);i++) {
+		rb_ary_store( ary, i, ID2SYM( rb_intern_str(rb_ary_entry(ary,i)) ) );
+	}
+	return ary;
+}
+#define TYPE_INT 0
+#define TYPE_FLOAT 1
+#define TYPE_SYM 2
+#define TYPE_HASH 3
+unsigned int convert_types[10];
+void set_convert_types()
+{
+	convert_types[TYPE_INT] = rb_intern("int");
+	convert_types[TYPE_FLOAT] = rb_intern("float");
+	convert_types[TYPE_SYM] = rb_intern("sym");
+}
+
+char *make_cstr(VALUE s) {
+	char *p = ALLOC_N(char,RSTRING_LEN(s)+1);
+	MEMCPY(p,RSTRING_PTR(s),char,RSTRING_LEN(s));
+	p[RSTRING_LEN(s)] = '\0';
+	return p;
+}
+
+char *strip_space_quotes( char *o, int len )
+{
+	char *vf;
+	char *c = o;
+	char *d;
+	int iq = 0;
+	if (!c) return 0;
+	vf = ALLOC_N(char,len+1);
+	d = vf;
+	while(isspace(*c)) c++;
+	if (*c == '"' || *c == '\'') { c++; iq = 1; }
+	while(*c) *d++ = *c++;
+	// you hit the end, rewind spaces and quotes
+	if (d == vf) {
+		xfree(vf);
+		return 0;
+	}
+	while(isspace(*(d-1))) d--;
+	if (iq && *(d-1) == '"' || *(d-1) == '\'') d--;
+	*d = 0;
+	return vf;
+}
+
+void make_hash_entry( VALUE h, VALUE s, char sep )
+{
+	char *p = make_cstr(s);
+	char *kf;
+	VALUE key;
+	char *vs = 0;
+	char *split;
+	char *head = p;
+
+	while (isspace(*head)) head++;
+	if (split = strchr(head,sep)) {
+		*split = 0;
+		vs = split+1;
+	}
+
+	kf = strip_space_quotes(head, RSTRING_LEN(s));
+	if (!kf) {
+		xfree(p);
+		return;
+	}
+	key = ID2SYM( rb_intern(kf) );
+
+	if (!vs || !*vs) {
+		rb_hash_aset( h, key, Qnil );
+	} else {
+		char *vf = strip_space_quotes(vs, RSTRING_LEN(s));
+		if (!vf)
+			rb_hash_aset( h, key, Qnil );
+		else {
+			rb_hash_aset( h, key, rb_str_new2(vf) );
+			xfree(vf);
+		}
+	}
+	xfree(kf);
+	xfree(p);
+}
+
+VALUE convert_to_type( VALUE v, VALUE type )
+{
+	if (type == Qnil || v == Qnil) return v;
+	// return the matching type, assuming v is a string
+	if (TYPE(type) == T_ARRAY) // it's a hash array
+	{
+		// tokenize the value based on the first and last characters
+		char *p = make_cstr(v);
+		char *t1 = make_cstr( rb_ary_entry( type, 0 ) );
+		char *t2 = make_cstr( rb_ary_entry( type, 1 ) );
+		int i;
+		VALUE h = rb_hash_new();
+		VALUE ary = get_token_array(p,t1[0]);
+		for (i=0;i< RARRAY_LEN(ary); i++) {
+			make_hash_entry( h, rb_ary_entry( ary, i ), t2[0] );
+		}
+		xfree(p);
+		xfree(t1);
+		xfree(t2);
+		return h;
+	}
+	else if (SYM2ID(type) == convert_types[TYPE_INT]) {
+		char *p = make_cstr(v);
+		int i = atoi(p);
+		xfree(p);
+		return INT2NUM(i);
+	}
+	else if (SYM2ID(type) == convert_types[TYPE_FLOAT]) {
+		char *p = make_cstr(v);
+		double f = atof(p);
+		xfree(p);
+		return DBL2NUM(f);
+	}
+	else if (SYM2ID(type) == convert_types[TYPE_SYM]) {
+		return ID2SYM( rb_intern_str(v) );
+	}
+	return v;
+}
+
+void add_hash_line(VALUE lines, VALUE header, VALUE types, VALUE ary) {
+	VALUE hash = rb_hash_new();
+	int i;
+	for (i=0;i<RARRAY_LEN(header);i++) {
+		if (types == Qnil)
+			rb_hash_aset( hash, rb_ary_entry(header,i), rb_ary_entry(ary,i) );
+		else
+			rb_hash_aset( hash, rb_ary_entry(header,i), 
+				convert_to_type( rb_ary_entry(ary,i), rb_ary_entry( types, i ) )
+			);
+	}
+	rb_ary_push(lines, hash);
+}
+
+
+VALUE method_load_file(VALUE self, VALUE file) {
+	VALUE cmmt = rb_iv_get(self,"@comment");
+	char *comment = (cmmt == Qnil) ? 0 : RSTRING_PTR(cmmt);
+	int commentsize = (cmmt == Qnil) ? 0 : (RSTRING_LEN(cmmt));
+
+	FILE *fp = fopen(RSTRING_PTR(file),"r");
+	long fp_size = get_file_size(fp);
+	char *contents = get_file_contents( fp, fp_size );
+
+	VALUE header = rb_iv_get(self,"@header");
+	VALUE skip_header = rb_iv_get(self,"@skip_header");
+	VALUE types = rb_iv_get(self,"@types");
+
+
+	char *buf = ALLOC_N(char,fp_size);
+	int i = 0, foundheader = 0;
+	char *n;
+	VALUE ary;
+	VALUE lines = rb_ary_new();
+
+	set_convert_types();
+	while (i < fp_size) {
+		if (!(n = strchr(contents+i, '\n'))) {
+			// there is no line before eof, copy the remainder of the buffer
+			strncpy(buf,contents+i,fp_size - i);
+			buf[fp_size - i] = 0;
+			i = fp_size;
+		} else {
+			strncpy(buf,contents+i,n-(contents+i));
+			buf[n-(contents+i)] = 0;
+			i = n - contents + 1;
+		}
+		if (comment && !strncmp(buf,comment,commentsize)) {
+			continue;
+		}
+		// okay, now you can split your string into tokens and push it
+		// onto an array.
+		ary = get_token_array(buf,'\t');
+		if (header == Qnil) {
+			header = convert_to_symbols(ary);
+			rb_iv_set(self,"@header",header);
+			continue;
+		}
+		if (skip_header != Qnil && !foundheader) {
+			// it expects there to be a header to be ignored
+			foundheader = 1;
+			continue;
+		}
+		add_hash_line( lines, header, types, ary );
+	}
+	
+	rb_iv_set(self,"@lines",lines);
+	xfree(buf);
+	xfree(contents);
+	return Qnil;
+}

data/ext/hash_table_aux/extconf.rb

@@ -0,0 +1,7 @@
+require 'mkmf'
+
+extension_name = 'hash_table_aux'
+
+dir_config(extension_name)
+
+create_makefile(extension_name)

data/lib/fasta.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+require 'fasta_aux/fasta_aux'
+
+class Fasta
+  private
+  include FastaAux
+
+  class Chrom
+    attr_reader :name, :size, :start
+    def initialize n, fasta, sz, st
+      @name, @fasta, @size, @start = n, fasta, sz, st
+    end
+
+    def include? pos
+      if pos.is_a? Array
+        start,stop = pos.to_a
+        include?(start) && include?(stop)
+      else
+        pos.is_a?(Fixnum) && pos >= 1 && pos <= size
+      end
+    end
+
+    def file_pos pos
+      return nil if !include? pos
+      start + pos/line_size*(line_size+1) + (pos % line_size) - 1 - ((pos % line_size == 0) ? 1 : 0)
+    end
+
+    private
+    def line_size
+      @fasta.line_size
+    end
+  end
+
+  def seq_size_from_byte_size bytes
+    (bytes/(@line_size+1))*@line_size + (bytes % (@line_size+1))
+  end
+
+  def compute_chrom_stats
+    @chroms = {}
+    @seq_names.each_with_index do |name, i|
+      if i < @seq_names.size-1
+        @chroms[name] = Fasta::Chrom.new name, self, seq_size_from_byte_size(@seq_starts[i+1] - @seq_starts[i] - @seq_names[i+1].size - 3), @seq_starts[i]
+      else
+        @chroms[name] = Fasta::Chrom.new name, self, seq_size_from_byte_size(@io.size - @seq_starts[i]), @seq_starts[i]
+      end
+    end
+  end
+
+
+  public
+  attr_reader :line_size, :chroms
+  def initialize file, size=nil
+    @io = File.open(file)
+
+    @line_size = size || 50
+
+    get_seq_starts
+
+    compute_chrom_stats
+  end
+
+  def size
+    @chroms.inject(0) { |s,v| s += v.last.size }
+  end
+
+  def inspect
+    "#<#{self.class.name}:#{object_id} @chroms=#{@seq_names.count}>"
+  end
+
+  def get_seq chrom, start, stop
+    seq = get_masked_seq chrom, start, stop
+    seq && seq.upcase
+  end
+
+  def get_masked_seq chrom, start, stop
+    raise ArgumentError.new("Improper interval") if !@chroms[chrom] || !@chroms[chrom].include?([start,stop])
+    get_seq_chunk(@chroms[chrom].file_pos(start), @chroms[chrom].file_pos(stop)).gsub(/\n/,'')
+  end
+end