mgnu 2.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f41f975c84c1e898266e72770b0ba76c8ab4d42d3c50d53944bc4ddd74e1e0aa
+  data.tar.gz: 646a09a7ff525576d25ceb3e3b4250259263b418be11a2b24a5429cebec752c4
+SHA512:
+  metadata.gz: b1945190d6d72e495e0eabe909122c8db9afe6fde8aff015af4d8b4d53298741cdeda8ba5351c2010524c623ce5ee869c3f7b2a2417dabbb8ebf6e0226893e58
+  data.tar.gz: 5600bc2b2cf0f3bec4f619261a9c230265d29c0e809a044391bcaf098dcd132c2bb735599e6a224c039efd4201fa2e6ab444f5f4f4fa93fa6c395a261ebbb95d

data/README.md

@@ -0,0 +1,31 @@
+<<<<<<< HEAD
+# mgnu
+Metagenomi Nu, a fast and small bioinformatics support library
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mgnu'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mgnu
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/mgnu/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 a new Pull Request

data/Rakefile

@@ -0,0 +1,33 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+Bundler::GemHelper.install_tasks
+
+THRESHOLD_MIN = 70.0
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :test => :spec
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+  task :rubocop do
+    $stderr.puts 'Rubocop is disabled'
+  end
+end
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+require 'yardstick/rake/measurement'
+Yardstick::Rake::Measurement.new do |measurement|
+  measurement.output = 'measurement/report.txt'
+end
+
+require 'yardstick/rake/verify'
+Yardstick::Rake::Verify.new do |verify|
+  verify.threshold = THRESHOLD_MIN
+end
+
+task :default => [:spec] #, :rubocop, :verify_measurements]

data/lib/mgnu.rb

@@ -0,0 +1,9 @@
+module Nu
+  require 'mgnu/version'
+  require 'mgnu/loggable'
+  require 'mgnu/common'
+  require 'mgnu/sequence'
+  require 'mgnu/alignment'
+  require 'mgnu/parser'
+  require 'mgnu/genbank'
+end

data/lib/mgnu/alignment.rb

