mgnu 2.1.1

data/lib/mgnu/parser/sam/alignment.rb

@@ -0,0 +1,22 @@
+module MgNu
+  module Parser
+    class Sam
+      class Alignment
+        attr_accessor :name, :flag, :hit, :position, :quality, :cigar, :mate_ref
+        attr_accessor :mate_pos, :distance, :sequence, :query_qual, :other
+        
+        # create a new Alignment object
+        def initialize(attributes = {})
+          self.attributes = attributes
+        end
+
+
+        def attributes=(attributes = {})
+          attributes.each do |attr,value|
+            self.send("#{attr}=", value) if self.respond_to?("#{attr}=")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mgnu/parser/sam/header.rb

@@ -0,0 +1,23 @@
+module MgNu
+  module Parser
+    class Sam
+      class Header
+        include MgNu::Loggable
+
+        attr_accessor :vn, :so, :sq, :rg, :pg, :co
+
+        # create a new Header object
+        def initialize(options)
+          options = {
+            :vn => options.has_key?(:vn) ? options[:vn] : nil,
+            :so => options.has_key?(:so) ? options[:so] : nil,
+            :sq => options.has_key?(:sq) ? options[:sq] : nil,
+            :rg => options.has_key?(:rg) ? options[:rg] : nil,
+            :pg => options.has_key?(:pg) ? options[:pg] : nil,
+            :co => options.has_key?(:co) ? options[:co] : nil,
+          }.merge!(options)
+        end
+      end
+    end
+  end
+end

data/lib/mgnu/parser/sam/pair.rb

@@ -0,0 +1,18 @@
+module MgNu
+  module Parser
+    module Sam
+      class Pair
+      	
+      	attr_accessor :name, :first, :second
+
+        # create a new Pair object
+      	def initialize(name, first, second)
+      		@name = name
+      		@first = first
+      		@second = second
+      	end
+
+      end
+    end
+  end
+end

data/lib/mgnu/sequence.rb

