BioDSL 1.0.0

data/Rakefile

@@ -0,0 +1,94 @@
+require 'bundler'
+require 'rake/testtask'
+require 'pp'
+
+Bundler::GemHelper.install_tasks
+
+task :default => 'test'
+ 
+Rake::TestTask.new do |t|
+  t.description = "Run test suite"
+  t.test_files  = Dir['test/**/*'].select { |f| f.match(/\.rb$/) }
+  t.warning     = true
+end
+ 
+desc 'Run test suite with simplecov'
+task :simplecov do
+  ENV['SIMPLECOV'] = 'true'
+  Rake::Task['test'].invoke
+end
+
+desc 'Add or update yardoc'
+task :doc do
+  run_docgen
+end
+
+task :build => :boilerplate
+
+desc 'Add or update license boilerplate in source files'
+task :boilerplate do
+  run_boilerplate
+end
+
+def run_docgen
+  $stderr.puts "Building docs"
+  `yardoc lib/`
+  $stderr.puts "Docs done"
+end
+
+def run_boilerplate
+  boilerplate = <<END
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-#{Time.now.year} Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of BioDSL (www.github.com/maasha/BioDSL).              #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+END
+
+  files = Rake::FileList.new('bin/**/*', 'lib/**/*.rb', 'test/**/*.rb')
+
+  files.each do |file|
+    body = ""
+
+    File.open(file) do |ios|
+      body = ios.read
+    end
+
+    if body.match(/Copyright \(C\) 2007-(\d{4}) Martin Asser Hansen/) and $1.to_i != Time.now.year
+      STDERR.puts "Updating boilerplate: #{file}"
+
+      body.sub!(/Copyright \(C\) 2007-(\d{4}) Martin Asser Hansen/, "Copyright (C) 2007-#{Time.now.year} Martin Asser Hansen")
+
+      File.open(file, 'w') do |ios|
+        ios.puts body
+      end
+    end
+
+    unless body.match('Copyright')
+      STDERR.puts "Warning: missing boilerplate in #{file}"
+      STDERR.puts body.split($/).first(10).join($/)
+      exit
+    end
+  end
+end

data/examples/fastq_to_fasta.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'BioDSL'
+
+# Read in sequences in FASTQ format from the file `test.fq` and save them in
+# FASTA format in the file `test.fna`.
+
+BP.new.read_fastq(input: "test.fq").write_fasta(output: "test.fna").run

data/lib/BioDSL/cary.rb

