bio-tm_hmm 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-19mode
+#  - 1.8.7
+#  - jruby-18mode # JRuby in 1.8 mode
+#  - rbx-18mode
+
+# uncomment this line if your project needs to run something other than `rake`:
+# script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "shoulda", ">= 0"
+  gem "rdoc", "~> 3.12"
+  gem "jeweler", "~> 1.8.3"
+  gem "bundler", ">= 1.0.21"
+  gem "bio", ">= 1.4.2"
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Ben J Woodcroft
+
+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.rdoc

@@ -0,0 +1,56 @@
+= bio-tm_hmm
+
+{<img
+src="https://secure.travis-ci.org/wwood/bioruby-tm_hmm.png"
+/>}[http://travis-ci.org/#!/wwood/bioruby-tm_hmm]
+
+A bioruby plugin for running TMHMM automatically on multiple sequences in a FASTA file and manipulation of the results
+
+Note: this software is under active development!
+
+== Installation
+
+        gem install bio-tm_hmm
+
+== Usage
+
+  bio-tm_hmm my.fasta
+
+Where my.fasta is a FASTA file with one or more protein sequences in it. Output will be a description of the transmembrane domains predicted by TMHMM.
+
+Other options include -f for printing out the fasta sequences that have some number of transmembrane domains in them, and ignoring those that done (converse is -g)
+
+  bio-tm_hmm -f 2 <my.fasta
+
+== Developers
+
+To use the library 
+
+        require 'bio-tm_hmm'
+
+The API doc is online. For more code examples see also the test files in
+the source tree.
+        
+== Project home page
+
+Information on the source tree, documentation, issues and how to contribute, see
+
+  http://github.com/wwood/bioruby-tm_hmm
+
+The BioRuby community is on IRC server: irc.freenode.org, channel: #bioruby.
+
+== Cite
+
+  If you use this software, please cite one of
+ 
+* [BioRuby: bioinformatics software for the Ruby programming language](http://dx.doi.org/10.1093/bioinformatics/btq475)
+* [Biogem: an effective tool-based approach for scaling up open source software development in bioinformatics](http://dx.doi.org/10.1093/bioinformatics/bts080)
+
+== Biogems.info
+
+This Biogem is published at http://biogems.info/index.html#bio-tm_hmm
+
+== Copyright
+
+Copyright (c) 2012 Ben J Woodcroft. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "bio-tm_hmm"
+  gem.homepage = "http://github.com/wwood/bioruby-tm_hmm"
+  gem.license = "MIT"
+  gem.summary = %Q{A bioruby plugin for interaction with the transmembrane predictor TMHMM}
+  gem.description = %Q{A bioruby plugin for interaction with the transmembrane predictor TMHMM}
+  gem.email = "donttrustben@gmail.com"
+  gem.authors = ["Ben J. Woodcroft"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "bio-tm_hmm #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/bio-tm_hmm

@@ -0,0 +1,69 @@
+#!/usr/bin/env ruby
+
+# Author:: Ben J. Woodcroft
+# Copyright:: 2011
+# License:: The Ruby License
+
+require 'rubygems'
+require 'bio'
+require 'bio-tm_hmm'
+require 'optparse'
+
+# If being run directly instead of being require'd,
+# output one transmembrane per line, and
+# indicate that a particular protein has no transmembrane domain
+options = {
+  :filter_in => false,
+  :filter_out => false,
+}
+o = OptionParser.new do |opts|
+  opts.banner = ['',
+    'Usage: tm_hmm_wrapper.rb [-fg] [fasta_filename]','',
+    "\tfasta file can also be piped in on STDIN.",
+    "\twithout arguments, a description of the transmembranes is printed out for each input sequence",''
+  ].join("\n")
+  opts.on('-f','--filter-in [MIN_TRANSMEMBRANE_DOMAINS]','Print those sequences that have a transmembrane domain. If MIN_TRANSMEMBRANE_DOMAINS is defined, only those proteins with that many TMDs or more are printed out') do |m|
+    options[:filter_in] = m.to_i #gets set to 0 when optional MIN_TRANSMEMBRANE_DOMAINS is omitted
+  end
+  opts.on('-g','--filter-out [MIN_TRANSMEMBRANE_DOMAINS]','Print those sequences that do NOT have a transmembrane domain. If MIN_TRANSMEMBRANE_DOMAINS is defined, only those proteins with that many TMDs or more are filtered out') do |m|
+    options[:filter_out] = m.to_i #gets set to 0 when optional MIN_TRANSMEMBRANE_DOMAINS is omitted
+  end
+end
+o.parse!
+
+runner = Bio::TMHMM::TmHmmWrapper.new
+
+Bio::FlatFile.auto(ARGF).each do |seq|
+  result = runner.calculate(seq.seq)
+  name = seq.definition
+
+  # Default output - a description of the TMDs for each input aaseq
+  if options[:filter_in] == false and options[:filter_out] == false
+    if result.has_domain?
+      # At least one TMD found. Output each on a separate line
+      result.transmembrane_domains.each do |tmd|
+        puts [
+        name,
+        result.transmembrane_type,
+        tmd.start,
+        tmd.stop,
+        tmd.orientation
+      ].join("\t")
+      end
+    else
+      puts [
+      name,
+      'No Transmembrane Domain Found'
+    ].join("\t")
+    end
+
+  elsif options[:filter_in] != false
+  	if result.transmembrane_domains.length >= options[:filter_in]
+  		puts seq
+  	end
+  elsif options[:filter_out] != false
+  	unless result.transmembrane_domains.length >= options[:filter_out]
+  		puts seq
+  	end
+  end
+end

data/bio-tm_hmm.gemspec

@@ -0,0 +1,68 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = "bio-tm_hmm"
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ben J. Woodcroft"]
+  s.date = "2012-05-03"
+  s.description = "A bioruby plugin for interaction with the transmembrane predictor TMHMM"
+  s.email = "donttrustben@gmail.com"
+  s.executables = ["bio-tm_hmm"]
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    ".travis.yml",
+    "Gemfile",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "bin/bio-tm_hmm",
+    "bio-tm_hmm.gemspec",
+    "lib/bio-tm_hmm.rb",
+    "lib/bio/appl/tmhmm/tmhmm_runner.rb",
+    "lib/bio/transmembrane.rb",
+    "test/data/falciparum1.fa",
+    "test/helper.rb",
+    "test/test_tm_hmm_wrapper.rb",
+    "test/test_transmembrane.rb"
+  ]
+  s.homepage = "http://github.com/wwood/bioruby-tm_hmm"
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = "1.8.21"
+  s.summary = "A bioruby plugin for interaction with the transmembrane predictor TMHMM"
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<shoulda>, [">= 0"])
+      s.add_development_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_development_dependency(%q<bundler>, [">= 1.0.21"])
+      s.add_development_dependency(%q<bio>, [">= 1.4.2"])
+    else
+      s.add_dependency(%q<shoulda>, [">= 0"])
+      s.add_dependency(%q<rdoc>, ["~> 3.12"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+      s.add_dependency(%q<bundler>, [">= 1.0.21"])
+      s.add_dependency(%q<bio>, [">= 1.4.2"])
+    end
+  else
+    s.add_dependency(%q<shoulda>, [">= 0"])
+    s.add_dependency(%q<rdoc>, ["~> 3.12"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.3"])
+    s.add_dependency(%q<bundler>, [">= 1.0.21"])
+    s.add_dependency(%q<bio>, [">= 1.4.2"])
+  end
+end
+

data/lib/bio/appl/tmhmm/tmhmm_runner.rb

@@ -0,0 +1,91 @@
+require 'tempfile'
+
+module Bio
+  class TMHMM
+    class TmHmmWrapper
+      # Given an amino acid sequence, return a TransmembraneProtein
+      # made up of the predicted transmembrane domains
+      def calculate(sequence)
+        Bio::Command.mktmpdir do |d|
+          line = nil
+          Bio::Command.call_command(['tmhmm','-short'], :chdir => d) do |io|
+            io.puts '>wrapperSeq'
+            io.puts sequence
+            io.close_write
+            line = io.readline
+          end
+          
+          if line.nil?
+            raise Exception, "Error running locally installed TMHMM program 'tmhmm'. Is it properly installed?"
+          end
+          
+          return TmHmmResult.create_from_short_line(line)
+        end
+      end
+    end
+    
+    class TmHmmResult
+      attr_reader :domains
+      
+      # initialise with the output line of a 
+      # eg. 
+      #PFF0290w len=293 ExpAA=145.77  First60=20.51 PredHel=7 Topology=o39-61i101-120o140-162i169-186o196-218i230-252o262-284i
+      def self.create_from_short_line(line)
+        protein = Bio::Transmembrane::OrientedTransmembraneDomainProtein.new
+        
+        splits = line.strip.split("\t")
+        if splits.length != 6
+          raise Exception, "Incorrectly parsed short line from TMHMM: #{line}"
+        end
+        
+        substrate = splits[5]
+        if substrate.gsub!(/^Topology\=[io]/,'').nil?
+          raise Exception, "Badly parsed Topology hit: #{substrate}"
+        end
+        
+        matches = substrate.match('^(\d+?)\-')
+        if !matches
+          return protein #no transmembrane domains predicted
+        end
+        
+        # eat the string from the beginning adding the transmembrane domains
+        prev = matches[1]
+        substrate.gsub!(/^(\d+?)-/,'')
+        # match all the middle bits
+        reg = /^(\d+?)([io])(\d+?)\-/
+        while matches =substrate.match(reg)
+          tmd = Bio::Transmembrane::OrientedTransmembraneDomain.new
+          tmd.start = prev.to_i
+          tmd.stop = matches[1].to_i
+          tmd.orientation = parse_orientation_from_last_location(matches[2])
+          protein.push tmd
+          
+          prev = matches[3]
+          substrate.gsub!(reg, '')
+        end
+        #match the last bit
+        if !(matches = substrate.match('(\d+?)([io])$'))
+          raise Exception, "Failed to parse the last bit of: #{substrate}"
+        end
+        tmd = Bio::Transmembrane::OrientedTransmembraneDomain.new
+        tmd.start = prev.to_i
+        tmd.stop = matches[1].to_i
+        tmd.orientation = parse_orientation_from_last_location(matches[2])
+        protein.push tmd
+        
+        return protein
+      end
+      
+      def self.parse_orientation_from_last_location(last_location)
+        case last_location
+          when 'i'  
+          return Bio::Transmembrane::OrientedTransmembraneDomain::OUTSIDE_IN
+          when 'o'
+          return Bio::Transmembrane::OrientedTransmembraneDomain::INSIDE_OUT
+        else
+          raise Exception, "Badly parsed topology hit due to orientation character: #{substrate}"
+        end
+      end
+    end
+  end
+end

data/lib/bio/transmembrane.rb

@@ -0,0 +1,222 @@
+
+# Monkey-patch Array#pair in
+class Array
+  # Return an array of all pairs of elements from this array (each is an array).
+  # If another_array is not nil, then do pairwise between this array and that (but not within each)
+  #
+  # NOT thread safe.
+  def pairs(another_array = nil)
+    pairs = []
+    
+    if another_array #between this array and the next
+     (0..length-1).each do |index1|
+     (0..another_array.length-1).each do |index2|
+          pairs.push [self[index1], another_array[index2]]
+        end
+      end
+    else # within this array only
+     (0..length-1).each do |index1|
+        index2 = index1+1
+        while index2 < length
+          pairs.push [self[index1], self[index2]]
+          index2 += 1
+        end
+      end
+    end
+    
+    return pairs
+  end
+end  
+
+
+
+# a simple class to represent a transmembrane domain, and a transmembrane domain containing protein
+module Bio
+  module Transmembrane
+    class TransmembraneProtein
+      attr_accessor :transmembrane_domains, :name
+      include Enumerable #so each, each_with_index, etc. work
+      
+      def initialize
+        # default no domains to empty array not nil
+        @transmembrane_domains = []
+      end
+      
+      def push(transmembrane_domain)
+        @transmembrane_domains.push transmembrane_domain
+      end
+      
+      def average_length
+        @transmembrane_domains.inject(0){|sum,cur| sum+cur.length}.to_f/@transmembrane_domains.length.to_f
+      end
+      
+      def minimum_length
+        @transmembrane_domains.min.length
+      end
+      
+      def maximum_length
+        @transmembrane_domains.max.length
+      end
+      
+      def has_domain?
+        !@transmembrane_domains.empty?
+      end
+      
+      def multiple_transmembrane_domains?
+        @transmembrane_domains.length > 1
+      end
+      
+      def overlaps(another_transmembrane_protein)
+        @transmembrane_domains.pairs(another_transmembrane_protein.transmembrane_domains).collect {|t1,t2|
+          t1.intersection(t2) == () ? nil : [t1,t2]
+        }.reject {|a| a.nil?}
+      end
+      
+      # return the pair of transmembrane domains that overlaps the best (ie for the longest period)
+      def best_overlap(another_transmembrane_protein)
+        max = @transmembrane_domains.pairs(another_transmembrane_protein.transmembrane_domains).collect {|t1,t2|
+          [t1.overlap_length(t2), [t1,t2]]
+        }.max {|a,b| a[0] <=> b[0]}
+        max[0] == 0 ? nil : max[1]
+      end
+      
+      def each
+        @transmembrane_domains.each{|t| yield t}
+      end
+    
+      def residue_number_contained?(residue_number)
+        contained = false
+        @transmembrane_domains.each do |tmd|
+          if tmd.start <= residue_number and tmd.stop >= residue_number
+            contained = true
+          end
+        end
+        contained
+      end
+    end
+    
+    class OrientedTransmembraneDomainProtein<TransmembraneProtein
+      def transmembrane_type_1?
+        @transmembrane_domains and @transmembrane_domains.length == 1 and @transmembrane_domains[0].orientation == OrientedTransmembraneDomain::OUTSIDE_IN
+      end
+      
+      def transmembrane_type_2?
+        @transmembrane_domains and @transmembrane_domains.length == 1 and @transmembrane_domains[0].orientation == OrientedTransmembraneDomain::INSIDE_OUT
+      end
+      
+      def transmembrane_type
+        if transmembrane_type_1?
+          return 'I'
+        elsif transmembrane_type_2?
+          return 'II'
+        else
+          return 'Unknown'
+        end
+      end
+    end
+    
+    class TransmembraneDomainDefinition
+      attr_accessor :start, :stop
+      
+      # A new TMD. The length is stop-start+1, so start and stop are
+      # 'inclusive'
+      def initialize(start=nil, stop=nil)
+        @start = start
+        @stop = stop
+      end
+      
+      def length
+        @stop-@start+1
+      end
+      
+      def <=>(other)
+        length <=> other.length
+      end
+      
+      def ==(other)
+        start == other.start and
+        stop == other.stop
+      end
+      
+      def sequence(protein_sequence_string, nterm_offset=0, cterm_offset=0)
+        one = start+nterm_offset-1
+        one = 0 if one < 0
+        two = stop+cterm_offset-1
+        two = 0 if two < 0
+        
+        protein_sequence_string[(one)..(two)]
+      end
+      
+      # Return the number of amino acids that overlap with another
+      # transmembrane domain, or 0 if none are found
+      def overlap_length(another_transmembrane_domain_defintion)
+        intersection(another_transmembrane_domain_defintion).to_a.length
+      end
+      
+      # Return a range representing the overlap of this transmembrane domain
+      # with another
+      #
+      # Code inspired by http://billsiggelkow.com/2008/8/29/ruby-range-intersection
+      def intersection(another_transmembrane_domain_defintion)
+        res = (@start..@stop).to_a & (another_transmembrane_domain_defintion.start..another_transmembrane_domain_defintion.stop).to_a
+        res.empty? ? nil : (res.first..res.last)
+      end
+      alias_method(:overlap, :intersection)
+    end
+    
+    class ConfidencedTransmembraneDomain<TransmembraneDomainDefinition
+      attr_accessor :confidence
+      
+      def <=>(other)
+        return start<=>other.start if start<=>other.start
+        return stop<=>other.start if stop<=>other.stop
+        return confidence <=> other.confidence
+      end
+      
+      def ==(other)
+        start == other.start and
+        stop == other.stop and
+        confidence == other.confidence
+      end
+    end
+    
+    # From Predicting transmembrane protein topology with a hidden markov model: application to complete g
+    #
+    # Another signal shown to be associated with transmembrane helices is
+    # the abundance of positively charged residues in the part of the
+    # sequence on the cytoplasmic side of the membrane, “the positive inside
+    # rule” (von Heijne 1986) and (von Heijne 1994).
+    #
+    # So, inside means cytosolic. So outside_in means type I transmembrane domain protein
+    class OrientedTransmembraneDomain<TransmembraneDomainDefinition
+     # The orientation can either be inside out (like a type II transmembrane domain protein)
+      INSIDE_OUT = 'inside_out'
+      # Or outside in, like a type I transmembrane domain protein)
+      OUTSIDE_IN = 'outside_in'
+      # or the whole protein is TMD, so orientation is unknown
+      UNKNOWN = 'unknown'
+      
+      attr_accessor :orientation
+      
+      def initialize(start=nil, stop=nil, orientation=nil)
+        @start = start.to_i unless start.nil?
+        @stop = stop.to_i unless stop.nil?
+        @orientation = orientation unless orientation.nil?
+      end
+    end
+    
+    # A class to represent a protein with a signal peptide and a transmembrane
+    # domain
+    class SignalPeptideTransmembraneDomainProtein<OrientedTransmembraneDomainProtein
+      attr_accessor :signal_peptide
+      
+      def signal?
+        !@signal_peptide.nil?
+      end
+    end
+    
+    class SignalPeptide
+      attr_accessor :start, :stop
+    end
+  end
+end

data/lib/bio-tm_hmm.rb

@@ -0,0 +1,4 @@
+# General transmembrane domain related data structures
+require 'bio/transmembrane'
+# TMHMM extras
+require 'bio/appl/tmhmm/tmhmm_runner'

data/test/data/falciparum1.fa

@@ -0,0 +1,38 @@
+>Plasmodium_falciparum_3D7|MAL8|PF08_0142|Annotation|Plasmodium_falciparum_Sanger_Stanford_TIGR|(protein coding) erythrocyte membrane protein 1 (PfEMP1)
+MAAAGGGGKDKYKNAQDAKHLLDIIGEDIYKIANDAALKRSGSELKGLLSLAKFEKNPPD
+KQTPEDPCDLDYKYHTNVTSNVIEPCNKRSGKRFSEVSGAECANNRIKGNKGSNGDACAP
+FRRLHVCDRNLEQIDPAKITATHNLLVDVCQAAKFEGQSITQDYPKYLATYNDSPSQICT
+MLARSFADIGDIVRGKDLFRGYDDEEKNRRKKLEQKLKVIFGHIYEELKKHKKLKEEAEE
+RYKKDGDNYYKLREDWWALNRQEIWKAITCGHPGGTYFRQTACGGGTTPTPNKCRCATND
+VPTYFDYVPQYLRWFEEWAEDFCRKRKYKLENAIEKCRGKTKGEKYCDLNGFDCTQTASG
+EKKFVKGHNCHNCSVTCIPFGPWIDNQKKEFLKQRNKYQNEISSNSRKKRSTSNNNYKGY
+DEEFYKILKEDYGDVEQFLEKLSREGICQSQPTVGNQKADAANFTKDNPAKTFSHTEYCQ
+ACPWCGVVCKSGNCTKNPEGSCTEQIRKKVYDDSNTTTIPVLTPEKGKTSILQKYKTFCE
+KPEKHNQINNWECHYEKTDISNNCILGKWEKFQKGQEVMVYHPFFWKWVTEMLDDSIKWR
+KELDNCLKNENKQCISKCNGKCDCYKRWVEQKKEKEWTQIKDHFGKQEDMKEQIRGADPG
+IILEGVLDIEDLFENIKDTYGDVKEIDHIKKLLEEETTVDADNQNKTTIDKLLDHEDKDA
+KGCLQKQNECKEQERDGGARSDSQEPTPRSEVKPDSEDLDDDDEDDPDEEKSEEVENPED
+QGEEEGTKQGSGEKKVDGTEAVQETVAEVTPEKKDEVNPCEIVKTLFEKPENLSDACGLK
+YGPGGKERYSQWKCIPTKPNSDNKGEVGSAGRVARSAPSGEKGSICVPPRRRRLYVKDLE
+TLGDSEVTQVQLRDAFIKCAAVETFFLWDRYKKEKEKKKPQEGVLQLLGTVGTPPTDDEE
+DPPEKMLQKGEIPEEFKRQMFYTLADYKDILFGDQEVIKTLKDSGDENIKDISEKIKKTL
+NGDNNQESGSSPSLSGKKTTPKDWWETYGKDIWEGMVCALTYKNSGDKKIEQVKTADDGE
+DLFQKLKTQYEYNTVTLKDENSGTEGAKPFTPKTVSSSSGEKNPPKLSDFVLRPPYFRYL
+EEWGETFCRQRARMLDKIKKDCNVEENDNRPGGGITKQYSGDGESCKDYLPDDPTTLPDL
+VSSCPKSCSSYRKWINKKKDEFVEQQNAYTEQQNKCQSKSDKAKSDNGFYTRLQNLPDAA
+AFLKTLGSCSKNDIPEYKIDFDVNGETFRYEKYCGTCPEFKINCTKVKCTSGDMQNGCKD
+NKINAANFKTMAQSTEINMLVSDNSGNGSQNDLKDCKTSGIFKGFREDVWTCGKVCGYNV
+CKPKNVNGQNGDGNQILLFNALLKRWVEYFLEDYKKIKHKISHCKNSSEGHTCIKNCVEQ
+WISTKRTEWETIRGRFNDQYKSNDSDVYPVRSFLETWIPKIPVANANNDGKKLIKLSKFD
+NFCSCSASAHSPNGKDDAIDCMINRLQDKIDKCKEKHPQPSAENQTTCDESTLVEDVDDY
+EEQNPENKVGKPAICGNVDTTEPVKEEDEEECKAAESPAEPEQAAEEESVPAAETKDTEN
+QPPQAPDVGPPPLAPAPADQPLDPTILQTTIPFGIAIALTSIVFLFLKKKTKSTIDLLRV
+INIPKSDYDIPTKLSPNRYIPYTSGKYRGKRYIYLEGDSGTDSGYTDHYSDITSSSESEY
+EELDINDIYVPRAPKYKTLIEVVLEPSGNNTTASGNNTTASDTQNDIQNDIPSDIPKTPS
+DTPPPITDDEWNQLKDEFISQYLQSEQPKDVPNDYSSGDIPLNTQPNTLYFDKPQEKPFI
+TSIHDRNLYSGEEYNYDMFNSGKNGPYSDKNDLYSGNHDSLSGNRDPTSANHDSYSGNHH
+PYSGIDLINDSISGNQHIDIYDELLKRKENELFGTNNPKRTSTYSVAKLTNSDPIHNQLE
+LFHTWLDRHRDMCEKWENHHERLAKLKEEWENETHSGNTHPSDSNKTLNTDVSIQIDMDH
+EKRMKEFTNMDTILEDLDKPFNEPYYYDMYDDDIYYDVNDHDTSTVDSNAMDVPSKVQIE
+MDVNTKLVKEKYPIGDVWDI
+

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'bio-tm_hmm'
+
+class Test::Unit::TestCase
+end

data/test/test_tm_hmm_wrapper.rb

@@ -0,0 +1,65 @@
+require 'bio'
+require 'helper'
+
+class TmHmmWrapperTest < Test::Unit::TestCase
+  include Bio::Transmembrane
+  
+  def test_parser
+    result = Bio::TMHMM::TmHmmResult.create_from_short_line('PFA0635c	len=555	ExpAA=0.00	First60=0.00	PredHel=0	Topology=o')
+    assert result
+    assert_equal false, result.has_domain?
+    
+    # test a single TMD
+    result = Bio::TMHMM::TmHmmResult.create_from_short_line('PFA0685c	len=324	ExpAA=20.36	First60=0.00	PredHel=1	Topology=o281-303i')
+    assert result
+    assert_equal 1, result.transmembrane_domains.length
+    assert_equal 281, result.transmembrane_domains[0].start
+    assert_equal 303, result.transmembrane_domains[0].stop
+    assert_equal Bio::Transmembrane::OrientedTransmembraneDomain::OUTSIDE_IN,
+      result.transmembrane_domains[0].orientation
+    assert result.transmembrane_type_1?
+    assert_equal false, result.transmembrane_type_2?
+    
+    # test 2 TMD
+    result = Bio::TMHMM::TmHmmResult.create_from_short_line('PFA0680c	len=209	ExpAA=43.03	First60=0.02	PredHel=2	Topology=i137-159o164-183i')
+    assert result
+    assert_equal 2, result.transmembrane_domains.length
+    assert_equal 137, result.transmembrane_domains[0].start
+    assert_equal 159, result.transmembrane_domains[0].stop
+    assert_equal Bio::Transmembrane::OrientedTransmembraneDomain::INSIDE_OUT,
+      result.transmembrane_domains[0].orientation
+    assert_equal 164, result.transmembrane_domains[1].start
+    assert_equal 183, result.transmembrane_domains[1].stop
+    assert_equal Bio::Transmembrane::OrientedTransmembraneDomain::OUTSIDE_IN,
+      result.transmembrane_domains[1].orientation
+    assert_equal false, result.transmembrane_type_1?
+    assert_equal false, result.transmembrane_type_2?
+    
+    # test 3 TMD
+    result = Bio::TMHMM::TmHmmResult.create_from_short_line('PFA0705c	len=282	ExpAA=90.97	First60=22.20	PredHel=4	Topology=i22-44o185-207i212-234o259-281i')
+    assert result
+    assert_equal 4, result.transmembrane_domains.length
+    assert_equal 22, result.transmembrane_domains[0].start
+    assert_equal 44, result.transmembrane_domains[0].stop
+    assert_equal Bio::Transmembrane::OrientedTransmembraneDomain::INSIDE_OUT,
+      result.transmembrane_domains[0].orientation
+    assert_equal 185, result.transmembrane_domains[1].start
+    assert_equal 207, result.transmembrane_domains[1].stop
+    assert_equal Bio::Transmembrane::OrientedTransmembraneDomain::OUTSIDE_IN,
+      result.transmembrane_domains[1].orientation
+    assert_equal 259, result.transmembrane_domains[3].start
+    assert_equal 281, result.transmembrane_domains[3].stop
+    assert_equal Bio::Transmembrane::OrientedTransmembraneDomain::OUTSIDE_IN,
+      result.transmembrane_domains[3].orientation
+    assert_equal false, result.transmembrane_type_1?
+    assert_equal false, result.transmembrane_type_2?
+  end
+  
+  def test_wrapper
+    prog = Bio::TMHMM::TmHmmWrapper.new
+    seq = Bio::FlatFile.auto(File.join(File.dirname(__FILE__),'data','falciparum1.fa')).next_entry
+    tmp = prog.calculate(seq.seq)
+    assert tmp
+    assert_equal false, tmp.has_domain?
+  end
+end

data/test/test_transmembrane.rb

@@ -0,0 +1,146 @@
+require 'helper'
+
+module Transmembrane
+  class TransmembraneTest < Test::Unit::TestCase
+    include Bio::Transmembrane
+    
+    def test_confidenced_transmembrane_domain
+      one = ConfidencedTransmembraneDomain.new
+      two = ConfidencedTransmembraneDomain.new
+      assert_equal one, two
+    end
+    
+    def test_sequence_offsets
+      aaseq = 'AAAAAANG' #8 aa long
+      d = TransmembraneDomainDefinition.new
+      d.start = 6
+      d.stop = 8
+      assert_equal 'ANG', d.sequence(aaseq)
+      
+      assert_equal 'AANG', d.sequence('AAAAAANG', -1, 0)
+      assert_equal 'AANG', d.sequence('AAAAAANG', -1, 1) #overhang
+      assert_equal 'AAN', d.sequence('AAAAAANG', -1, -1) #overhang over the cterm
+      
+      d.start = 1
+      d.stop = 5
+      assert_equal 'AAAAA', d.sequence('AAAAAANG', -2, 0) #overhang over the nterm
+      assert_equal 'AAAAAANG', d.sequence('AAAAAANG', -2, 15) #overhang over the nterm and cterm
+    end
+  end
+
+  class TransmembraneProteinTest < Test::Unit::TestCase
+    include Bio::Transmembrane
+    def test_simple
+      protein = TransmembraneProtein.new
+      tmd = TransmembraneDomainDefinition.new
+      tmd.start = 8
+      tmd.stop = 9
+      protein.push tmd
+
+      tmd = TransmembraneDomainDefinition.new
+      tmd.start = 8
+      tmd.stop = 10
+      protein.push tmd
+
+      assert_equal 2, protein.minimum_length
+      assert_equal 2.5, protein.average_length
+    end
+
+    def test_empty
+      protein = TransmembraneProtein.new
+      assert protein.transmembrane_domains.empty?
+      assert_equal false, protein.has_domain?
+    end
+
+    def test_overlaps
+      p1 = TransmembraneProtein.new
+      p2 = TransmembraneProtein.new
+      tmd1 = TransmembraneDomainDefinition.new(5,10)
+      tmd2 = TransmembraneDomainDefinition.new(5,6)
+      p1.transmembrane_domains = [tmd1]
+      p2.transmembrane_domains = [tmd2]
+      assert_equal [[tmd1, tmd2]], p1.overlaps(p2)
+
+      p2.transmembrane_domains = [tmd1,tmd2]
+      assert_equal [[tmd1, tmd1],[tmd1, tmd2]], p1.overlaps(p2)
+
+      tmd3 = TransmembraneDomainDefinition.new(500,600)
+      p2.transmembrane_domains = [tmd3]
+      assert_equal [], p1.overlaps(p2)
+    end
+
+    def test_best_overlap
+      p1 = TransmembraneProtein.new
+      p2 = TransmembraneProtein.new
+      tmd1 = TransmembraneDomainDefinition.new(5,10)
+      tmd2 = TransmembraneDomainDefinition.new(5,6)
+      tmd3 = TransmembraneDomainDefinition.new(11,22)
+      p1.transmembrane_domains = [tmd1]
+      p2.transmembrane_domains = [tmd2]
+      assert_equal [tmd1, tmd2], p1.best_overlap(p2)
+
+      p2.transmembrane_domains = [tmd1,tmd2]
+      assert_equal [tmd1, tmd1], p1.best_overlap(p2)
+
+      p2.transmembrane_domains = [tmd3]
+      assert_equal nil, p1.best_overlap(p2)
+    end
+
+    def test_each
+      expected = [10,6,22]
+      p = TransmembraneProtein.new
+      tmd1 = TransmembraneDomainDefinition.new(5,10)
+      tmd2 = TransmembraneDomainDefinition.new(5,6)
+      tmd3 = TransmembraneDomainDefinition.new(11,22)
+      p.transmembrane_domains = [tmd1,tmd2,tmd3]
+      p.each_with_index do |tmd, i|
+        assert_equal expected[i], tmd.stop
+      end
+    end
+  end
+
+  class TransmembraneProteinTest < Test::Unit::TestCase
+    def test_overlap_tmd
+      tmd1 = TransmembraneDomainDefinition.new(3,6)
+      tmd2 = TransmembraneDomainDefinition.new(3,6)
+      assert_equal((3..6), tmd1.intersection(tmd2))
+      assert_equal 4, tmd1.overlap_length(tmd2)
+
+      tmd2 = TransmembraneDomainDefinition.new(7,8)
+      assert_equal 0, tmd1.overlap_length(tmd2)
+
+      tmd2 = TransmembraneDomainDefinition.new(5,8)
+      assert_equal 2, tmd1.overlap_length(tmd2)
+
+      tmd2 = TransmembraneDomainDefinition.new(1,3)
+      assert_equal 1, tmd1.overlap_length(tmd2)
+      assert_equal((3..3), tmd1.intersection(tmd2))
+    end
+    
+    def test_residue_contained?
+      p = TransmembraneProtein.new
+      
+      # test none
+      p.transmembrane_domains = []
+      assert_equal false, p.residue_number_contained?(5)
+      
+      # test one
+      p.transmembrane_domains = [TransmembraneDomainDefinition.new(5,8)]
+      assert p.residue_number_contained?(5)
+      assert p.residue_number_contained?(6)
+      assert p.residue_number_contained?(8)
+      assert_equal false, p.residue_number_contained?(4)
+      assert_equal false, p.residue_number_contained?(9)
+      
+      # test 3
+      p.transmembrane_domains = [
+      TransmembraneDomainDefinition.new(1,10),
+      TransmembraneDomainDefinition.new(90,100),
+      TransmembraneDomainDefinition.new(16,24),
+      ]
+      assert p.residue_number_contained?(5)
+      assert p.residue_number_contained?(95)
+      assert_equal false, p.residue_number_contained?(150)
+    end
+  end
+end

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: bio-tm_hmm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ben J. Woodcroft
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: shoulda
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.21
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.21
+- !ruby/object:Gem::Dependency
+  name: bio
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.4.2
+description: A bioruby plugin for interaction with the transmembrane predictor TMHMM
+email: donttrustben@gmail.com
+executables:
+- bio-tm_hmm
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- bin/bio-tm_hmm
+- bio-tm_hmm.gemspec
+- lib/bio-tm_hmm.rb
+- lib/bio/appl/tmhmm/tmhmm_runner.rb
+- lib/bio/transmembrane.rb
+- test/data/falciparum1.fa
+- test/helper.rb
+- test/test_tm_hmm_wrapper.rb
+- test/test_transmembrane.rb
+homepage: http://github.com/wwood/bioruby-tm_hmm
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1028203441
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: A bioruby plugin for interaction with the transmembrane predictor TMHMM
+test_files: []