rbbt-util 5.0.1 → 5.1.0

data/README.rdoc

@@ -12,7 +12,7 @@
     cp .bash_profile .bash_profile.save
     mv tmp.bash_profile .bash_profile
     . .bash_profile
-    rvm install 1.8.7
+    rvm install 1.9.3
     
 2 - install tokyocabinet (Intructions for user install follow. For system level, make sure we have dev package)
     1 - download source from http://fallabs.com/tokyocabinet/tokyocabinet-1.4.47.tar.gz
@@ -43,7 +43,7 @@
 
    :script
 
-   gem install specific_install
+   gem install specific_install hoe
    gem specific_install -l https://github.com/bensomers/png.git
    gem specific_install -l https://github.com/felipec/soap4r.git
    gem specific_install -l https://github.com/mikisvaz/tokyocabinet_19_fix.git
@@ -53,18 +53,22 @@
    :script
 
    # RSRuby
-   R_HOME='full_path_to_R_dir' # Example in ubuntu
+   ## Example in ubuntu
    gem install rsruby -- --with-R-dir=/usr/lib/R/lib/ --with-R-include=/usr/share/R/include
+   
+   ## Example in MAC
+   gem install rsruby -- --with-R-dir=/Library/Frameworks/R.framework/Resources/
+
 
    # JRB
    export JAVA_HOME="full_path_to_jdk"
    gem install rjb
 
-3 - install gems rbbt-util rbbt-sources rbbt-text rbbt-phgx. 
+3 - install gems rbbt-util rbbt-sources rbbt-text rbbt-phgx, ...
 
     :script
     
-    gem install rbbt-util rbbt-sources rbbt-text rbbt-phgx rbbt-entities rbbt-views
+    gem install rbbt-util rbbt-sources rbbt-text rbbt-phgx rbbt-entities rbbt-views rbbt-dm rbbt-GE
 
 3.bis - Or install github repos and make ruby use them
 
@@ -82,13 +86,19 @@
     alias druby="env RBBT_LOG=0 ruby $(for d in $HOME/git/rbbt-*;do echo -n "-I$d/lib ";done)"
     alias drake="env RBBT_LOG=0 rake $(for d in $HOME/git/rbbt-*;do echo -n "-I$d/lib ";done)"
 
-4 - Set up R to find the helper lib
+4 - Install other gems that you might need for some of my workflows
+    
+    script
+
+    gem install redcarpet thin 
+
+5 - Set up R to find the helper lib
 
     :script
 
     echo "source(system('rbbt_Rutil.rb', intern =T));" >> $HOME/.Rprofile
 
-5 - If you plan to run workflows you might want to redefine the default directory to place your workflows (~/.workflows)
+6 - If you plan to run workflows you might want to redefine the default directory to place your workflows (~/.workflows)
     
     :script
 

data/lib/rbbt/annotations.rb

@@ -1,598 +1,300 @@
 require 'rbbt/util/misc'
-require 'rbbt/util/chain_methods'
+require 'rbbt/annotations/annotated_array'
+require 'rbbt/annotations/util'
 
-require 'json'
-module Annotated
-  attr_accessor :annotation_types
-  attr_accessor :context
-  attr_accessor :container
-  attr_accessor :container_index
-  attr_accessor :id
-
-  def self.extended(base)
-    base.annotation_types ||= []
-  end
+#{{{ ANNOTATED
 
-  def annotations
-    raise "Annotation types is nil for object: #{self.inspect}" if annotation_types.nil?
-    annotation_types.collect do |mod|
-      mod.annotations
-    end.flatten.uniq
-  end
+module Annotated
+  attr_accessor :container, :container_index
 
-  def unmasked_annotations
-    raise "Annotation types is nil for object: #{self.inspect}" if annotation_types.nil?
-    annotation_types.collect do |mod|
-      mod.unmasked_annotations
-    end.flatten.uniq
+  def annotation_values
+    @annotation_values ||= {}
   end
 
