rbbt-entities 1.1.1 → 2.0.0

data/lib/rbbt/entity.rb

@@ -5,27 +5,34 @@ module Entity
     attr_accessor :formats, :entity_property_cache, :entity_list_cache
   end
 
-  self.entity_property_cache = "cache/entity_property"
-  self.entity_list_cache = "cache/entity_list"
+  self.entity_property_cache = "var/entity_property"
+  self.entity_list_cache     = "var/entity_list"
   self.formats = {}
   
+  UNPERSISTED_PREFIX = "entity_unpersisted_property_"
+
   def self.extended(base)
     base.extend Annotation unless Annotation === base
 
+
     Entity.formats[base.to_s] = base
     base.module_eval do
+      attr_accessor :_ary_property_cache
+
       if not methods.include? "prev_entity_extended"
         class << self
-          attr_accessor :template, :list_template, :action_template, :list_action_template
+          attr_accessor :template, :list_template, :action_template, :list_action_template, :keep_id
           alias prev_entity_extended extended 
         end 
 
         def self.extended(data)
           prev_entity_extended(data)
 
+          data._ary_property_cache = {}
+
           if Array === data and 
             not AnnotatedArray === data and 
-            not (Annotated === data.compact.first and (data.annotation_types - data.compact.first.annotation_types).any?)
+            not (data.compact.first != nil and Annotated === data.compact.first and (data.annotation_types - data.compact.first.annotation_types).any?)
 
             data.extend AnnotatedArray
           end
@@ -41,25 +48,49 @@ module Entity
         end
       end
 
-      def clean_annotations
+      def clean_annotations_old
+        return nil if self.nil?
+        return self.dup
         case
         when self.nil?
-          self
+          nil
         when String === self
           "" << self
         when self.respond_to?(:annotated_array_clean_collect)
           self.annotated_array_clean_collect{|e| e.respond_to?(:clean_annotations)? e.clean_annotations : e}
         when Array === self
           self.collect{|e| e.respond_to?(:clean_annotations)? e.clean_annotations : e}
+        when (Fixnum === self)
+          0 + self
+        when (Float === self)
+          0.0 + self
         else
           raise "Unknown casuistic in clean_annotations for object: #{self.inspect}"
         end
       end
 
+      def clean_annotations
+        case
+        when self.nil?
+          nil
+        when Array === self
+          self.dup.collect{|e| e.respond_to?(:clean_annotations)? e.clean_annotations : e}
+        when String === self
+          "" << self
+        else
+          self.dup
+        end
+      end
+
       def to_yaml(*args)
-        clean_annotations.to_yaml(*args)
+        self.clean_annotations.dup.to_yaml(*args)
+      end
+
+      def encode_with(coder)
+        coder.scalar = clean_annotations
       end
 
+
       def marshal_dump
         clean_annotations
       end
@@ -73,81 +104,105 @@ module Entity
           end
         }
       end
-    end 
-  end
 
-  def property(name, &block)
-    case
-    when (Hash === name and name.size == 1)
-      name, type = name.collect.first
-    when (String === name or Symbol === name)
-      type = :single
-    else
-      raise "Format of name ( => type) not understood: #{name.inspect}"
-    end
-
-    name = name.to_s unless String === name
-
-    case type
-    when :single, :single2array
-      self.module_eval do 
-        single_name = "_single_" << name
-        define_method single_name, &block 
-        define_method name do |*args|
-          if Array === self
-            self.collect{|e| e.send(name, *args)}
-          else
-            self.send(single_name, *args)
-          end
+      def self.property(name, &block)
+        case
+        when (Hash === name and name.size == 1)
+          name, type = name.collect.first
+        when (String === name or Symbol === name)
+          type = :single
+        else
+          raise "Format of name ( => type) not understood: #{name.inspect}"
         end
-      end
-    when :array, :array2single
-      self.module_eval do 
-        ary_name = "_ary_" << name
-        define_method ary_name, &block 
-
-        define_method name do |*args|
-          case
-          when Array === self
-            self.send(ary_name, *args)
-          when (Array === self.container and self.container.respond_to? ary_name)
-            res = self.container.send(name, *args)
-            if Hash === res
-              res[self]
+
+        name = name.to_s unless String === name
+
+        persisted_name = UNPERSISTED_PREFIX + name
+        self.remove_method persisted_name if methods.include? persisted_name
+
+        case type
+        when :both
+          define_method name, &block 
+ 
+        when :single, :single2array
+          single_name = "_single_" << name
+          define_method single_name, &block 
+          define_method name do |*args|
+            if Array === self
+              self.collect{|e| e.send(name, *args)}
             else