@@ -0,0 +1,242 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                  #
+#                                                                                #
+# This program is free software; you can redistribute it and/or                  #
+# modify it under the terms of the GNU General Public License                    #
+# as published by the Free Software Foundation; either version 2                 #
+# of the License, or (at your option) any later version.                         #
+#                                                                                #
+# This program is distributed in the hope that it will be useful,                #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of                 #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                  #
+# GNU General Public License for more details.                                   #
+#                                                                                #
+# You should have received a copy of the GNU General Public License              #
+# along with this program; if not, write to the Free Software                    #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. #
+#                                                                                #
+# http://www.gnu.org/copyleft/gpl.html                                           #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                                #
+# This software is part of BioDSL (www.BioDSL.org).                        #
+#                                                                                #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+module BioDSL
+  # Error class for all exceptions to do with CAry.
+  class CAryError < StandardError; end
+
+  # Class to manipulate a Ruby byte array which is fit for inline C manipulation.
+  class CAry
+    require 'inline'
+
+    attr_reader :count, :size, :ary
+
+    # Class method to store to a given file a given ary.
+    def self.store(file, ary)
+      File.open(file, 'w') do |ios|
+        ios.write([ary.count].pack("I"))
+        ios.write([ary.size].pack("I"))
+        ios.write(ary.ary)
+      end
+
+      nil
+    end
+
+    # Class method to retrieve and return an ary from a given file.
+    def self.retrieve(file)
+      count = nil
+      size  = nil
+      ary   = nil
+
+      File.open(file) do |ios|
+        count = ios.read(4).unpack("I").first
+        size  = ios.read(4).unpack("I").first
+        ary   = ios.read
+      end
+
+      CAry.new(count, size, ary)
+    end
+
+    # Method to initialize a new CAry object which is either empty
+    # or created from a given byte string. Count is the number of
+    # elements in the ary, and size is the byte size of a element.
+    def initialize(count, size, ary = nil)
+      raise CAryError, "count must be positive - not #{count}" if count <= 0
+      raise CAryError, "size must be positive - not #{size}"   if size  <= 0
+
+      @count = count
+      @size  = size
+      @ary   = ary || "\0" * count * size
+    end
+
+    # Method to set all members in an ary to 1.
+    def fill!
+      self.zero!
+      self.~
+    end
+
+    # Method to set all members in an ary to 1.
+    def fill
+      CAry.new(@count, @size).fill!
+    end
+
+    # Method to set all members in an ary to zero.
+    def zero!
+      zero_ary_C(@ary, @count * @size)
+      self
+    end
+
+    # Method to set all members in an ary to zero.
+    def zero
+      CAry.new(@count, @size).zero!
+    end
+
+    # Method to do bitwise AND operation between two CArys.
+    def &(cary)
+      raise BioDSL::CAryError, "Bad object type: #{cary.class}" unless cary.is_a? CAry
+      raise BioDSL::CAryError, "Counts mismatch: #{self.count} != #{cary.count}" if self.count != cary.count
+      raise BioDSL::CAryError, "Sizes mismatch: #{self.size} != #{cary.size}"    if self.size != cary.size
+
+      bitwise_and_C(@ary, cary.ary, @count * @size)
+
+      self
+    end
+
+    # Method to do bitwise OR operation between two CArys.
+    def |(cary)
+      raise BioDSL::CAryError, "Bad object type: #{cary.class}" unless cary.is_a? CAry
+      raise BioDSL::CAryError, "Counts mismatch: #{self.count} != #{cary.count}" if self.count != cary.count
+      raise BioDSL::CAryError, "Sizes mismatch: #{self.size} != #{cary.size}"    if self.size != cary.size
+
+      bitwise_or_C(@ary, cary.ary, @count * @size)
+
+      self
+    end
+
+    # Method to do bitwise XOR operation between two CArys.
+    def ^(cary)
+      raise BioDSL::CAryError, "Bad object type: #{cary.class}" unless cary.is_a? CAry
+      raise BioDSL::CAryError, "Counts mismatch: #{self.count} != #{cary.count}" if self.count != cary.count
+      raise BioDSL::CAryError, "Sizes mismatch: #{self.size} != #{cary.size}"    if self.size != cary.size
+
+      bitwise_xor_C(@ary, cary.ary, @count * @size)
+
+      self
+    end
+
+    # Method to complement all bits in an ary.
+    def ~
+      complement_ary_C(@ary, @count * @size)
+      self
+    end
+
+    # Method that returns a string from an ary.
+    def to_s
+      @ary.unpack('B*').first
+    end
+
+    private
+
+    inline do |builder|
+      # Method that given a byte array and its size in bytes
+      # sets all bytes to 0.
+      builder.c %{
+        void zero_ary_C(
+          VALUE _ary,       // Byte array to zero.
+          VALUE _ary_size   // Size of array.
+        )
+        {
+          char         *ary      = (char *) StringValuePtr(_ary);
+          unsigned int  ary_size = FIX2UINT(_ary_size);
+
+          bzero(ary, ary_size);
+        }
+      }
+
+      # Method that given two byte arrays perform bitwise AND operation
+      # beween these and save the result in the first.
+      builder.c %{
+        void bitwise_and_C(
+          VALUE _ary1,      // Byte array to recieve.
+          VALUE _ary2,      // Byte array to &.
+          VALUE _ary_size   // Size of arrays.
+        )
+        {
+          char         *ary1     = (char *) StringValuePtr(_ary1);
+          char         *ary2     = (char *) StringValuePtr(_ary2);
+          unsigned int  ary_size = FIX2UINT(_ary_size);
+          int           i        = 0;
+
+          for (i = ary_size - 1; i >= 0; i--)
+          {
+            ary1[i] = ary1[i] & ary2[i];
+          }
+        }
+      }
+
+      # Method that given two byte arrays perform bitwise OR operation
+      # beween these and save the result in the first.
+      builder.c %{
+        void bitwise_or_C(
+          VALUE _ary1,      // Byte array to recieve.
+          VALUE _ary2,      // Byte array to &.
+          VALUE _ary_size   // Size of arrays.
+        )
+        {
+          char         *ary1     = (char *) StringValuePtr(_ary1);
+          char         *ary2     = (char *) StringValuePtr(_ary2);
+          unsigned int  ary_size = FIX2UINT(_ary_size);
+          int           i        = 0;
+
+          for (i = ary_size - 1; i >= 0; i--)
+          {
+            ary1[i] = ary1[i] | ary2[i];
+          }
+        }
+      }
+
+      # Method that given two byte arrays perform bitwise XOR operation
+      # beween these and save the result in the first.
+      builder.c %{
+        void bitwise_xor_C(
+          VALUE _ary1,      // Byte array to recieve.
+          VALUE _ary2,      // Byte array to &.
+          VALUE _ary_size   // Size of arrays.
+        )
+        {
+          char         *ary1     = (char *) StringValuePtr(_ary1);
+          char         *ary2     = (char *) StringValuePtr(_ary2);
+          unsigned int  ary_size = FIX2UINT(_ary_size);
+          int           i        = 0;
+
+          for (i = ary_size - 1; i >= 0; i--)
+          {
+            ary1[i] = ary1[i] ^ ary2[i];
+          }
+        }
+      }
+
+      # Method that given a byte array and its size in bytes
+      # complements all bits using bitwise ~.
+      builder.c %{
+        void complement_ary_C(
+          VALUE _ary,       // Byte array complement.
+          VALUE _ary_size   // Size of array.
+        )
+        {
+          char         *ary      = (char *) StringValuePtr(_ary);
+          unsigned int  ary_size = FIX2UINT(_ary_size);
+          int           i        = 0;
+
+          for (i = ary_size - 1; i >= 0; i--)
+          {
+            ary[i] = ~ary[i];
+          }
+        }
+      }
+    end
+  end
+end