@@ -0,0 +1,143 @@
+module MgNu
+  class Alignment
+    include Enumerable
+    StrongConservationGroups = %w(STA NEQK NHQK NDEQ QHRK MILV MILF HY FYW).collect { |x| x.split('').sort }
+    WeakConservationGroups = %w(CSA ATV SAG STNK STPA SGND SNDEQK NDEQHK NEQHRK FVLIM HFY).collect { |x| x.split('').sort }
+
+    attr_reader :length
+    attr_accessor :sequences, :order
+
+    # create a new Alignment object
+    def initialize(sequences, order = nil)
+      @sequences = sequences
+      @order = order
+      @length = sequences[sequences.keys[0]].length
+    end
+
+    # override each
+    def each
+      if @order.nil?
+        @sequences.each do |name, seq|
+          yield seq
+        end
+      else
+        @order.each do |name|
+          yield @sequences[name]
+        end
+      end
+    end
+
+    # Returns an array of arrays containing the sequences at the position indicated.
+    # Can take a range
+    def each_position(range = nil)
+      matrix = []
+      if @order.nil?
+        @sequences.each do |name, seq|
+          if range.class == Range
+            matrix.push(seq[range].split(//))
+          elsif range.class == Integer
+            matrix.push(seq[range])
+          else
+            matrix.push(seq.split(//))
+          end
+        end
+      else
+        @order.each do |name|
+          if range.class == Range
+            # correct for 0 indexed arrays
+            matrix.push(@sequences[name][(range.begin - 1..range.end - 1)].split(//))
+          elsif range.class == Integer
+            matrix.push(@sequences[name][range - 1].chr)
+          else
+            matrix.push(@sequences[name].split(//))
+          end
+        end
+      end
+
+      positions = []
+      if range.class == Range
+        range.each do |pos|
+          position = []
+          matrix.each do |seq|
+            position.push(seq[(pos - 1) - (range.begin - 1)])
+          end
+          positions << position
+          if block_given?
+            yield position
+          end
+        end
+        unless block_given?
+          positions
+        end
+      elsif range.class == Integer
+        position = []
+        matrix.each do |seq|
+          position.push(seq)
+        end
+        positions << position
+        if block_given?
+          yield position
+        end
+        unless block_given?
+          positions
+        end
+      else
+        0.upto(@length-1) do |pos|
+          position = []
+          matrix.each do |seq|
+            position.push(seq[pos])
+          end
+          positions << position
+          if block_given?
+            yield position
+          end
+        end
+        unless block_given?
+          positions
+        end
+      end
+    end
+
+    def [](range = nil)
+      each_position(range)
+    end
+
+    def match(range = nil)
+      # get the matrix for the whole alignment, or a portion if a
+      # range is given
+      m = each_position(range) 
+      str = ""
+
+      # go through every row (position) in the array from
+      # each_position and compute the match symbol.  Concat to str
+      m.each do |pos|
+        # if there's a gap in the alignment at this pos, return a space
+        if pos.index("-") != nil
+          str += " "
+        else
+          # no gaps, so determine strength of column
+          p = pos.collect { |c| c.upcase }.sort.uniq
+          if p.length == 1
+            str += "*"
+          elsif StrongConservationGroups.find { |x| (p - x).empty? }
+            str += ":"
+          elsif WeakConservationGroups.find { |x| (p - x).empty? }
+            str += "."
+          else
+            str += " "
+          end
+        end
+      end
+      str
+    end
+
+    def to_s
+      str = ""
+      self.order.each do |name|
+        str += "#{name}: #{self.sequences[name]}\n"
+      end
+      str += self.match + "\n"
+      str
+    end
+  end # end MgNu::Alignment class
+end # end MgNu module

data/lib/mgnu/common.rb

@@ -0,0 +1,68 @@
+module MgNu
+  # codon table 11 from http://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi
+  # standard bacteria/archae/plastid codes
+  BACTERIA_CODONS = {'ttt' => 'F', 'tct' => 'S', 'tat' => 'Y', 'tgt' => 'C',
+                     'ttc' => 'F', 'tcc' => 'S', 'tac' => 'Y', 'tgc' => 'C',
+                     'tta' => 'L', 'tca' => 'S', 'taa' => '*', 'tga' => '*',
+                     'ttg' => 'L', 'tcg' => 'S', 'tag' => '*', 'tgg' => 'W',
+
+                     'ctt' => 'L', 'cct' => 'P', 'cat' => 'H', 'cgt' => 'R',
+                     'ctc' => 'L', 'ccc' => 'P', 'cac' => 'H', 'cgc' => 'R',
+                     'cta' => 'L', 'cca' => 'P', 'caa' => 'Q', 'cga' => 'R',
+                     'ctg' => 'L', 'ccg' => 'P', 'cag' => 'Q', 'cgg' => 'R',
+
+                     'att' => 'I', 'act' => 'T', 'aat' => 'N', 'agt' => 'S',
+                     'atc' => 'I', 'acc' => 'T', 'aac' => 'N', 'agc' => 'S',
+                     'ata' => 'I', 'aca' => 'T', 'aaa' => 'K', 'aga' => 'R',
+                     'atg' => 'M', 'acg' => 'T', 'aag' => 'K', 'agg' => 'R',
+
+                     'gtt' => 'V', 'gct' => 'A', 'gat' => 'D', 'ggt' => 'G',
+                     'gtc' => 'V', 'gcc' => 'A', 'gac' => 'D', 'ggc' => 'G',
+                     'gta' => 'V', 'gca' => 'A', 'gaa' => 'E', 'gga' => 'G',
+                     'gtg' => 'V', 'gcg' => 'A', 'gag' => 'E', 'ggg' => 'G'}
+end
+
+# example usage of Regexp#global_match
+# re = /(\w+)/
+# words = []
+# re.global_match("cat dog house") do |m|
+#   words.push(m[0])
+# end
+# p words # ["cat", "dog", "house"]
+class Regexp
+  def global_match(str, &proc)
+    retval = nil
+    loop do
+      res = str.sub(self) do |m|
+        proc.call($~) # pass MatchData obj
+        ''
+      end
+      break retval if res == str
+      str = res
+      retval ||= true
+    end
+  end # end of global_match
+end # end of Regexp class
+
+# add print_multiline method to String class
+class String
+  def print_multiline(width=80, options={})
+    return unless self.length > 0
+    indent = ' ' * (options[:indent] || 12)
+    x = width - indent.length
+    # string broken up with spaces or solid string
+    split_str = self.scan(/(.{1,#{x}})(?: +|$)\n?|(.{#{x}})/)
+    out = ''
+    # print first line without indent
+    out += split_str.first[0] || split_str.first[1]
+
+    if split_str.length > 1
+      out += "\n"
+    end
+    # print all other lines with indent
+    out += split_str[1..-1].map do |str, other|
+      "#{indent}#{str || other}"
+    end.join("\n")
+    out
+  end # end of print_multiline
+end

data/lib/mgnu/genbank.rb

@@ -0,0 +1,117 @@
+require 'forwardable'
+require 'mgnu/genbank/feature'
+require 'mgnu/genbank/location'
+require 'mgnu/genbank/qualifier'
+require 'mgnu/genbank/reference'
+require 'mgnu/genbank/source'
+
+module MgNu
+  class Genbank
+    attr_accessor :locus, :definition, :accession, :secondary_accession, :version, :dblink
+    attr_accessor :geninfo_identifier, :keywords, :segment, :source, :references, :comment
+    attr_accessor :features, :sequence
+    include MgNu::Loggable
+    extend Forwardable
+
+    STRUCTURE = [:locus, :definition, :accession, :version, :dblink,
+                 :keywords, :segment, :source, :references, :comment,
+                 :features, :sequence]
+
+    Locus = Struct.new :name, :length, :no_of_strands, :molecule_type, :molecule_structure, :genbank_division, :modification_date  do
+      def to_s
+        str = ''
+        str << 'LOCUS'.ljust(12) # 1-12
+        str << name.ljust(17) # 13-29
+        str << length.rjust(11) # 30-41
+        str << ' bp ' # 41-44
+        str << "#{no_of_strands}".ljust(3) # ss- ds- ms-, 45-47
+        str << "#{molecule_type}".ljust(8) # 48-55
+        str << "#{molecule_structure}".ljust(8) # linear or circular, 56-63
+        str << " #{genbank_division} " # 65-68
+        str << modification_date # 69
+      end
+    end
+
+    # create a new Genbank object
+    def initialize
+      @locus               = nil
+      @definition          = ''
+      @accession           = ''
+      @secondary_accession = []
+      @dblink              = ''
+      @version             = ''
+      @geninfo_identifier  = ''
+      @keywords            = nil
+      @segment             = ''
+      @source              = nil
+      @references          = []
+      @comment             = ''
+      @features            = []
+      @sequence            = ''
+    end
+
+    def_delegators :@locus, :name, :length, :no_of_strands, :molecule_type
+    def_delegators :molecule_structure, :genbank_division, :modification_date
+
+    # string representation
+    def to_s
+      str = ''
+      STRUCTURE.each do |part|
+        p = send(part)
+        p_exists = false
+        case part
+        when :locus, :source
+          if p
+            p_exists = true
+            str << p.to_s
+          end
+        when :definition, :dblink, :segment, :comment
+          if p && !p.empty?
+            p_exists = true
+            str << part.to_s.upcase.ljust(12)
+            str << p.print_multiline
+            str << '.' if part == :definition
+          end
+        when :accession
+          if p && !p.empty?
+            p_exists = true
+            str += 'ACCESSION'.ljust(12)
+            str += accession
+            if secondary_accession.any?
+              str += " #{secondary_accession.join(' ')}"
+            end
+          end
+        when :version
+          if p && !p.empty?
+            p_exists = true
+            str += 'VERSION'.ljust(12)
+            str += version
+            str += "  GI:#{geninfo_identifier}" if geninfo_identifier
+          end
+        when :features, :references
+          unless p.empty?
+            p_exists = true
+            str += "FEATURES             Location/Qualifiers\n" if part == :features
+            temp = p.collect { |x| x.to_s }
+            str += temp.join("\n")
+          end
+        when :sequence
+          unless p.value.empty?
+            p_exists = true
+            str << "#{'ORIGIN'.ljust(12)}\n"
+            str << @sequence.to_genbank
+          end
+        when :keywords
+          p_exists = true
+          str << 'KEYWORDS'.ljust(12)
+          str << p.join('; ').print_multiline if p
+          str << '.'
+        end
+        # print newline character if there are more parts
+        str << "\n" if p_exists && STRUCTURE[STRUCTURE.index(part) + 1]
+      end
+      str << '//'
+    end
+  end # end of MgNu::Parser::Genbank class
+end # end of MgNu module
+__END__

data/lib/mgnu/genbank/feature.rb

@@ -0,0 +1,84 @@
+module MgNu
+  class Genbank
+    class Feature
+      attr_accessor :feature_type, :qualifiers, :location, :sequence
+      attr_accessor :start_continues, :stop_continues, :raw_qualifiers
+
+      # create a new Feature object
+      def initialize
+        @qualifiers = []
+        @raw_qualifiers = []
+      end
+
+      # for handling tags in gb format
+      def method_missing(method_name, *args)
+        quals = @qualifiers.select {|q| q.name == method_name.to_s}
+        if quals.length > 1
+          return quals.map {|q| q.value }
+        elsif quals.length == 1
+          return quals.first.value
+        else
+          return nil
+        end
+      end
+
+      # class method for parsing a gb entry in a buffer
+      def self.parse(buffer)
+        buffer = buffer.split("\n")
+        feature = Feature.new # create a new feature
+        buffer.each_with_index do |line,i|
+          if line =~ /^\s{5}([\w\-\*']+)\s+(.+)$/ #feature type and (beginning of) location line
+            feature.feature_type = Regexp.last_match[1]
+            loc = Regexp.last_match[2]
+
+            until buffer[i + 1] =~ /\/.+=.+/ # check for a continuation of Location line
+              break unless buffer[i+1]
+              loc += buffer[i + 1].lstrip!
+              buffer.delete_at(i + 1)
+            end
+            feature.location = Location.new(loc)
+          elsif line =~ /^\s{21}\/(.+)=(.+)$/
+            key, value = Regexp.last_match[1], Regexp.last_match[2]
+
+            # to handle multi-line qualifier values
+            until buffer[i+1] =~ /^\s{21}\/(?:.+?)=/ # next qualifier
+              break unless buffer[i + 1]
+              value += " #{buffer[i + 1].lstrip}"
+              buffer.delete_at(i + 1)
+            end
+            # parse out quotes
+            quoted = false
+            if value =~ /^"(.+)"$/
+              value = Regexp.last_match[1]
+              quoted = true # some qualifier values are part of a controlled vocabulary and, as such, unquoted
+            end
+            # make sure sequence contains no spaces
+            if key == 'translation'
+              value.gsub!(/\s/, '');
+            end
+            # add new qualifier to feature
+            feature.qualifiers << Qualifier.new(:name => key, :value => value.squeeze(' '), :quoted => quoted)
+          elsif line =~ /^\s{21}\/(.+)$/ # qualifier name w/out value
+            key = Regexp.last_match[1]
+            feature.qualifiers << Qualifier.new(:name => key)
+          else
+            raise "UNKNOWN FEATURE LINE TYPE: #{line} -- #{i}"
+          end
+        end # end loop through buffer
+        feature
+      end
+
+      # string representation of Feature
+      def to_s
+        out = ''
+        out += ' ' * 5
+        out += feature_type.ljust(16)
+        out += location.to_s
+        qualifiers.each do |q|
+          out += q.to_s
+        end
+        out 
+      end
+    end # end MgNu::Genbank::Feature class
+  end # end MgNu::Genbank class
+end # end MgNu module