-              res[self.container_index]
+              self.send(single_name, *args)
+            end
+          end
+        when :array, :array2single
+          ary_name = "_ary_" << name
+          define_method ary_name, &block 
+          
+          define_method name do |*args|
+            #ary_name = "_ary_" << __method__.to_s
+            case
+            when Array === self
+              self.send(ary_name, *args)
+            when (Array === self.container and self.container.respond_to? ary_name)
+              cache_code = Misc.hash2md5({:name => ary_name, :args => args})
+              res = (self.container._ary_property_cache[cache_code] ||=  self.container.send(name, *args))
+              if Hash === res
+                res[self]
+              else
+                res[self.container_index]
+              end
+            else
+              res = self.make_list.send(ary_name, *args)
+              Hash === res ? res[self] : res[0]
             end
-          else
-            res = self.make_list.send(ary_name, *args)
-            Hash === res ? res[self] : res[0]
           end
-        end
 
+        end
       end
-    end
-  end
 
-  UNPERSISTED_PREFIX = "entity_unpersisted_property_"
-  def persist(method_name, type = nil, options = {})
-    type = :memory if type.nil?
-    options = Misc.add_defaults options, :dir => Entity.entity_property_cache
+      def self.persist(method_name, type = nil, options = {})
+        type = :memory if type.nil?
+        options = Misc.add_defaults options, :dir => Entity.entity_property_cache
 
-    self.module_eval do
-      orig_name = UNPERSISTED_PREFIX + method_name.to_s
-      alias_method orig_name, method_name unless instance_methods.include? orig_name
+        orig_name = UNPERSISTED_PREFIX + method_name.to_s
+        alias_method orig_name, method_name unless self.instance_methods.include? orig_name.to_sym
 
-      define_method method_name do |*args|
-        persist_name = __method__.to_s << ":" << self.id
+        define_method method_name do |*args|
+          id = self.id
+          persist_name = __method__.to_s << ":" << (Array === id ? Misc.hash2md5(:id => id) : id)
+          persist_name << ":" << Misc.hash2md5({:args => args}) unless args.nil? or args.empty?
 
-        persist_options = options
-        persist_options = persist_options.merge(:other => {:args => args}) if args.any?
+          persist_options = options
+          persist_options = persist_options.merge(:other => {:args => args}) if args.any?
 
-        Persist.persist(persist_name, type, persist_options) do
-          self.send(orig_name, *args)
+          Persist.persist(persist_name, type, persist_options) do
+            self.send(orig_name, *args)
+          end
         end
       end
-    end
-  end
 
+      def self.unpersist(method_name)
+        return unless persisted? method_name
+        orig_name = UNPERSISTED_PREFIX + method_name.to_s
+
+        alias_method method_name, orig_name
+        remove_method orig_name
+      end
+
+      def self.persisted?(method_name)
+        orig_name = UNPERSISTED_PREFIX + method_name.to_s
+        instance_methods.include? orig_name.to_sym
+      end
+
+      def self.with_persisted(method_name)
+        persisted = persisted? method_name
+        persist method_name unless persisted
+        res = yield
+        unpersist method_name unless persisted
+        res
+      end
+
+    end 
+  end
 end
 

data/test/rbbt/entity/test_gene.rb

@@ -45,8 +45,22 @@ class TestGene < Test::Unit::TestCase
   end
 
   def test_range
-    assert Range === CDK5.range
-    assert Range === CDK5.make_list.range.first
+    assert Range === CDK5.chr_range
+    assert Range === CDK5.make_list.chr_range.first
+  end
+
+  def test_total_bases
+    require 'rbbt/entity/gene'
+    require 'rbbt/sources/kegg'
+
+    assert Gene.gene_list_bases(Gene.setup(KeggPathway.setup("hsa03040", "Hsa/jun2011").genes, "KEGG Gene ID", "Hsa/jun2011").ensembl) > 100000
+  end
+
+  def test_total_exon_bases
+    require 'rbbt/entity/gene'
+    require 'rbbt/sources/kegg'
+
+    assert Gene.gene_list_exon_bases(Gene.setup(KeggPathway.setup("hsa03040", "Hsa/jun2011").genes, "KEGG Gene ID", "Hsa/jun2011").ensembl) < 1000000
   end
 
 end

data/test/rbbt/entity/test_genomic_mutation.rb

@@ -7,22 +7,74 @@ require 'rbbt/entity/genomic_mutation'
 
 class TestGenomicMutation < Test::Unit::TestCase
   MUTATION = GenomicMutation.setup("10:124745844:A:158", "Test", "Hsa/jun2011")