data/lib/BioDSL/command.rb

@@ -0,0 +1,133 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of BioDSL (www.github.com/maasha/BioDSL).              #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+module BioDSL
+  # Command class for initiating and calling commands.
+  class Command
+    attr_reader :name, :status, :options
+    attr_accessor :run_status
+
+    # Constructor for Command objects.
+    #
+    # @param name    [Symbol] Name of command.
+    # @param lmb     [Proc]   Lambda for command callback execution.
+    # @param options [Hash]   Options hash.
+    def initialize(name, lmb, options)
+      @name       = name
+      @lmb        = lmb
+      @run_status = 'running'
+      @options    = options
+      @status     = {}
+    end
+
+    # Callback method for executing a Command lambda.
+    #
+    # @param args [Array] List of arguments used in the callback.
+    def call(*args)
+      @lmb.call(*args, @status)
+
+      @run_status         = 'done'
+      @status[:time_stop] = Time.now
+      calc_time_elapsed
+      calc_delta
+    end
+
+    # Return string representation of a Command object.
+    #
+    # @return [String] With formated command.
+    def to_s
+      options_list = []
+
+      @options.each do |key, value|
+        options_list << case value.class.to_s
+                        when 'String'
+                          value = Regexp.quote(value) if key == :delimiter
+                          %(#{key}: "#{value}")
+                        when 'Symbol'
+                          "#{key}: :#{value}"
+                        else
+                          "#{key}: #{value}"
+                        end
+      end
+
+      @options.empty? ? @name : "#{@name}(#{options_list.join(', ')})"
+    end
+
+    # Add a key with time_elapsed to the status.
+    #
+    # @return [BioDSL::Status] returns self.
+    def calc_time_elapsed
+      delta = @status[:time_stop] - @status[:time_start]
+      @status[:time_elapsed] = (Time.mktime(0) + delta).strftime("%H:%M:%S")
+
+      self
+    end
+
+    # Locate all status key pairs <foo>_in and <foo>_out and add a new status
+    # key <foo>_delta with the numerical difference.
+    #
+    # @return [BioDSL::Status] returns self.
+    def calc_delta
+      @status.keys.select { |s| s[-3..-1] == '_in' }.each do |in_key|
+        base    = in_key[0...-3]
+        out_key = "#{base}_out".to_sym
+
+        next unless @status.key? out_key
+
+        @status["#{base}_delta".to_sym]         = delta(in_key, out_key)
+        @status["#{base}_delta_percent".to_sym] = delta_percent(in_key, out_key)
+      end
+
+      self
+    end
+
+    private
+
+    # Calculate the difference between status values given two status keys.
+    #
+    # @param in_key  [Symbol] Status hash key.
+    # @param out_key [Symbol] Status hash key.
+    #
+    # @return [Fixnum] Difference.
+    def delta(in_key, out_key)
+      @status[out_key] - @status[in_key]
+    end
+
+    # Calculate the percent difference between status values given two status
+    # keys.
+    #
+    # @param in_key  [Symbol] Status hash key.
+    # @param out_key [Symbol] Status hash key.
+    #
+    # @return [Float] Percentage rounded to 2 decimals.
+    def delta_percent(in_key, out_key)
+      d = @status[out_key] - @status[in_key]
+
+      return 0.0 if d == 0
+
+      (100 * d.to_f / [@status[out_key], @status[in_key]].max).round(2)
+    end
+  end
+end

data/lib/BioDSL/commands/add_key.rb

@@ -0,0 +1,110 @@
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# Copyright (C) 2007-2015 Martin Asser Hansen (mail@maasha.dk).                #
+#                                                                              #
+# This program is free software; you can redistribute it and/or                #
+# modify it under the terms of the GNU General Public License                  #
+# as published by the Free Software Foundation; either version 2               #
+# of the License, or (at your option) any later version.                       #
+#                                                                              #
+# This program is distributed in the hope that it will be useful,              #
+# but WITHOUT ANY WARRANTY; without even the implied warranty of               #
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                #
+# GNU General Public License for more details.                                 #
+#                                                                              #
+# You should have received a copy of the GNU General Public License            #
+# along with this program; if not, write to the Free Software                  #
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,    #
+# USA.                                                                         #
+#                                                                              #
+# http://www.gnu.org/copyleft/gpl.html                                         #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+#                                                                              #
+# This software is part of the BioDSL framework (www.BioDSL.org).        #
+#                                                                              #
+# >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< #
+
+module BioDSL
+  # == Add a key/value pair to all records in stream.
+  #
+  # +add_key+ can be used to add a fixed value to a specified key to all
+  # records in the stream, or add a numeric forth running number (zero-based)
+  # with a specified prefix.
+  #
+  # == Usage
+  #
+  #    add_key(<key: <string>[, value: <string> | prefix: <string>])
+  #
+  # === Options
+  #
+  # * key: <string>    - Key to add or overwrite.
+  # * value: <string>  - Value to use with +key+.
+  # * prefix: <string> - Prefix to use with +key+.
+  #
+  # == Examples
+  #
+  # To add a value to all records in the stream do:
+  #
+  #    add_key(key: "FOO", value: "BAR")
+  #
+  # To add a forth running number to all records in the stream do:
+  #
+  #    add_key(key: :ID, prefix: "")
+  #
+  # Finally, to add a forth running number with a prefix do:
+  #
+  #    add_key(key: :ID, prefix: "ID_")
+  class AddKey
+    STATS = %i(records_in records_out)
+
+    # Constructor for AddKey.
+    #
+    # @param [Hash] options Options hash.
+    # @option options [Symbol] :key    Key to add or replace.
+    # @option options [String] :value  Value to use with :key.
+    # @option options [String] :prefix Prefix to use with :key.
+    #
+    # @return [Proc] Returns class instance.
+    def initialize(options)
+      @options = options
+
+      check_options
+    end
+
+    # Add a key or replace a key for all records with a specified value or a
+    # forthrunning number with a prefix.
+    #
+    # @param [Hash] options Options hash.
+    # @option options [Symbol] :key    Key to add or replace.
+    # @option options [String] :value  Value to use with :key.
+    # @option options [String] :prefix Prefix to use with :key.
+    #
+    # @return [Proc] Returns the command lambda.
+    def lmb
+      lambda do |input, output, status|
+        status_init(status, STATS)
+
+        input.each_with_index do |record, i|
+          @status[:records_in] += 1
+
+          record[@options[:key].to_sym] = @options[:value] ||
+                                          "#{@options[:prefix]}#{i}"
+
+          output << record
+
+          @status[:records_out] += 1
+        end
+      end
+    end
+
+    private
+
+    # Check all options.
+    def check_options
+      options_allowed(@options, :key, :value, :prefix)
+      options_required(@options, :key)
+      options_required_unique(@options, :value, :prefix)
+    end
+  end
+end