-  def info(masked = false)
-    hash = {:annotation_types => annotation_types}
-    (masked ? unmasked_annotations : annotations).each do |annotation|
-      value = self.send(annotation)
-      hash[annotation] = value unless value.nil?
-    end
-    hash
+  def detach_annotations
+    @annotation_values = @annotation_values.dup
+    @annotation_values.instance_variable_set(:@annotation_md5, nil)
+    @shared_annotations = false
   end
 
-  def id
-    @id ||= self.respond_to?(:annotation_id) ? annotation_id : Misc.hash2md5(info.merge(:self => self))
+  def reset
+    @info = nil
+    @id = nil
+    @self_md5 = nil
+    @annotation_values.instance_variable_set(:@annotation_md5, nil)
   end
 
-  def self.load(object, info)
-    annotation_types = info[:annotation_types] || []
-    annotation_types = annotation_types.split("|") if String === annotation_types
-
-    return object if annotation_types.nil? or annotation_types.empty?
+  def annotation_types
 
-    annotated_array = info.delete(:annotated_array) || false
-
-    annotation_types.each do |mod|
-      mod = Misc.string2const(mod) if String === mod
-      mod.setup(object, *info.values_at(*mod.all_annotations))
-    end
-
-    object.id = info[:entity_id] if info.include? :entity_id
-
-    object.extend AnnotatedArray if annotated_array
-
-    object
+    @annotation_types ||= class << self; self; end.
+      included_modules.
+      select{|m| 
+        Annotation === m
+      }
   end
 
-  def tsv_values(*fields)
-    if Array === self and (not AnnotatedArray === self or self.double_array)
-      Misc.zip_fields(self.compact.collect{|e| e.tsv_values(fields)})
-    else
-      fields = fields.flatten
-      info = self.info
-      info[:annotated_array] = true if AnnotatedArray === self
-      values = []
-
-      fields.each do |field|
-        values << case
-        when Proc === field
-          field.call(self)
-        when field == "JSON"
-          info.to_json
-        when field == "annotation_types"
-          annotation_types.collect{|t| t.to_s} * "|"
-        when field == "literal"
-          (Array === self ? "Array:" << self * "|" : self).gsub(/\n|\t/, ' ')
-        when info.include?(field.to_sym)
-          res = info.delete(field.to_sym)
-          Array === res ? "Array:" << res * "|" : res
-        when self.respond_to?(field)
-          res = self.send(field)
-          Array === res ? "Array:"<< res * "|" : res
-        end
-      end
+  def annotations
+    if @annotations.nil? 
+      @annotations = []
 
-      values
-    end
-  end
+      annotation_types.each do |annotation_type|
+        @annotations.concat annotation_type.annotations
+      end
 
-  def self.resolve_array(entry)
-    if entry =~ /^Array:/
-      entry["Array:".length..-1].split("|")
+      @annotations
     else
-      entry
+      @annotations
     end
   end
 
-  def self.load_tsv_values(id, values, *fields)
-    fields = fields.flatten
-    info = {}
-    literal_pos = fields.index "literal"
-
-    object = case
-             when literal_pos
-               values[literal_pos]
-             else
-               id.dup
-             end
-
-    object = resolve_array(object)
-
-    if Array === values.first
-      Misc.zip_fields(values).collect do |list|
-        fields.each_with_index do |field,i|
-          if field == "JSON"
-            JSON.parse(list[i]).each do |key, value|
-              info[key.to_sym] = value
-            end
-          else
-            info[field.to_sym] = resolve_array(list[i])
-          end
-        end
+  def masked_annotations
+    if @masked_annotations.nil? 
+      @masked_annotations = []
+
+      annotation_types.each do |annotation_type|
+        @masked_annotations.concat annotation_type.masked_annotations
       end
+
+      @masked_annotations
     else
-      fields.each_with_index do |field,i|
-        if field == "JSON"
-          JSON.parse(values[i]).each do |key, value|
-            info[key.to_sym] = value
-          end
-        else
-          info[field.to_sym] = resolve_array(values[i])
-        end
-      end
+      @masked_annotations
     end
-
-    self.load(object, info)
   end
 