+  NON_CODING_MUTATION = GenomicMutation.setup("12:52844451:T", "Test", "Hsa/jun2011")
   SPLICING = GenomicMutation.setup("18:14787040:A", "Test", "Hsa/jun2011")
+  SPLICING2 = GenomicMutation.setup("3:125551372:G:1265.90:1", "test", "Hsa/jun2011", true)
+
+  FORWARD_STRAND_FIRST_EXON_START = GenomicMutation.setup("10:89622870", "Test", "Hsa/jun2011")
+  FORWARD_STRAND_FIRST_EXON_END   = GenomicMutation.setup("10:89624305", "Test", "Hsa/jun2011")
+  FORWARD_STRAND_LAST_EXON_START  = GenomicMutation.setup("10:89725044", "Test", "Hsa/jun2011")
+  FORWARD_STRAND_LAST_EXON_END    = GenomicMutation.setup("10:89731687", "Test", "Hsa/jun2011")
+
+  REVERSE_STRAND_FIRST_EXON_START = GenomicMutation.setup("2:198256698", "Test", "Hsa/jun2011")
+  REVERSE_STRAND_FIRST_EXON_END   = GenomicMutation.setup("2:198257185", "Test", "Hsa/jun2011")
+  REVERSE_STRAND_LAST_EXON_START  = GenomicMutation.setup("2:198299696", "Test", "Hsa/jun2011")
+  REVERSE_STRAND_LAST_EXON_END    = GenomicMutation.setup("2:198299815", "Test", "Hsa/jun2011")
+
 
   def test_mutated_isoforms
     assert MUTATION.mutated_isoforms.length > 1
-    assert ["PSTK"], MUTATION.mutated_isoforms.protein.gene.to("Associated Gene Name").uniq
+    assert_equal ["PSTK"], MUTATION.mutated_isoforms.protein.gene.to("Associated Gene Name").uniq
   end
 
   def test_exon_junction
     assert(!(MUTATION.in_exon_junction?))
     assert SPLICING.in_exon_junction?
+
+    assert(!(FORWARD_STRAND_FIRST_EXON_START.in_exon_junction?))
+    assert( (FORWARD_STRAND_FIRST_EXON_END.in_exon_junction?))
+    assert( (FORWARD_STRAND_LAST_EXON_START.in_exon_junction?))
+    assert(!(FORWARD_STRAND_LAST_EXON_END.in_exon_junction?))
+
+    assert(!(REVERSE_STRAND_FIRST_EXON_START.in_exon_junction?))
+    assert( (REVERSE_STRAND_FIRST_EXON_END.in_exon_junction?))
+    assert( (REVERSE_STRAND_LAST_EXON_START.in_exon_junction?))
+    assert(!(REVERSE_STRAND_LAST_EXON_END.in_exon_junction?))
   end
 
   def test_over_gene
     assert MUTATION.over_gene? Gene.setup("PSTK", "Associated Gene Name", "Hsa/jun2011").ensembl
     assert(!(SPLICING.over_gene? Gene.setup("PSTK", "Associated Gene Name", "Hsa/jun2011").ensembl))
   end
+
+  def test_type
+    reference = "A"
+    mutation = GenomicMutation.setup("1:1727802:A", "Test", "Hsa/may2009", true)
+    assert_equal 'none', mutation.type
+    mutation = GenomicMutation.setup("1:1727802:C", "Test", "Hsa/may2009", true)
+    assert_equal 'transversion', mutation.type
+    mutation = GenomicMutation.setup("1:1727802:T", "Test", "Hsa/may2009", true)
+    assert_equal 'transversion', mutation.type
+    mutation = GenomicMutation.setup("1:1727802:G", "Test", "Hsa/may2009", true)
+    assert_equal 'transition', mutation.type
+  end
+
+  def test_coding
+    assert MUTATION.coding?
+    assert(!NON_CODING_MUTATION.coding?)
+  end
+
+  def test_masked_annotations
+    assert MUTATION.info.include?(:jobname)
+    assert(!MUTATION.info(true).include?(:jobname))
+  end
+
+  def test_transcripts_with_affected_splicing
+    assert(SPLICING.transcripts_with_affected_splicing.any?)
+    assert(SPLICING2.transcripts_with_affected_splicing.empty?)
+  end
+
+
 end
 
 

data/test/rbbt/entity/test_pmid.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+require 'test/unit'
+require 'rbbt/util/tmpfile'
+require 'test/unit'
+require 'rbbt/entity/pmid'
+
+class TestProtein < Test::Unit::TestCase
+  
+  def test_pmid_id
+    assert_match /^PMID/, PMID.setup("21904853").docid
+  end
+
+  def test_pmid_text
+    assert_match /TET2/, PMID.setup("21904853").text
+  end
+end
+
+

