mitab 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce2fc8ccf6fdfae5dab43d559f44e67bb72bbe3c
+  data.tar.gz: 8abfa26555a589173fdfe8dd2b8dff019f7b4f11
+SHA512:
+  metadata.gz: f880d900c11fc5f021fe2bf2a8cdff56e495bc3cf91df40536af5b09fef65f347dcd7cc268ff2018eb8a7f37791bef8de686b977e922222c6cd193ec85640a68
+  data.tar.gz: 5f996e45eeb1d0b32daf4db82f7e2197db806f07214fa39c753cab55721b0ab6c45599d1e52e11c62793160cfd3d76f458d714628e468a24b26ad0a7a6b9974c

data/lib/mitab.rb

@@ -0,0 +1,142 @@
+require 'open-uri'
+module Mitab
+  class MitabParser
+    attr_reader :nodes, :links, :scores, :mitab
+
+    # regex
+    $textInParenthesis = /\((.*?)\)/
+    $textInQuotes = /\"(.*?)\"/
+    $textInTax = /\:(.*?)\(/
+    $geneName = /\((gene name)\)/
+    $geneNameSynonym = /\((gene name synonym)\)/
+
+    def initialize(text)
+      @nodes = {}
+      @links= []
+      @scores = {}
+      @mitab
+      
+
+      $lines = text.split("\n")
+
+      $interactions = $lines.map{ |l| parse(l)}
+      nodeval = @nodes.values
+
+      @links = $interactions
+
+      @mitab = {
+        links: $interactions,
+        nodes: nodeval,
+        ids: nodeval.map { |h| h[:id] },
+        taxa: nodeval.reduce([]){ |union, x| union | x[:taxonomy]}.compact,
+        scores: @scores.values
+      }
+
+    end
+
+    def mapPub(pubStr)
+        arr = pubStr.split(':')
+        return {name:arr[0], value:arr[1]}
+    end
+
+    def mapField(fieldStr)
+      
+        if(fieldStr.match($textInQuotes).nil? || fieldStr.match($textInParenthesis).nil?)
+            arr = fieldStr.split(':')
+            return {name:arr[0], score:arr[1]}
+        end
+        return {name:fieldStr.match($textInQuotes)[1], value:fieldStr.match($textInParenthesis)[1]}
+    end
+
+    def addScore(score)
+      if( !score[:score].to_f.nan?)
+          if(@scores.key?(score[:name]))
+              if(@scores[score[:name]][:min].to_f > score[:score].to_f) 
+                @scores[score[:name]][:min] = score[:score].to_f
+              end
+              if(@scores[score[:name]][:max].to_f < score[:score].to_f) 
+                @scores[score[:name]][:max] = score[:score].to_f
+              end
+          else
+              @scores[score[:name]] = {name:score[:name], min:score[:score], max:score[:score]}
+          end
+      end
+    end
+
+    def mapScore(scoreStr)
+      arr = scoreStr.split(':')
+      score = {name:arr[0], score:arr[1]}
+      addScore(score)
+      return score
+    end
+
+    def mapTaxonomy(taxStr)
+
+        if(taxStr != '-')
+            return (taxStr.match($textInTax).nil?) ? taxStr.split(':')[1] : taxStr.match($textInTax)[1]
+        end
+    end
+
+    def getNode(idStr, altIdsStr, aliasStr, taxStr)
+      gNameAliases = aliasStr.split("|")
+
+      gNameStr = gNameAliases.select{ |gNameAlias| gNameAlias.match($geneName)}
+
+      gNameStr = (gNameStr.nil?) ? gNameAliases.select{ |gNameAlias| gNameAlias.match($geneNameSynonym)} : gNameStr
+      ids = idStr.split("|") + altIdsStr.split("|") + aliasStr.split("|")
+      ids = ids.map{|x| mapPub(x)}
+      id = ids.select{|id| id[:name] == "uniprotkb"}
+      node = {
+              id: ids[0][:value],
+              ids: ids,
+              uniprot: (id.nil?) ? '' : id,
+              geneName: (gNameStr.nil?) ? '' : gNameStr.map{|gStr| gStr.match($textInTax)[1]},
+              altIds: altIdsStr.split('|').map{|x| mapPub(x)},
+              taxonomy: taxStr.split('|').uniq{|x| mapTaxonomy(x)},
+        }
+        return node
+
+        
+    end
+
+    def parse(line)
+      if (!line.is_a? String) 
+        puts 'MITab cannot parse line '
+        return {}
+      end
+      fields = line.split("\t")
+      if(fields.length < 15)
+        puts "MITab cannot parse line "
+        return {}
+      end
+
+      nodeA = getNode(fields[0], fields[2], fields[4], fields[9])
+      nodeB = getNode(fields[1], fields[3], fields[5], fields[10])
+
+      interaction = {
+          source: nodeA[:id],
+          target: nodeB[:id],
+          detMethods: fields[6].split('|').map{|x| mapField(x)},
+          firstAuthor: fields[7].split('|'),
+          publications: fields[8].split('|').map{|x| mapField(x)},
+          intTypes: fields[11].split('|').map{|x| mapField(x)},
+          sourceDbs: fields[12].split('|').map{|x| mapField(x)},
+          intIds: fields[13].split('|').map{|x| mapPub(x)},
+          scores: fields[14].split('|').map{|x| mapScore(x)},
+        }
+
+
+
+      @nodes[nodeA[:id]] = nodeA
+      @nodes[nodeB[:id]] = nodeB
+
+      nodeval = @nodes.values
+
+      return interaction
+    end
+    
+    def print
+      puts @mitab
+    end
+  end
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: mitab
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Prasun Anand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-30 00:00:00.000000000 Z
+dependencies: []
+description: A ruby parser for MITab file format.
+email: prasunanand.bitsp@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mitab.rb
+homepage: http://rubygems.org/gems/mitab
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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.4.6
+signing_key: 
+specification_version: 4
+summary: MITab parser
+test_files: []