-  def self.json(annotations, literal = false)
-    annotations = [annotations] unless Array === annotations
-    hash = {}
-    annotations.each do |annotation|
-      if literal
-        hash[annotation.id] = annotation.info.merge(:literal => annotation)
-      else
-        hash[annotation.id] = annotation.info
-      end
-    end
-    hash.to_json
+  def unmasked_annotations
+    @unmasked_annotations ||= annotations - masked_annotations
   end
 
-  def self.tsv(annotations, *fields)
-    return nil if annotations.nil?
-    fields = case
-             when ((fields.compact.empty?) and not annotations.empty?)
-               fields = AnnotatedArray === annotations ? annotations.annotations : annotations.compact.first.annotations
-               fields << :annotation_types
-             when (fields == [:literal] and not annotations.empty?)
-               fields << :literal
-             when (fields == [:all] and Annotated === annotations)
-               fields = [:annotation_types] + annotations.annotations 
-               fields << :literal
-             when (fields == [:all] and not annotations.empty?)
-               raise "Input array must be annotated or its elements must be" if not Annotated === annotations.compact.first and not Array === annotations.compact.first
-               raise "Input array must be annotated or its elements must be. No duble arrays of singly annotated entities." if not Annotated === annotations.compact.first and Array === annotations.compact.first
-               fields = [:annotation_types] + (Annotated === annotations ? 
-                                               annotations.annotations : 
-                                               annotations.compact.first.annotations)
-               fields << :literal
-             when annotations.empty?
-               [:annotation_types, :literal]
-             else
-               fields.flatten
-             end
-
-    fields = fields.collect{|f| f.to_s}
+  def info(masked = false)
 
-    case
-    when (Annotated === annotations and not (AnnotatedArray === annotations and annotations.double_array))
-      tsv = TSV.setup({}, :key_field => "List", :fields => fields, :type => :list, :unnamed => true)
-      annot_id = annotations.id
-      tsv[annot_id] = annotations.tsv_values(*fields)
-    when Array === annotations 
-      tsv = TSV.setup({}, :key_field => "ID", :fields => fields, :type => :list, :unnamed => true)
-      annotations.compact.each_with_index do |annotation,i|
-        tsv[annotation.id + ":" << i.to_s] = annotation.tsv_values(*fields)
-        #tsv[annotation.id] = annotation.tsv_values(*fields)
-      end
-    else
-      raise "Annotations need to be an Array to create TSV"
+    if @info.nil?
+      info = annotation_values.dup
+      info[:annotation_types] = annotation_types
+      info[:annotated_array] = true if AnnotatedArray === self
+      @info = info
     end
 
-    tsv
-  end
-
-  def self.load_tsv(tsv)
-    tsv.with_unnamed do
-      annotated_entities = tsv.collect do |id, values|
-        Annotated.load_tsv_values(id, values, tsv.fields)
-      end
-
-      case tsv.key_field 
-      when "List"
-        annotated_entities.first
-      else
-        annotated_entities
+    if masked 
+      if @masked_info.nil?
+        @masked_info = @info.dup
+        masked_annotations.each do |annotation|
+          @masked_info.delete annotation
+        end
       end
+      @masked_info
+    else
+      @info
     end
   end
 
-  def make_list
-    new = [self]
-    annotation_types.each do |mod|
-      mod.setup(new, *info.values_at(*mod.all_annotations))
+  def annotation_md5
+    if annotation_values.instance_variable_get(:@annotation_md5).nil?
+      annotation_values.instance_variable_set(:@annotation_md5, Misc.hash2md5(annotation_values))
     end
-    new.context = self.context
-    new
+    annotation_values.instance_variable_get(:@annotation_md5)
   end
 
-  def annotate(object)
-    annotation_types.each do |mod|
-      mod.setup(object, *info.values_at(*mod.annotations))
-    end
-    object.context = self.context
-    object.container = self.container
-    object
+  def self_md5
+    @self_md5 ||= Misc.digest(annotation_md5 + self.to_s)
   end
-end
-
-
-module Annotation
-  def self.extended(base)
-    if not base.respond_to? :annotations
-      class << base
-        attr_accessor :annotations, :inheritance, :all_inheritance, :all_annotations, :masked_annotations
-
-        def unmasked_annotations
-          annotations - masked_annotations
-        end
-        self
-      end
-
-      base.annotations = []
-      base.masked_annotations = []
-      base.inheritance = []
-      base.all_annotations = []
-      base.all_inheritance = []
 
