bio-kseq 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 887f0a14561673eb7226ee2e01372b637d780c63
+  data.tar.gz: c4fd1b6e2648d0bb3fb54855fb33cb7cb2fdfb68
+SHA512:
+  metadata.gz: 0224e47c38a03c2d2e468c8aaef333494a254774bd0261f6f7a32efd59b0e93888187897e6cb3b9ec4df45b53b56cb6fc3702ce833fe3b162ffd2d193e406569
+  data.tar.gz: 73d65945910d96940304586733c8a78c9b6cf8338408596be33fafbbc755542c4af07a50c4f84d48c763765d8c4a84d2a7c970f80e597173d8d168ec680eb354

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "ext/seqtk_bindings/seqtk"]
+	path = ext/seqtk_bindings/seqtk
+	url = https://github.com/lh3/seqtk.git

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.1.2
+  - 2.1.1
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bioruby-seqtk.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Gusev Fedor
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,65 @@
+# Bio::Kseq [![Build Status](https://travis-ci.org/gusevfe/bio-kseq.svg?branch=master)](https://travis-ci.org/gusevfe/bio-kseq)
+
+Ruby bindings for a very fast FASTA/Q parser [kseq.h](https://github.com/lh3/seqtk/blob/master/kseq.h) by Heng Li.
+
+A default FASTA/Q parser from [BioRuby](http://bioruby.org) is extremly slow. One alternative is to use [bio-faster](https://github.com/fstrozzi/bioruby-faster) but that lacks support for FASTA files. However, `bio-faster` does parse qualities, unlike `bio-kseq`. 
+
+## Timings
+```
+                 user     system     total          real
+BioRuby      2.130000   0.270000   2.400000 (  2.403145)
+Bio::Faster  0.420000   0.070000   0.490000 (  0.486809)
+Bio::Kseq    0.030000   0.010000   0.040000 (  0.037176)
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'bioruby-seqtk'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bioruby-seqtk
+
+## Usage
+
+```ruby
+require 'bio/kseq'
+
+# Convert FASTQ to FASTA
+kseq = Bio::Kseq.new("test.fastq")
+while kseq.read! # returns truthy values when there is an entry
+  puts ">" + kseq.name 
+  puts kseq.seq
+end
+
+kseq = Bio::Kseq.new("test.fastq.gz") # You can open GZIPed files flawlessly
+kseq.read! or throw("Failed to read test.fastq.gz")
+
+# Suppose entry is like this:
+# @SRR001666.1 071112_SLXA-EAS1_s_7:5:1:817:345 length=36
+# GGGTGATGGCCGCTGCCGATGGCGTCAAATCCCACC
+# +SRR001666.1 071112_SLXA-EAS1_s_7:5:1:817:345 length=36
+# IIIIIIIIIIIIIIIIIIIIIIIIIIIIII9IG9IC
+kseq.name    # = "SRR001666.1"
+kseq.comment # = "071112_SLXA-EAS1_s_7:5:1:817:345 length=36", may be nil
+kseq.seq     # = "GGGTGATGGCCGCTGCCGATGGCGTCAAATCCCACC"
+kseq.qual    # = "IIIIIIIIIIIIIIIIIIIIIIIIIIIIII9IG9IC", may be nil
+
+kseq = Bio::Kseq.new(IO.popen("zcat test.fastq.gz")) # You can also process Ruby IO objects
+kseq.read! or throw("Failed to read test.fastq.gz")
+puts kseq # Outputs a valid FASTQ entry
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/gusevfe/bioruby-seqtk/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,9 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+require "rake/extensiontask"
+
+RSpec::Core::RakeTask.new('spec')
+Rake::ExtensionTask.new "seqtk_bindings"
+
+task :spec => :compile
+task :default => :spec

data/bio-kseq.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bio/kseq/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bio-kseq"
+  spec.version       = Bio::Kseq::VERSION
+  spec.authors       = ["Fedor Gusev"]
+  spec.email         = ["gusevfe@gmail.com"]
+  spec.summary       = %q{Ruby inferface for kseq.h by Heng Li for fast FASTA/Q reading}
+  spec.description   = %q{A fast FASTA/FASTQ parser based on kseq.h by Heng Li}
+  spec.homepage      = "https://github.com/gusevfe/bio-kseq"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0") - ["timing.rb"]
+  spec.files         << "ext/seqtk_bindings/seqtk/kseq.h"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib", "ext"]
+  spec.extensions    = Dir['ext/**/extconf.rb']
+  spec.platform = Gem::Platform::RUBY
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", ">= 3.0.0"
+  spec.add_development_dependency "rake-compiler"
+  #spec.add_development_dependency "bio" # For timing script
+  #spec.add_development_dependency "bio-faster" # For timing script
+end

data/ext/seqtk_bindings/extconf.rb

@@ -0,0 +1,6 @@
+require 'mkmf'
+
+dir_config('seqtk_bindings')
+find_header('zlib.h')
+find_library('z', 'gzopen')
+create_makefile('seqtk_bindings')

data/ext/seqtk_bindings/seqtk/kseq.h

@@ -0,0 +1,235 @@
+/* The MIT License
+
+   Copyright (c) 2008, 2009, 2011 Attractive Chaos <attractor@live.co.uk>
+
+   Permission is hereby granted, free of charge, to any person obtaining
+   a copy of this software and associated documentation files (the
+   "Software"), to deal in the Software without restriction, including
+   without limitation the rights to use, copy, modify, merge, publish,
+   distribute, sublicense, and/or sell copies of the Software, and to
+   permit persons to whom the Software is furnished to do so, subject to
+   the following conditions:
+
+   The above copyright notice and this permission notice shall be
+   included in all copies or substantial portions of the Software.
+
+   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+   BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+   ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+   SOFTWARE.
+*/
+
+/* Last Modified: 05MAR2012 */
+
+#ifndef AC_KSEQ_H
+#define AC_KSEQ_H
+
+#include <ctype.h>
+#include <string.h>
+#include <stdlib.h>
+
+#define KS_SEP_SPACE 0 // isspace(): \t, \n, \v, \f, \r
+#define KS_SEP_TAB   1 // isspace() && !' '
+#define KS_SEP_LINE  2 // line separator: "\n" (Unix) or "\r\n" (Windows)
+#define KS_SEP_MAX   2
+
+#define __KS_TYPE(type_t)						\
+	typedef struct __kstream_t {				\
+		unsigned char *buf;						\
+		int begin, end, is_eof;					\
+		type_t f;								\
+	} kstream_t;
+
+#define ks_eof(ks) ((ks)->is_eof && (ks)->begin >= (ks)->end)
+#define ks_rewind(ks) ((ks)->is_eof = (ks)->begin = (ks)->end = 0)
+
+#define __KS_BASIC(type_t, __bufsize)								\
+	static inline kstream_t *ks_init(type_t f)						\
+	{																\
+		kstream_t *ks = (kstream_t*)calloc(1, sizeof(kstream_t));	\
+		ks->f = f;													\
+		ks->buf = (unsigned char*)malloc(__bufsize);				\
+		return ks;													\
+	}																\
+	static inline void ks_destroy(kstream_t *ks)					\
+	{																\
+		if (ks) {													\
+			free(ks->buf);											\
+			free(ks);												\
+		}															\
+	}
+
+#define __KS_GETC(__read, __bufsize)						\
+	static inline int ks_getc(kstream_t *ks)				\
+	{														\
+		if (ks->is_eof && ks->begin >= ks->end) return -1;	\
+		if (ks->begin >= ks->end) {							\
+			ks->begin = 0;									\
+			ks->end = __read(ks->f, ks->buf, __bufsize);	\
+			if (ks->end < __bufsize) ks->is_eof = 1;		\
+			if (ks->end == 0) return -1;					\
+		}													\
+		return (int)ks->buf[ks->begin++];					\
+	}
+
+#ifndef KSTRING_T
+#define KSTRING_T kstring_t
+typedef struct __kstring_t {
+	size_t l, m;
+	char *s;
+} kstring_t;
+#endif
+
+#ifndef kroundup32
+#define kroundup32(x) (--(x), (x)|=(x)>>1, (x)|=(x)>>2, (x)|=(x)>>4, (x)|=(x)>>8, (x)|=(x)>>16, ++(x))
+#endif
+
+#define __KS_GETUNTIL(__read, __bufsize)								\
+	static int ks_getuntil2(kstream_t *ks, int delimiter, kstring_t *str, int *dret, int append) \
+	{																	\
+		if (dret) *dret = 0;											\
+		str->l = append? str->l : 0;									\
+		if (ks->begin >= ks->end && ks->is_eof) return -1;				\
+		for (;;) {														\
+			int i;														\
+			if (ks->begin >= ks->end) {									\
+				if (!ks->is_eof) {										\
+					ks->begin = 0;										\
+					ks->end = __read(ks->f, ks->buf, __bufsize);		\
+					if (ks->end < __bufsize) ks->is_eof = 1;			\
+					if (ks->end == 0) break;							\
+				} else break;											\
+			}															\
+			if (delimiter == KS_SEP_LINE) { \
+				for (i = ks->begin; i < ks->end; ++i) \
+					if (ks->buf[i] == '\n') break; \
+			} else if (delimiter > KS_SEP_MAX) {						\
+				for (i = ks->begin; i < ks->end; ++i)					\
+					if (ks->buf[i] == delimiter) break;					\
+			} else if (delimiter == KS_SEP_SPACE) {						\
+				for (i = ks->begin; i < ks->end; ++i)					\
+					if (isspace(ks->buf[i])) break;						\
+			} else if (delimiter == KS_SEP_TAB) {						\
+				for (i = ks->begin; i < ks->end; ++i)					\
+					if (isspace(ks->buf[i]) && ks->buf[i] != ' ') break; \
+			} else i = 0; /* never come to here! */						\
+			if (str->m - str->l < (size_t)(i - ks->begin + 1)) {		\
+				str->m = str->l + (i - ks->begin) + 1;					\
+				kroundup32(str->m);										\
+				str->s = (char*)realloc(str->s, str->m);				\
+			}															\
+			memcpy(str->s + str->l, ks->buf + ks->begin, i - ks->begin); \
+			str->l = str->l + (i - ks->begin);							\
+			ks->begin = i + 1;											\
+			if (i < ks->end) {											\
+				if (dret) *dret = ks->buf[i];							\
+				break;													\
+			}															\
+		}																\
+		if (str->s == 0) {												\
+			str->m = 1;													\
+			str->s = (char*)calloc(1, 1);								\
+		} else if (delimiter == KS_SEP_LINE && str->l > 1 && str->s[str->l-1] == '\r') --str->l; \
+		str->s[str->l] = '\0';											\
+		return str->l;													\
+	} \
+	static inline int ks_getuntil(kstream_t *ks, int delimiter, kstring_t *str, int *dret) \
+	{ return ks_getuntil2(ks, delimiter, str, dret, 0); }
+
+#define KSTREAM_INIT(type_t, __read, __bufsize) \
+	__KS_TYPE(type_t)							\
+	__KS_BASIC(type_t, __bufsize)				\
+	__KS_GETC(__read, __bufsize)				\
+	__KS_GETUNTIL(__read, __bufsize)
+
+#define kseq_rewind(ks) ((ks)->last_char = (ks)->f->is_eof = (ks)->f->begin = (ks)->f->end = 0)
+
+#define __KSEQ_BASIC(SCOPE, type_t)										\
+	SCOPE kseq_t *kseq_init(type_t fd)									\
+	{																	\
+		kseq_t *s = (kseq_t*)calloc(1, sizeof(kseq_t));					\
+		s->f = ks_init(fd);												\
+		return s;														\
+	}																	\
+	SCOPE void kseq_destroy(kseq_t *ks)									\
+	{																	\
+		if (!ks) return;												\
+		free(ks->name.s); free(ks->comment.s); free(ks->seq.s);	free(ks->qual.s); \
+		ks_destroy(ks->f);												\
+		free(ks);														\
+	}
+
+/* Return value:
+   >=0  length of the sequence (normal)
+   -1   end-of-file
+   -2   truncated quality string
+ */
+#define __KSEQ_READ(SCOPE) \
+	SCOPE int kseq_read(kseq_t *seq) \
+	{ \
+		int c; \
+		kstream_t *ks = seq->f; \
+		if (seq->last_char == 0) { /* then jump to the next header line */ \
+			while ((c = ks_getc(ks)) != -1 && c != '>' && c != '@'); \
+			if (c == -1) return -1; /* end of file */ \
+			seq->last_char = c; \
+		} /* else: the first header char has been read in the previous call */ \
+		seq->comment.l = seq->seq.l = seq->qual.l = 0; /* reset all members */ \
+		if (ks_getuntil(ks, 0, &seq->name, &c) < 0) return -1; /* normal exit: EOF */ \
+		if (c != '\n') ks_getuntil(ks, KS_SEP_LINE, &seq->comment, 0); /* read FASTA/Q comment */ \
+		if (seq->seq.s == 0) { /* we can do this in the loop below, but that is slower */ \
+			seq->seq.m = 256; \
+			seq->seq.s = (char*)malloc(seq->seq.m); \
+		} \
+		while ((c = ks_getc(ks)) != -1 && c != '>' && c != '+' && c != '@') { \
+			if (c == '\n') continue; /* skip empty lines */ \
+			seq->seq.s[seq->seq.l++] = c; /* this is safe: we always have enough space for 1 char */ \
+			ks_getuntil2(ks, KS_SEP_LINE, &seq->seq, 0, 1); /* read the rest of the line */ \
+		} \
+		if (c == '>' || c == '@') seq->last_char = c; /* the first header char has been read */	\
+		if (seq->seq.l + 1 >= seq->seq.m) { /* seq->seq.s[seq->seq.l] below may be out of boundary */ \
+			seq->seq.m = seq->seq.l + 2; \
+			kroundup32(seq->seq.m); /* rounded to the next closest 2^k */ \
+			seq->seq.s = (char*)realloc(seq->seq.s, seq->seq.m); \
+		} \
+		seq->seq.s[seq->seq.l] = 0;	/* null terminated string */ \
+		if (c != '+') return seq->seq.l; /* FASTA */ \
+		if (seq->qual.m < seq->seq.m) {	/* allocate memory for qual in case insufficient */ \
+			seq->qual.m = seq->seq.m; \
+			seq->qual.s = (char*)realloc(seq->qual.s, seq->qual.m); \
+		} \
+		while ((c = ks_getc(ks)) != -1 && c != '\n'); /* skip the rest of '+' line */ \
+		if (c == -1) return -2; /* error: no quality string */ \
+		while (ks_getuntil2(ks, KS_SEP_LINE, &seq->qual, 0, 1) >= 0 && seq->qual.l < seq->seq.l); \
+		seq->last_char = 0;	/* we have not come to the next header line */ \
+		if (seq->seq.l != seq->qual.l) return -2; /* error: qual string is of a different length */ \
+		return seq->seq.l; \
+	}
+
+#define __KSEQ_TYPE(type_t)						\
+	typedef struct {							\
+		kstring_t name, comment, seq, qual;		\
+		int last_char;							\
+		kstream_t *f;							\
+	} kseq_t;
+
+#define KSEQ_INIT2(SCOPE, type_t, __read)		\
+	KSTREAM_INIT(type_t, __read, 16384)			\
+	__KSEQ_TYPE(type_t)							\
+	__KSEQ_BASIC(SCOPE, type_t)					\
+	__KSEQ_READ(SCOPE)
+
+#define KSEQ_INIT(type_t, __read) KSEQ_INIT2(static, type_t, __read)
+
+#define KSEQ_DECLARE(type_t) \
+	__KS_TYPE(type_t) \
+	__KSEQ_TYPE(type_t) \
+	extern kseq_t *kseq_init(type_t fd); \
+	void kseq_destroy(kseq_t *ks); \
+	int kseq_read(kseq_t *seq);
+
+#endif

data/ext/seqtk_bindings/seqtk_bindings.c

@@ -0,0 +1,100 @@
+#include <ruby.h>
+#include <ruby/io.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <seqtk/kseq.h>
+#include <zlib.h>
+
+KSEQ_INIT(gzFile, gzread);
+
+void Init_seqtk_bindings();
+static VALUE kseq_wrapper_allocate(VALUE klass);
+static VALUE kseq_wrapper_initialize(VALUE klass, VALUE rb_filename);
+static void kseq_wrapper_deallocate(void *seq);
+static VALUE kseq_wrapper_read(VALUE self);
+
+VALUE mBio;
+VALUE cKseq;
+
+typedef struct {
+  char from_io;
+  kseq_t *seq;
+  gzFile fp;
+} Kseq_Wrapper;
+
+#define kseq_wrapper_field(NAME) \
+  static VALUE kseq_wrapper_ ## NAME(VALUE self) { \
+    Kseq_Wrapper *w; \
+    Data_Get_Struct(self, Kseq_Wrapper, w);\
+    if (w->seq->NAME.l) \
+      return rb_str_new2(w->seq->NAME.s);\
+    else \
+      return Qnil;\
+  }\
+
+kseq_wrapper_field(name);
+kseq_wrapper_field(comment);
+kseq_wrapper_field(seq);
+kseq_wrapper_field(qual);
+
+void Init_seqtk_bindings() {
+  mBio = rb_define_module("Bio");
+  cKseq = rb_define_class_under(mBio, "Kseq", rb_cObject);
+  rb_define_alloc_func(cKseq, kseq_wrapper_allocate);
+  rb_define_method(cKseq, "initialize", kseq_wrapper_initialize, 1);
+
+  rb_define_method(cKseq, "read!", kseq_wrapper_read, 0);
+  rb_define_method(cKseq, "name", kseq_wrapper_name, 0);
+  rb_define_method(cKseq, "comment", kseq_wrapper_comment, 0);
+  rb_define_method(cKseq, "seq", kseq_wrapper_seq, 0);
+  rb_define_method(cKseq, "qual", kseq_wrapper_qual, 0);
+}
+
+static VALUE kseq_wrapper_allocate(VALUE klass) {
+  Kseq_Wrapper *w = malloc(sizeof(Kseq_Wrapper));
+
+  return Data_Wrap_Struct(klass, NULL, kseq_wrapper_deallocate, w);
+}
+
+static void kseq_wrapper_deallocate(void *p)
+{
+  Kseq_Wrapper *w = p;
+  kseq_destroy(w->seq);
+  if (!(w->from_io))
+    gzclose(w->fp);
+  free(w);
+}
+
+static VALUE kseq_wrapper_read(VALUE self) {
+  int r;
+  Kseq_Wrapper *w;
+
+  Data_Get_Struct(self, Kseq_Wrapper, w);
+  r = kseq_read(w->seq);
+
+  return r >= 0 ? Qtrue : Qfalse;
+}
+
+static VALUE kseq_wrapper_initialize(VALUE self, VALUE value) {
+  Kseq_Wrapper *w;
+
+  Data_Get_Struct(self, Kseq_Wrapper, w);
+  w->from_io = 0;
+
+  switch (TYPE(value)) {
+    case T_STRING:
+      w->fp = gzopen(StringValuePtr(value), "r"); 
+      break;
+    case T_FILE:
+      w->fp = gzdopen(fileno(rb_io_stdio_file(RFILE(value)->fptr)), "r");
+      w->from_io = 1;
+      break;
+    default:
+      rb_raise(rb_eTypeError, "Only strings and IOs are supported");
+      break;
+  }
+
+  w->seq = kseq_init(w->fp);
+
+  return self;    
+}

data/lib/bio/kseq.rb

@@ -0,0 +1,24 @@
+require "seqtk_bindings"
+require "bio/kseq/version"
+
+module Bio
+  module SeqTK
+    class Kseq
+      def to_s
+        if qual.nil?
+          if comment.nil?
+            ">" + name + "\n" + seq
+          else
+            ">" + name + " " + comment + "\n" + seq
+          end
+        else
+          if comment.nil?
+            "@" + name + "\n" + seq + "\n+\n" + qual
+          else
+            "@" + name + " " + comment + "\n" + seq + "\n+\n" + qual
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bio/kseq/version.rb

@@ -0,0 +1,5 @@
+module Bio
+  class Kseq
+    VERSION = "0.0.2"
+  end
+end

data/spec/kseq_spec.rb

@@ -0,0 +1,100 @@
+require 'bio/kseq'
+require 'tempfile'
+
+include Bio
+
+describe Kseq do
+  it 'should parse simple FASTA files' do
+    tmp = Tempfile.new 'fasta'
+    tmp.puts ">A"
+    tmp.puts "AAAATTTTCCCCGGGG"
+    tmp.puts ">B comment"
+    tmp.puts "GGGGTTTTCCCCAAAA"
+    tmp.close
+
+    kseq = Kseq.new tmp.path
+
+    expect(kseq.read!).to be_truthy 
+    expect(kseq.name).to eq("A")
+    expect(kseq.comment).to be_nil
+    expect(kseq.seq).to eq("AAAATTTTCCCCGGGG")
+    expect(kseq.qual).to be_nil
+
+    expect(kseq.read!).to be_truthy 
+    expect(kseq.name).to eq("B")
+    expect(kseq.comment).to eq("comment")
+    expect(kseq.seq).to eq("GGGGTTTTCCCCAAAA")
+    expect(kseq.qual).to be_nil
+
+    expect(kseq.read!).to be_falsey
+  end
+
+  it 'should parse simple FASTQ files' do
+    tmp = Tempfile.new 'fasta'
+    tmp.puts "@A"
+    tmp.puts "AAAATTTTCCCCGGGG"
+    tmp.puts "+"
+    tmp.puts "AAAAAAAAAAAAAAAA"
+    tmp.puts "@B comment"
+    tmp.puts "GGGGTTTTCCCCAAAA"
+    tmp.puts "+"
+    tmp.puts "IIIIIIIIIIIIIIII"
+    tmp.close
+
+    kseq = Kseq.new tmp.path
+
+    expect(kseq.read!).to be_truthy
+    expect(kseq.name).to eq("A")
+    expect(kseq.comment).to be_nil
+    expect(kseq.seq).to eq("AAAATTTTCCCCGGGG")
+    expect(kseq.qual).to eq("AAAAAAAAAAAAAAAA")
+
+    expect(kseq.read!).to be_truthy
+    expect(kseq.name).to eq("B")
+    expect(kseq.comment).to eq("comment")
+    expect(kseq.seq).to eq("GGGGTTTTCCCCAAAA")
+    expect(kseq.qual).to eq("IIIIIIIIIIIIIIII")
+
+    expect(kseq.read!).to be_falsey
+  end
+
+  it 'should read from IO' do
+    tmp = Tempfile.new 'fasta'
+    tmp.puts ">A"
+    tmp.puts "AAAATTTTCCCCGGGG"
+    tmp.puts ">B comment"
+    tmp.puts "GGGGTTTTCCCCAAAA"
+    tmp.close
+
+    io = File.open(tmp.path)
+
+    kseq = Kseq.new io
+
+    expect(kseq.read!).to be_truthy
+    expect(kseq.name).to eq("A")
+    expect(kseq.comment).to be_nil
+    expect(kseq.seq).to eq("AAAATTTTCCCCGGGG")
+    expect(kseq.qual).to be_nil
+
+    expect(kseq.read!).to be_truthy
+    expect(kseq.name).to eq("B")
+    expect(kseq.comment).to eq("comment")
+    expect(kseq.seq).to eq("GGGGTTTTCCCCAAAA")
+    expect(kseq.qual).to be_nil
+
+    expect(kseq.read!).to be_falsey
+  end
+
+  it 'should read comment' do
+    tmp = Tempfile.new 'fasta'
+    tmp.puts "@SRR001666.1 071112_SLXA-EAS1_s_7:5:1:817:345 length=36"
+    tmp.puts "GGGTGATGGCCGCTGCCGATGGCGTCAAATCCCACC"
+    tmp.puts "+SRR001666.1 071112_SLXA-EAS1_s_7:5:1:817:345 length=36"
+    tmp.puts "IIIIIIIIIIIIIIIIIIIIIIIIIIIIII9IG9IC"
+    tmp.close
+
+    kseq = Kseq.new tmp.path
+    expect(kseq.read!).to be_truthy
+    expect(kseq.comment).to eq("071112_SLXA-EAS1_s_7:5:1:817:345 length=36")
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  config.order = 'random'
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: bio-kseq
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Fedor Gusev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A fast FASTA/FASTQ parser based on kseq.h by Heng Li
+email:
+- gusevfe@gmail.com
+executables: []
+extensions:
+- ext/seqtk_bindings/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".gitmodules"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bio-kseq.gemspec
+- ext/seqtk_bindings/extconf.rb
+- ext/seqtk_bindings/seqtk/kseq.h
+- ext/seqtk_bindings/seqtk_bindings.c
+- lib/bio/kseq.rb
+- lib/bio/kseq/version.rb
+- spec/kseq_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/gusevfe/bio-kseq
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby inferface for kseq.h by Heng Li for fast FASTA/Q reading
+test_files:
+- spec/kseq_spec.rb
+- spec/spec_helper.rb