rbbt-util 5.0.1 → 5.1.0

data/lib/rbbt/annotations/annotated_array.rb

@@ -0,0 +1,174 @@
+module AnnotatedArray
+  def double_array
+    AnnotatedArray === self.send(:[], 0, true)
+  end
+
+  def first
+    self[0]
+  end
+
+  def last
+    self[-1]
+  end
+
+  def [](pos, clean = false)
+
+    value = super(pos)
+    return value if value.nil? or clean
+
+    value = value.dup if value.frozen?
+
+    value = annotate(value)
+
+    value.extend AnnotatedArray if Array === value
+
+    value.container       = self
+    value.container_index = pos
+
+    value
+  end
+
+  def each(&block)
+
+    pos = 0
+    super do |value|
+
+      if value.nil?
+
+        block.call value
+      else
+
+        value = value.dup if value.frozen?
+
+        value = annotate(value)
+
+        value.extend AnnotatedArray if Array === value
+
+        value.container       = self
+        value.container_index = pos
+
+        pos += 1
+
+        block.call value
+      end
+    end
+  end
+
+  def collect(&block)
+
+    if block_given?
+
+      res = []
+      each do |value|
+        res << yield(value)
+      end
+
+      res
+    else
+
+      res = []
+      each do |value|
+        res << value
+      end
+
+      res
+    end
+  end
+
+  def select(method = nil, *args)
+
+    if method
+
+      res = self.zip( self.send(method, *args) ).
+        select{|e,result| result }. 
+        collect{|element,r| element }
+    else
+
+      return self unless block_given?
+
+      res = []
+      each do |value|
+        res << value if yield(value)
+      end
+    end
+
+    annotate(res)
+    res.extend AnnotatedArray
+
+    res
+  end
+
+  def reject
+    res = []
+
+    each do |value|
+      res << value unless yield(value)
+    end
+
+    annotate(res)
+    res.extend AnnotatedArray
+
+    res
+  end
+
+  def select
+    res = []
+
+    each do |value|
+      res << value if yield(value)
+    end
+
+    annotate(res)
+    res.extend AnnotatedArray
+
+    res
+  end
+
+  def subset(list)
+
+    res = (self & list)
+
+    annotate(res)
+    res.extend AnnotatedArray
+
+    res
+  end
+
+  def remove(list)
+
+    res = (self - list)
+
+    annotate(res)
+    res.extend AnnotatedArray
+
+    res
+  end
+
+  def sort(&block)
+    res = self.collect.sort(&block).collect{|value| value.respond_to?(:clean_annotations) ? value.clean_annotations.dup : value.dup }
+
+    annotate(res)
+    res.extend AnnotatedArray
+
+    res
+  end
+
+
+  %w(compact uniq flatten reverse sort_by).each do |method|
+
+    self.module_eval <<-EOC
+
+      def #{method}
+        res = super
+
+        annotate(res)
+        res.extend AnnotatedArray
+
+        res
+      end
+
+      EOC
+  end
+end
+
+

data/lib/rbbt/annotations/util.rb

@@ -0,0 +1,206 @@
+require 'json'
+
+module Annotated
+
+  def self.load(object, info)
+    annotation_types = info.delete(:annotation_types) || info.delete("annotation_types") || []
+    annotation_types = annotation_types.split("|") if String === annotation_types
+
+    return object if annotation_types.nil? or annotation_types.empty?
+
+    annotated_array = false
+    annotated_array = true if (info.delete(:annotated_array) || info.delete("annotated_array")).to_s == "true"
+    entity_id = info.delete(:entity_id) || info.delete("entity_id")
+
+    annotation_types.each do |mod|
+      mod = Misc.string2const(mod) if String === mod
+      object.extend mod
+    end
+
+    object.instance_variable_set(:@annotation_values, info) 
+
+    object.instance_variable_set(:@id, entity_id) if entity_id
+
+    object.extend AnnotatedArray if annotated_array
+
+    object
+  end
+
+  def self.resolve_array(entry)
+    if entry =~ /^Array:/
+      entry["Array:".length..-1].split("|")
+    else
+      entry
+    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|
+          next if field == "literal"
+          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
+      end
+    else
+      fields.each_with_index do |field,i|
+        next if field == "literal"
+        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
+    end
+
+    self.load(object, info)
+
+    object
+  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
+      end
+    end
+  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 << :annotated_array if AnnotatedArray === 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}
+
+    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).dup
+
+    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).dup
+      end
+
+    else
+      raise "Annotations need to be an Array to create TSV"
+
+    end
+
+    tsv
+  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
+
+      values = []
+
+      fields.each do |field|
+        values << case
+
+        when Proc === field
+          field.call(self)
+
+        when field == "JSON"
+          if AnnotatedArray === self
+            info.merge(:annotated_array => true).to_json
+          else
+            info.to_json
+          end
+
+        when field == "annotation_types"
+          annotation_types.collect{|t| t.to_s} * "|"
+
+        when field == "annotated_array"
+          AnnotatedArray === self
+
+        when field == "literal"
+          (Array === self ? "Array:" << self * "|" : self).gsub(/\n|\t/, ' ')
+
+        when info.include?(field.to_sym)
+          res = info[field.to_sym]
+          Array === res ? "Array:" << res * "|" : res
+
+        when self.respond_to?(field)
+          res = self.send(field)
+          Array === res ? "Array:"<< res * "|" : res
+
+        end
+      end
+
+
+      values
+    end
+  end
+
+
+  end
+