-      base.module_eval do
-        class << self
-          alias prev_annotation_extended extended
-        end
-
-        def self.extended(object)
-          self.send(:prev_annotation_extended, object)
-          object.extend Annotated unless Annotated === object
-          if not object.annotation_types.include? self
-            object.annotation_types.concat self.inheritance 
-            object.annotation_types << self
-            object.annotation_types.uniq!
-          end
-        end
+  # ToDo This does not make much sense, why not change :id directly
+  def id
+    @id ||= self.respond_to?(:annotation_id) ? 
+      annotation_id : self_md5
+  end
 
-        def self.included(base)
-          base.inheritance << self
-          base.all_inheritance.concat self.all_inheritance if self.respond_to? :all_inheritance
-          base.all_inheritance << self
-          base.all_inheritance.uniq!
-          base.update_annotations
-        end
-      end
+  def annotate(object)
 
+    annotation_types.each do |annotation|
+      object.extend annotation
     end
-  end
 
-  def update_annotations
-    @all_annotations = all_inheritance.inject([]){|acc,mod| acc.concat mod.all_annotations}.concat(@annotations)
-  end
+    object.instance_variable_set(:@annotation_types, nil)
 
-  def annotation(*values)
-    @annotations.concat values.collect{|v| v.to_sym}
-    update_annotations
+    if object.instance_variables.include?(:@annotation_values)
+      hash = {}
+      object.instance_variable_get(:@annotation_values).each{|k,v| hash[k] = v}
+      self.annotation_values.each{|k,v| hash[k] = v}
 
-    module_eval do
-      attr_accessor *values
+      object.instance_variable_set(:@annotation_values, hash)
+      object.instance_variable_set(:@shared_annotations,  false)
+    else
+      object.instance_variable_set(:@annotation_values,  self.annotation_values)
+      object.instance_variable_set(:@shared_annotations,  true)
+      @shared_annotations = true
     end
-  end
 
- def setup_info(object, info)
-    object.extend self unless self === object
-    all_annotations.each do |annotation|
-      object.send(annotation.to_s + '=', info[annotation])
-    end
+    object
   end
 
-  def setup(object, *values)
-    return nil if object.nil?
-
-    object.extend self unless self === object
-
-    if Hash === values.last
-      values.last.each do |name, value|
-        setter = "#{name}="
-        next unless object.respond_to? setter
-        value = value.split("|") if String === value and value.index "|"
-        object.send("#{name}=", value)
+  def clean_annotations(recursive = false)
+    case
+    when self.nil?
+      nil
+    when Array === self
+      if recursive
+        [].concat self.collect{|e| e.respond_to?(:clean_annotations)? e.clean_annotations : e}
+      else
+        [].concat self
       end
+    when String === self
+      "" << self
     else
-      all_annotations.zip(values).each do |name, value|
-        value = value.split("|") if String === value and value.index "|"
-        object.send("#{name}=", value)
-      end
+      self.dup
     end
+  end
 
-    object
+  def make_list
+    new = [self]
+    self.annotate(new)
+    new.extend AnnotatedArray
+    new
   end
 end
 
-module AnnotatedArray
-  extend ChainMethods
 
-  self.chain_prefix = :annotated_array
+#{{{ ANNOTATION
 
-  def double_array
-    AnnotatedArray === self.send(:[], 0, true)
-  end
+module Annotation
+  attr_accessor :annotations, :masked_annotations
 
-  def first
-    self[0]
+  def annotations
+    @annotations ||= []
   end
 
-  def last
-    self[-1]
+  def masked_annotations
+    @masked_annotations ||= []
   end
 
-  def [](pos, clean = false)
-    value = super(pos)
-    return nil if value.nil?
-    return value if clean
-    return value unless String === value or Array === value
-
-    value = value.dup if value.frozen?
-
-    annotation_types.each do |mod| 
-      value.extend mod  unless mod === value
-      mod.annotations.each do |annotation| value.send(annotation.to_s << "=", self.send(annotation)) end
-    end
-
-    value.context         = self.context
-    value.container       = self
-    value.container_index = pos
-
-    value.extend AnnotatedArray if Array === value and AnnotatedArray === self
-
-    value
+  def unmasked_annotations
+    annotations - masked_annotations
   end
 