@@ -0,0 +1,207 @@
+require 'strscan'
+require_relative 'sequence/fasta'
+require_relative 'sequence/fastq'
+
+module MgNu
+  class Sequence
+    attr_accessor :type, :value
+
+    def initialize(options)
+      options = {:value => nil, :type => nil}.merge! options
+      @value = options[:value]
+      @value = options[:sequence] if options.key?(:sequence)
+      @type = options[:type]
+    end
+
+    alias_method :sequence, :value
+    alias_method :sequence=, :value=
+
+    def rna?
+      @type == 'rna' ? true : false
+    end
+
+    def dna?
+      @type == 'dna' ? true : false
+    end
+
+    def aa?
+      @type == 'aa' || @type == 'aminoacid' || @type == 'protein' ? true : false
+    end
+
+    alias_method :protein?, :aa?
+    alias_method :aminoacid?, :aa?
+
+    def length
+      @value.nil? ? nil : @value.length
+    end
+
+    # returns a string
+    def complement
+      if @type == 'rna'
+        @value.tr('ucgtrymkdhvbUCGTRYMKDHVB', 'agcuyrkmhdbvAGCUYRKMHDBV')
+      else
+        @value.tr('acgtrymkdhvbACGTRYMKDHVB', 'tgcayrkmhdbvTGCAYRKMHDBV')
+      end
+    end
+
+    # changes sequence @value
+    def complement!
+      @value = complement
+    end
+
+    def reverse_complement
+      complement.reverse
+    end
+    alias_method :revcomp, :reverse_complement
+
+    def reverse_complement!
+      @value = complement.reverse
+    end
+    alias_method :revcomp!, :reverse_complement!
+
+    def translate(frame = 1, cdn_table = MgNu::BACTERIA_CODONS)
+      from, sequence = nil, @value
+
+      case frame
+      when 1, 2, 3
+        from = frame - 1
+      when 4, 5, 6
+        from = frame - 4
+        sequence = reverse_complement
+      when -1, -2, -3
+        from = -1 - frame
+        sequence = reverse_complement
+      else
+        $stderr.puts 'unknown frame - defaulting to zero (0)'
+        from = 0
+      end
+
+      nalen = sequence.length - from
+      nalen -= nalen % 3
+      sequence[from, nalen].downcase.gsub(/.{3}/) { |codon| cdn_table[codon] || 'X' }
+    end
+
+    def translate!(frame = 1, cdn_table = MgNu::BACTERIA_CODONS)
+      @value = translate(frame, cdn_table)
+    end
+
+    def to_s(cols = 60)
+      seq = ''
+      if @value.length < cols
+        seq = @value
+      else
+        0.step(@value.length, cols) { |segment| seq += @value[segment, cols] + "\n" }
+      end
+      seq
+    end
+
+    # Genbank formatted sequence 6 cols w/10 letters each, right justified line numbers
+    #   1 tcctgatctc ctttatagca ctttccgtga aaattgccaa gcgacctgca tgagttccgg
+    #  61 gagcgagaac ttctgcattt aactcacgag gagtaacaat atccactcca ggcagattcc
+    # 121 tgaaaccctt cagaacatta tccttgttgg atacaactat caaaacgctc ttctttttct
+    def to_genbank
+      i = 1
+      result = @value.gsub(/.{1,60}/) do |s|
+        s = s.gsub(/.{1,10}/, ' \0')
+        y = format('%9d%s\n', i, s)
+        i += 60
+        y
+      end
+      result
+    end
+
+    # returns an array of 1-based positon ranges after splitting on N-blocks > length
+    def nblocks(length = 10)
+      pieces = []
+      prev = 1
+      seq = StringScanner.new(value) # the sequence
+      while seq.scan_until(/[Nn]{#{length},}/) # only splits at N stitches that are >10, but that can be changed
+        pieces << (prev .. seq.pos - seq.matched.length)
+        prev = seq.pos + 1
+      end
+      pieces << (prev .. value.length) # add last piece
+      pieces
+    end
+
+    def levenshtein_distance(other)
+      # initialize
+      a, b, m = '', '', []
+
+      # one or the other strings are empty or the strings are the same
+      return -1 if @value.nil? || @value == ''
+      a = @value.upcase
+
+      if other.class == MgNu::Sequence
+        return -1 if other.value == '' || other.value.nil?
+        b = other.value.upcase
+        return 0 if other.value.upcase == @value.upcase
+      elsif other.class == String
+        return -1 if other == ''
+        b = other.upcase
+        return 0 if other.upcase == @value.upcase
+      end
+
+      0.upto(a.length) { |x| m[x] = [x] }
+      1.upto(b.length) { |x| m[0] << x }
+
+      1.upto(a.length) do |x|
+        1.upto(b.length) do |y|
+          cost = a[x - 1] == b[y - 1] ? 0 : 1
+          m[x][y] = [m[x - 1][y] + 1, m[x][y - 1] + 1, m[x - 1][y - 1] + cost].min
+        end
+      end
+      m[-1][-1]
+    end # end of levenshtein_distance
+
+    alias_method :distance, :levenshtein_distance
+
+    def percent_identity(other)
+      # one or the other strings are empty or the strings are the same
+      return -1 if @value.nil? || @value == ''
+      a = @value
+      b = ''
+
+      if other.class == MgNu::Sequence
+        return -1 if other.value == '' || other.value.nil?
+        b = other.value
+        return 1.0 if other.value == @value
+      elsif other.class == String
+        return -1 if other == ''
+        b = other
+        return 1.0 if other == @value
+      end
+
+      if a.length != b.length
+        warn('lengths differ - percent identity may is probably inaccurate')
+      end
+
+      match = 0
+      a.split(//).each_with_index do |char, i|
+        match += 1 if char.upcase == b[i].chr.upcase
+      end
+
+      a.length >= b.length ?  match / a.length.to_f : match / b.length.to_f
+    end # end of percent_identity
+
+    alias_method :identity, :percent_identity
+
+    def gc_content
+      return -1 if @value == '' || @value.nil?
+      base2count = {'A' => 0, 'C' => 0, 'G' => 0, 'T' => 0, 'U' => 0,
+                    'R' => 0, 'Y' => 0, 'M' => 0, 'K' => 0, 'W' => 0,
+                    'S' => 0, 'B' => 0, 'D' => 0, 'H' => 0, 'V' => 0}
+      temp = @value.split(//)
+      temp.each do |base|
+        next if base == '*' || base.upcase == 'N'
+        if base2count.key?(base.upcase)
+          base2count[base.upcase] += 1
+        else
+          $stderr.puts "Unknown character #{base.upcase}"
+        end
+      end
+      gc = base2count['G'] + base2count['C'] + base2count['R'] + base2count['K'] + base2count['S'] + base2count['B'] + base2count['D'] + base2count['V']
+      total = base2count.values.inject(0) { |a, e| a + e.nil? ? 0 : e }
+      format('%.4f', (gc.to_f / total.to_f))
+    end
+  end # end of Sequence class
+end # end of MgNu  module

data/lib/mgnu/sequence/fasta.rb

@@ -0,0 +1,79 @@
+#require 'mgnu/sequence'
+
+module MgNu
+  class Sequence
+    class Fasta < Sequence
+      attr_accessor :header, :header_name, :header_description
+
+      # create a new MgNu::Sequence::Fasta object
+      def initialize(options)
+        super(options)
+        options = {:header => nil}.merge! options
+        @header = options[:header]
+        temp = @header.split
+        @header_name = temp.shift
+        @header_description = temp.length > 0 ? temp.join(' ') : nil
+      end
+
+      # split sequence into columns
+      def sequence_by_columns(cols = 60)
+        seq = ''
+        if length < cols
+          seq << sequence
+        else
+          0.step(length, cols) { |segment| seq << sequence[segment, cols] << "\n" }
+        end
+        seq
+      end
+
+      # override to_s string representation
+      def to_s(cols = 60)
+        seq = ''
+        if sequence =~ /\d+\s+\d+/
+          # this is a fasta quality sequence
+          scores = sequence.split(/\s+/)
+          buffer = []
+          while scores.length > 0
+            score = scores.shift
+            if buffer.length == 17
+              seq << "#{buffer.join(' ')}\n"
+              buffer.clear
+              buffer << score
+            else
+              buffer << score
+            end
+          end
+          seq << "#{buffer.join(' ')}\n" if buffer.length > 0
+        else
+          if cols == -1       # don't break the sequence up
+            seq = sequence
+          else
+            seq = length < cols ? sequence : sequence_by_columns(cols)
+          end
+        end
+        ">#{@header}\n#{seq}"
+      end
+
+      # find runs of N characters in the sequence and split
+      def split_on_n(min_n = 10)
+        count = 0
+        sequence_chunks = []
+        sequence.split(/[nN]{#{min_n},}/).each do |chunk|
+          sequence_chunks << chunk
+          count += 1
+        end
+
+        if count > 1
+          outstr = ''
+          sequence_chunks.each_with_index do |chunk, i|
+            outstr << ">#{@header_name}_#{i + 1} #{@header_description}\n"
+            outstr << "#{chunk}\n"
+          end
+          outstr
+        else
+          to_s
+        end
+      end
+    end # end of Fasta class
+  end # end of Sequence class
+end # end of MgNu module

data/lib/mgnu/sequence/fastq.rb

@@ -0,0 +1,43 @@
+#require 'mgnu/sequence'
+
+module MgNu
+  class Sequence
+    class Fastq < Sequence
+      attr_accessor :header, :header_name, :header_description
+      attr_accessor :quality, :qualhdr, :qualary, :offset
+
+      # create a new MgNu::Sequence::Fastq object
+      def initialize(options)
+        super(options)
+        options = {:offset => 64, :header => nil, :quality => nil}.merge! options
+        @quality = options[:quality]
+        @offset = options[:offset]
+        @header = options[:header]
+        temp = @header.split
+        @header_name = temp.shift
+        @header_description = temp.length > 0 ? temp.join(' ') : nil
+        @qualhdr = options[:qualhdr] if options[:qualhdr]
+      end
+
+      def to_fasta
+        MgNu::Sequence::Fasta.new(:header => @header, :sequence => sequence)
+      end
+
+      # override to_s representation
+      def to_s
+        "@#{@header}\n#{sequence}\n+\n#{@quality}\n"
+      end
+
+      # Unpack the quality string and return an array of
+      #  offset-corrected integers
+      # @params [Integer] offset platform dependent offset value to
+      #  substract from the quality score, defaults to most recent
+      #  platform (i.e. illumina)
+      #  (64)
+      # @return [Array] the array of integers
+      def unpack_quality # only compute this one time
+        @quality.unpack('C*').map! { |x| x - @offset }
+      end
+    end # end of Fastq class
+  end # end of Sequence class
+end # end of MgNu module

data/lib/mgnu/version.rb

@@ -0,0 +1,16 @@
+module MgNu
+  class Version
+    MAJOR = 2
+    MINOR = 1
+    PATCH = 1
+    PRE = nil
+    class << self
+      # string representation of the version
+      #
+      # @return [String]
+      def to_s
+        [MAJOR, MINOR, PATCH, PRE].compact.join('.')
+      end
+    end
+  end
+end

data/mgnu.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'mgnu/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "mgnu"
+  spec.version       = MgNu::Version
+  spec.authors       = ["Brian C. Thomas"]
+  spec.email         = ["bct.x42@gmail.com"]
+  spec.summary       = %q{MgNu Ruby Bioinformatics Library}
+  spec.description   = %q{Lightweight ruby bioinformatics library}
+  spec.homepage      = "http://www.metagenomi.co"
+  spec.license       = "MIT"
+
+  # spec.files         = `git ls-files -z`.split("\x0")
+  spec.files = %w(.yardopts README.md Rakefile mgnu.gemspec)
+  spec.files += Dir.glob('lib/**/*.rb')
+  spec.files += Dir.glob('spec/**/*')
+
+
+  # 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"]
+
+  spec.add_dependency('naught', '~> 0.0', '>= 0.0.1')
+  spec.add_dependency('moneta', '~> 0.0', '>= 0.0.1')
+  spec.add_dependency('tokyocabinet', '~> 1.29', '>= 1.29.1')
+  spec.add_dependency('ox', '~> 2.8', '>= 2.8.2')
+  spec.add_dependency('memoizable', '~> 0.0', '>= 0.0.1')
+  spec.add_dependency('yard', '~> 0.9', '>= 0.9.11')
+  spec.add_dependency('rake', '~> 12.0', '>= 12.0.0')
+  spec.add_development_dependency('mime-types', '~> 0.0', '> 0.0.1')
+  spec.add_development_dependency('rspec', '~> 0.0', '> 0.0.1')
+  spec.add_development_dependency('rubocop', '~> 0.49', '>= 0.49.0')
+  spec.add_development_dependency('timecop', '~> 0.0', '> 0.0.1')
+  spec.add_development_dependency('yardstick', '~> 0.0', '> 0.0.1')
+  spec.add_development_dependency('simplecov', '~> 0.0', '> 0.0.1')
+end