data/lib/rbbt/tsv/accessor.rb

@@ -9,11 +9,37 @@ module TSV
   attr_accessor :unnamed, :serializer_module, :entity_options
 
   def entity_options
-    options = namespace ? {:namespace => namespace, :organism => namespace} : {}
-    if @entity_options
-      options.merge(@entity_options)
+    if @entity_options.nil?
+      @entity_options = namespace ? {:namespace => namespace, :organism => namespace} : {}
+      @entity_templates = nil
+    end
+    @entity_options
+  end
+
+  def prepare_entity(entity, field, options = {})
+    return entity if entity.nil?
+    return entity unless defined? Entity
+    entity = entity if options.delete :dup_array
+    @entity_templates ||= {}
+    if (template = @entity_templates[field])
+      entity = template.annotate(entity.frozen? ? entity.dup : entity)
+      entity.extend AnnotatedArray if Array === entity
+      entity
     else
-      options
+      if @entity_templates.include? field
+        entity
+      else
+        template = Misc.prepare_entity("TEMPLATE", field, options)
+        if Annotated === template
+          @entity_templates[field] = template
+          entity = template.annotate(entity.frozen? ? entity.dup : entity)
+          entity.extend AnnotatedArray if Array === entity
+          entity
+        else
+          @entity_templates[field] = nil
+          entity
+        end
+      end
     end
   end
 
@@ -87,7 +113,7 @@ module TSV
     when :flat, :single
       value = value.dup if value.frozen?
 
-      value = Misc.prepare_entity(value, fields.first, entity_options)
+      value = prepare_entity(value, fields.first, entity_options)
     end
     value
   end
@@ -100,7 +126,7 @@ module TSV
     keys = tsv_clean_keys - ENTRY_KEYS
     return keys if @unnamed or key_field.nil?
 
-    Misc.prepare_entity(keys, key_field, entity_options.merge(:dup_array => true))
+    prepare_entity(keys, key_field, entity_options.merge(:dup_array => true))
   end
 
   def tsv_values
@@ -111,7 +137,7 @@ module TSV
     when :double, :list
       values.each{|value| NamedArray.setup value, fields, nil, entity_options}
     when :flat, :single
-      values = values.collect{|v| Misc.prepare_entity(v, fields.first, entity_options)}
+      values = values.collect{|v| prepare_entity(v, fields.first, entity_options)}
     end
       
     values
@@ -135,10 +161,10 @@ module TSV
           when :double, :list
             NamedArray.setup value, fields, key, entity_options if Array === value
           when :flat, :single
-            Misc.prepare_entity(value, fields.first, entity_options)
+            prepare_entity(value, fields.first, entity_options)
           end
         end
-        key = Misc.prepare_entity(key, key_field, entity_options)
+        key = prepare_entity(key, key_field, entity_options)
       end
 
       yield key, value if block_given?
@@ -162,10 +188,10 @@ module TSV
           when :double, :list
             NamedArray.setup value, fields, key, entity_options if Array === value 
           when :flat, :single
-            value = Misc.prepare_entity(value, fields.first, entity_options)
+            value = prepare_entity(value, fields.first, entity_options)
           end
         end
-        key = Misc.prepare_entity(key, key_field, entity_options)
+        key = prepare_entity(key, key_field, entity_options)
       end
 
 
@@ -229,14 +255,14 @@ module TSV
       if fields == :all
         if just_keys
           keys = elems.sort_by{|key, value| key }.collect{|key, values| key}
-          keys = Misc.prepare_entity(keys, key_field, entity_options.merge(:dup_array => true))
+          keys = prepare_entity(keys, key_field, entity_options.merge(:dup_array => true))
         else
           elems.sort_by{|key, value| key }
         end
       else
         if just_keys
           keys = elems.sort_by{|key, value| value }.collect{|key, value| key}
-          keys = Misc.prepare_entity(keys, key_field, entity_options.merge(:dup_array => true))
+          keys = prepare_entity(keys, key_field, entity_options.merge(:dup_array => true))
           keys
         else
           elems.sort_by{|key, value| value }.collect{|key, value| [key, self[key]]}
@@ -345,8 +371,8 @@ end
   end
 
   entry :key_field, 
-    :fields, 
     :type,
+    :fields,
     :cast,
     :identifiers,
     :namespace,
@@ -358,10 +384,22 @@ end
     if @fields.nil? or @unnamed
       @fields
     else
-      NamedArray.setup @fields, @fields, nil, entity_options
+      @named_fields ||= NamedArray.setup @fields, @fields, nil, entity_options
     end
   end
 
+  def namespace=(value)
+    self.tsv_clean_set_brackets "__tsv_hash_namespace", value.nil? ? NIL_YAML : value.to_yaml
+    @namespace = value
+    @entity_options = nil
+  end
+
+  def fields=(value)
+    self.tsv_clean_set_brackets "__tsv_hash_fields", value.nil? ? NIL_YAML : value.to_yaml
+    @fields = value
+    @named_fields = nil
+  end
+
   def self.zip_fields(list, fields = nil)
     return [] if list.nil? || list.empty?
     fields ||= list.fields if list.respond_to? :fields