-  def each
-    i = 0
-    info = info
-    super do |value|
-      if String === value or Array === value
-        value = value.dup if value.frozen? and not value.nil?
+  def annotation(*list)
 
-        annotation_types.each do |mod| 
-          value.extend mod  unless mod === value
-          mod.annotations.each do |annotation| value.send(annotation.to_s << "=", self.send(annotation)) end
-        end
-        
-        value.extend AnnotatedArray if Array === value and AnnotatedArray === self
-      
-        value.context = self.context
-        value.container = self
-        value.container_index = i
+    list.each do |annot|
+      next if annotations.include? annot.to_sym
+      annotations << annot.to_sym
 
+      # Getter
+      self.send(:define_method, annot.to_s) do 
+        annotation_values[annot]
       end
 
-      i += 1
-
-      yield value
-    end
-  end
+      # Setter
+      self.send(:define_method, "#{ annot}=") do |value|
+        if @shared_annotations 
+          detach_annotations # avoid side effects
+        end
 
-  def collect
-    res = []
+        reset
 
-    if block_given?
-      each do |value|
-        res << yield(value)
-      end
-    else
-      each do |value|
-        res << value
+        annotation_values[annot] = value
       end
     end
-
-    res
   end
 
-  def select(method = nil, *args)
-    res = []
-    if method
-      res = self.zip(self.send(method, *args)).select{|e,result| result}.collect{|element,r| element}
-    else
-      each do |value|
-        res << value if yield(value)
-      end
-    end
-
-    annotation_types.each do |mod| 
-      res.extend mod  unless mod === res
-      mod.annotations.each do |annotation| res.send(annotation.to_s + "=", self.send(annotation)) end
-    end
-
-    res.context = self.context
-    res.container = self.container
-
-    res.extend AnnotatedArray if AnnotatedArray === self
-
-    res
+  def setup_hash(object, values)
+    object.instance_variable_set(:@annotation_values,  values)
+    object.instance_variable_set(:@shared_annotations,  true)
+    object.reset
+    object
   end
 
-  def reject
-    res = []
-    each do |value|
-      res << value unless yield(value)
-    end
+  def clean_and_setup_hash(object, hash)
+    annotation_values = object.instance_variable_get(:@annotation_values)
+    annotation_values = annotation_values.nil? ? {} : annotation_values.dup
+    annotation_values.instance_variable_set(:@annotation_md5, nil)
 
-    annotation_types.each do |mod| 
-      res.extend mod  unless mod === res
-      mod.annotations.each do |annotation| res.send(annotation.to_s + "=", self.send(annotation)) end
-    end
-
-    res.context = self.context
-    res.container = self.container
-
-    res.extend AnnotatedArray if AnnotatedArray === self
-
-    res
-  end
+    hash.each do |key, value|
+      begin
+        next unless @annotations.include? (key = key.to_sym)
+      rescue
+        next
+      end
 
-  def subset(list)
-    value = (self & list)
+      value = value.split("|") if String === value and value.index "|"
 
-    annotation_types.each do |mod| 
-      value.extend mod  unless mod === value
-      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
+      annotation_values[key] = value
     end
 
-    value.context = self.context
-    value.container = self.container
+    object.instance_variable_set(:@annotation_values,  annotation_values)
+    object.instance_variable_set(:@shared_annotations,  false)
 
-    value.extend AnnotatedArray if AnnotatedArray === self
+    object.reset
 
-    value
+    object
   end
 
-  def remove(list)
-    value = (self - list)
-
-    annotation_types.each do |mod| 
-      value.extend mod  unless mod === value
-      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
-    end
-
-    value.context = self.context
-    value.container = self.container
+  def setup_positional(object, *values)
+    annotation_values = object.instance_variable_get(:@annotation_values) 
+    annotation_values = annotation_values.nil? ? {} : annotation_values.dup
+    annotation_values.instance_variable_set(:@annotation_md5, nil)
 