data/test/rbbt/test_entity.rb

@@ -1,4 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require 'rbbt'
 require 'rbbt/entity'
 require 'rbbt/util/tmpfile'
 require 'test/unit'
@@ -30,6 +31,16 @@ module ReversableString
     $count += 1
     self.collect{|s| s.reverse}
   end
+
+  property :random => :single do
+    rand
+  end
+
+  property :annotation_list => :single do
+    self.chars.to_a.collect{|c| 
+      ReversableString.setup(c)
+    }
+  end
  
   persist :reverse_text_ary_p
   persist :reverse_text_ary_p
@@ -37,10 +48,13 @@ module ReversableString
   persist :reverse_text_single_p
 
   persist :reverse_text_ary_p_array, :array, :dir => TmpFile.tmp_file
+
+  persist :annotation_list, :annotations, :dir => TmpFile.tmp_file
 end
+
 class TestEntity < Test::Unit::TestCase
 
-  def test_property_ary
+  def _test_property_ary
     a = ["String1", "String2"]
     a.extend ReversableString
 
@@ -48,11 +62,19 @@ class TestEntity < Test::Unit::TestCase
 
     assert_equal "2gnirtS", a.reverse_text_ary.last
     assert_equal 1, $count
+    a._ary_property_cache.clear
     assert_equal "2gnirtS", a[1].reverse_text_ary
     assert_equal 2, $count
+    a._ary_property_cache.clear
+
+    $count = 0
+    a.each do |string|
+      string.reverse_text_ary
+      assert_equal 1, $count
+    end
   end
 
-  def test_property_single
+  def _test_property_single
     a = ["String1", "String2"]
     a.extend ReversableString
 
@@ -64,7 +86,7 @@ class TestEntity < Test::Unit::TestCase
     assert_equal 3, $count
   end
 
-  def test_property_ary_p
+  def _test_property_ary_p
     a = ["String1", "String2"]
     a.extend ReversableString
 
@@ -75,7 +97,7 @@ class TestEntity < Test::Unit::TestCase
     assert_equal 1, $count
   end
 
-  def test_property_single_p
+  def _test_property_single_p
     a = ["String1", "String2"]
     a.extend ReversableString
 
@@ -87,7 +109,7 @@ class TestEntity < Test::Unit::TestCase
     assert_equal 2, $count
   end
 
-  def test_property_ary_p_array
+  def _test_property_ary_p_array
     a = ["String1", "String2"]
     a.extend ReversableString
 
@@ -98,4 +120,77 @@ class TestEntity < Test::Unit::TestCase
     assert_equal "2gnirtS", a.reverse_text_ary_p_array.last
     assert_equal 1, $count
   end
+
+  def _test_unpersist
+    a = ["String1", "String2"]
+    a.extend ReversableString
+
+    # Before persist
+    assert(! ReversableString.persisted?(:random))
+
+    r1 = a.random
+    r2 = a.random
+    assert_not_equal r1, r2
+
+    # After persist
+    ReversableString.persist :random
+    assert(ReversableString.persisted?(:random))
+
+    r1 = a.random
+    r2 = a.random
+    assert_equal r1, r2
+
+    # After unpersist
+    ReversableString.unpersist :random
+    assert(! ReversableString.persisted?(:random))
+
+    r1 = a.random
+    r2 = a.random
+    assert_not_equal r1, r2
+
+  end
+
+  def _test_persist_annotations
+    string = 'aaabbbccc'
+    ReversableString.setup(string)
+    assert_equal string.length, string.annotation_list.length
+    assert_equal string.length, string.annotation_list.length
+  end
+
+  def __test_performance
+
+    require 'rbbt/workflow'
+    Workflow.require_workflow "StudyExplorer"
+
+    s = Study.setup("CLL")
+    mutations = s.cohort.metagenotype
+    Misc.profile_html(:min_percent => 1) do
+      mutated_isoforms = mutations.each{|m| m.genes.each{|g| g}}
+    end
+  end
+
+  def test_clean_annotations
+    require 'rbbt/workflow'
+    Workflow.require_workflow "StudyExplorer"
+
+    s = Study.setup("CLL")
+    mutations = s.cohort.metagenotype.mutated_isoforms
+
+    Misc.benchmark(100) do
+      mutations.each{|m| m}
+    end
+
+    Misc.benchmark(100) do
+      mutations.clean_annotations.each{|m| m}
+    end
+
+    m = mutations.first
+
+    assert_equal m.split(":")[1], m.position.to_s
+    assert_raise NoMethodError do 
+      m.clean_annotations.position
+    end
+
+
+  end
 end