-    value.extend AnnotatedArray if AnnotatedArray === self
+    annotations.zip(values).each do |name, value|
 
-    value
-  end
-
-  def compact
-    value = super
+      value = value.split("|") if String === value and value.index "|"
 
-    annotation_types.each do |mod| 
-      value.extend mod  unless mod === value
-      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
+      annotation_values[name] = value
     end
 
-    value.context = self.context
-    value.container = self.container
+    object.instance_variable_set(:@annotation_values,  annotation_values)
 
-    value.extend AnnotatedArray if AnnotatedArray === self
+    object.reset
 
-    value
+    object
   end
- 
-  def uniq
-    value = super
-
-    annotation_types.each do |mod| 
-      value.extend mod  unless mod === value
-      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
-    end
 
-    value.context = self.context
-    value.container = self.container
-
-    value.extend AnnotatedArray if AnnotatedArray === self
-
-    value
-  end
+  def setup(object, *values)
+    return object if object.nil?
 
-  def flatten
-    value = super.dup
+    object.extend self
+    object.extend AnnotatedArray if Array === object
+    object.instance_variable_set(:@annotation_types, nil)
 
-    annotation_types.each do |mod| 
-      value.extend mod  unless mod === value
-      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
+    if Hash === (hash = values.last)
+      clean_and_setup_hash(object, hash)
+    else
+      setup_positional(object, *values)
     end
 
-    value.context = self.context
-    value.container = self.container
-
-    value.extend AnnotatedArray if AnnotatedArray === self
-
-    value
+    object
   end
 
-  def reverse
-    value = super
-
-    annotation_types.each do |mod| 
-      value.extend mod  unless mod === value
-      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
-    end
-
-    value.context = self.context
-    value.container = self.container
-
-    value.extend AnnotatedArray if AnnotatedArray === self
-
-    value
+  def fast_setup(object, hash, shared = false)
+    object.extend self
+    object.extend AnnotatedArray if Array === object
+    object.instance_variable_set(:@annotation_values, hash)
+    object.instance_variable_set(:@shared_annotations, true) if shared
   end
 
-  def sort_by(&block)
-    value = super &block
-
-    annotation_types.each do |mod| 
-      value.extend mod  unless mod === value
-      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
+  def self.extended(object)
+    object.module_eval do
+      include Annotated
     end
-
-    value.context = self.context
-    value.container = self.container
-
-    value.extend AnnotatedArray if AnnotatedArray === self
-
-    value
   end
 
-  def sort(&block)
-    value = self.collect.sort(&block).collect{|value| value.respond_to?(:clean_annotations) ? value.clean_annotations.dup : value.dup }
+  def included(mod)
+    mod.instance_variable_set(:@annotations, self.annotations.dup)
+    mod.instance_variable_set(:@masked_annotations, self.masked_annotations.dup)
+  end
+end
 
-    annotation_types.each do |mod| 
-      value.extend mod  unless mod === value
-      mod.annotations.each do |annotation| value.send(annotation.to_s + "=", self.send(annotation)) end
-    end
 
-    value.extend AnnotatedArray if AnnotatedArray === self
+if __FILE__ == $0
 
-    value
+  module Gene
+    extend Annotation
+    annotation :format, :organism
   end
 
-  def select_by(method)
-    case
-    when (Symbol === method or String === method)
-      method = self.send(method) 
-    when Array === method
-      method = method.dup
-    else
-      raise "Unknown format of method: of class #{method.class}"
-    end
+  a = %w(1 2 3 4 5 6 6)
+  Gene.setup a, "Ensembl Gene ID", "Hsa"
 
-    value = []
-    
-    super do |e|
-      value << e if method.shift
-    end
+  puts a.reject{|a| a.to_i < 6}.collect{|e| e.format}
 
-    value.extend AnnotatedArray if AnnotatedArray === self
-
-    value
-  end
-
-  def self.annotate(list)
-    list[0].annotate list unless AnnotatedArray === list or list[0].nil? or (not list[0].respond_to? :annotate)
-  end
+  puts 
 
+  puts a.reject{|a| a.to_i < 6}.uniq.collect{|e| e.format}
 end
-