rbbt-util 5.3.4 → 5.4.1

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MDVhYjZhYjA1ZDQwYzMxM2I4NjJjY2I0NjFhNjMwMzJmMzlmZTFiNg==
+    MzQxM2Y1NGU5NjBmNjc1M2IzZWExM2ZiNzU0OWIxNzRiZjYyMjdkNg==
   data.tar.gz: !binary |-
-    ZGI5NDE4MDk1ODg5OTIwZjgzOTJiYzQ2MDU2MjgzNWFhOTljNzlmYQ==
+    MjUwNjI3OTFhODA5YTQ0ZThkYzM5OWNiZjFjZGRmMDU1MWY3ZjI0NQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    NjQ2YTgzMTBhN2ZhNzVlN2RmMTMwYjgyNmQ0NWU2ZWY0ZGQ1MmY3Y2ZhYmZk
-    NmQzOTc0NmY0ZjdiYTVkZjM4OTFmYmE1YTZlZWQyYWIyYTU2NTY3NzI5NmEx
-    MzVkMWRmYzI1MjQ4ZDYwMGQzMjA2M2M3NjJjYjk2NmZkM2U1MGQ=
+    Y2Y5ZjBmNWVkOTkwZDNiNmI5NTkyMzJkZjZkN2M1OTY1ZmQzZWQyMWY2Zjkz
+    YTM3MTIyODJkMmRhZjQwNzI3NTIxZjNiNWQzY2Q0ODlmZDg2ODU1OWUxYTkx
+    YTIyOTRjNzA2MGNhZjNmOGVhYmEwMjJjMzZkYjM0ZDNhM2QwZjc=
   data.tar.gz: !binary |-
-    MTIxNjlmMjQxMjI2YjhmYjAwYzdkMmEyNjUyYjE1MjFiZDEyM2E5ZWE0Zjhi
-    ZTRjMzU5MWFiMTUwYzA4YjJkMTNjOWYwMzQzZmU3MDJmMjIzOTMyN2Y4N2Y5
-    ZWU5MTQxN2RhOThkZWQzYzE5YmM5NTdiZWFiM2QxYWVlYzhiZjY=
+    ZDI1MmRlNzhmZGI5ZDJmZGJiNzMyMTkzNjY1ODUyYjQ2ZTM1ZTZlZTBkOTZk
+    N2ZlMDAzOGRmOWY3ZmUyZDExZGVlNDVhOTIzMDQzMjhiNTc3MjgzMjA1Y2Rk
+    YjUxN2MxMjM3NDEyNTk4MGZjYTI2YjlhODZkOTY0YTg0NjFlOTU=

data/lib/rbbt/annotations/annotated_array.rb

@@ -24,8 +24,10 @@ module AnnotatedArray
 
     value.extend AnnotatedArray if Array === value
 
-    value.container       = self
-    value.container_index = pos
+    if value.respond_to? :container
+      value.container       = self
+      value.container_index = pos
+    end
 
     value
   end

data/lib/rbbt/association.rb

@@ -0,0 +1,256 @@
+require 'rbbt-util'
+
+module Association
+  class << self
+    attr_accessor :databases
+    def databases
+      @databases ||= {}
+    end
+  end
+
+  def self.register(database, file, options = {})
+    self.databases[database.to_s] = [file, options]
+  end
+
+  def self.get_database(database)
+    self.databases[database.to_s]
+  end
+
+  def self.open_database(database, options = {}, persist_options = {})
+    file, database_options = get_database database
+    open(file, database_options.merge(options), persist_options)
+  end
+
+  def self.index_database(database, options = {}, persist_options = {})
+    file, database_options = databases[database.to_s]
+    index(file, database_options.merge(options), persist_options)
+  end
+
+  def self.parse_field_specification(spec, fields)
+    spec = spec.split "=>" unless Array === spec
+    field_part, final_type = spec
+
+    field, type = field_part.split "=~"
+
+    [field, type, final_type]
+  end
+
+  def self.resolve_field(name, fields)
+    type = Entity.formats[name]
+    return "Field #{ name } could not be resolved: #{fields}" if type.nil?
+    field = fields.select{|f| Entity.formats[f] == type}.first
+    [field, nil, name]
+  end
+
+  def self.add_reciprocal(tsv)
+    new_tsv = {}
+    tsv.with_unnamed do
+
+      tsv.through do |target,v|
+        source_values = tsv.type == :double ? Misc.zip_fields(v) : [v]
+        
+        source_values.each do |values|
+          source = values.shift
+          values.unshift target
+          current = new_tsv[source] || tsv[source]
+
+          case tsv.type
+          when :double
+            new  = current ? current.zip(values).collect{|p| p.flatten} : values.collect{|p| [p]}
+          when :flat
+            new = current ? (current + values).compact.uniq : values
+          end
+
+          new_tsv[source] = new
+        end
+      end
+
+      tsv.merge! new_tsv
+    end
+
+    tsv
+  end
+
+  def self.load_tsv(file, options)
+    key_field = TSV.parse_header(file, options).key_field
+    fields = TSV.parse_header(file, options).fields
+    all_fields = TSV.parse_header(file, options).all_fields
+    
+    source = options[:source] || options[:source_type]
+    source = TSV.identify_field key_field, fields, options[:key_field] if source.nil? and options[:key_field]
+    source = all_fields[source] if Fixnum === source
+    source = key_field if source == :key or source.nil?
+
+    target = options[:target]
+    target = TSV.identify_field key_field, fields, options[:fields].first if target.nil? and options[:fields]
+    target = all_fields[target] if Fixnum === target
+    target = key_field if target == :key
+
+    zipped = options[:zipped]
+    undirected = options[:undirected]
+
+    source, source_header, source_final_type = parse_field_specification source, all_fields
+    target, target_header, target_final_type = parse_field_specification target, all_fields if target
+
+    if source and not all_fields.include? source
+      Log.debug("Resolving source: #{ source }")
+      source, source_header, source_final_type = resolve_field source, all_fields
+      Log.debug([source, source_header, source_final_type] * ", ")
+    end
+
+    if target and not all_fields.include? target
+      Log.debug("Resolving target: #{ target }")
+      target, target_header, target_final_type = resolve_field target, all_fields
+      Log.debug([target, target_header, target_final_type] * ", ")
+    end
+
+    source_final_type ||= options[:source_type] if options[:source_type]
+    target_final_type ||= options[:target_type] if options[:target_type]
+
+    Log.debug("Loading associations from: #{ file }")
+    Log.debug("sources: #{[source, source_header, source_final_type] * ", "}")
+    Log.debug("targets: #{[target, target_header, target_final_type] * ", "}")
+    if source != all_fields.first or (target and target != all_fields[1])
+      fields = ([target] + (all_fields - [source, target])).compact
+      open_options = options.merge({:key_field => source, :fields => fields})
+      tsv = TSV.open(file, open_options)
+    else
+      tsv = TSV.open(file, options)
+    end
+
+    if source_header and tsv.key_field != source_header
+      tsv.key_field = source_header
+    end
+
+    if source_final_type and tsv.key_field != source_final_type
+      Log.debug("Changing source type from #{tsv.key_field} to #{source_final_type}")
+      tsv.with_unnamed do
+        tsv = TSVWorkflow.job(:change_id, tsv.filename, :tsv => tsv, :format => source_final_type, :organism => tsv.namespace).exec
+      end
+    end
+
+    if target_header and tsv.fields.first != target_header
+      tsv.fields = tsv.fields.collect{|f| f == target ? target_header : f }
+    end
+
+    if target_final_type and tsv.fields.first != target_final_type and
+      Entity.formats[tsv.fields.first] and
+      Entity.formats[tsv.fields.first] == Entity.formats[target_final_type]
+
+      Log.debug("Changing target type from #{tsv.fields.first} to #{source_final_type}")
+      save_key_field = tsv.key_field
+      tsv.key_field = "MASKED"
+      tsv.with_unnamed do
+        tsv = TSVWorkflow.job(:swap_id, tsv.filename, :tsv => tsv, :field => tsv.fields.first, :format => target_final_type, :organism => tsv.namespace).exec
+      end
+      tsv.key_field = save_key_field 
+    end
+
+    if undirected
+      tsv = add_reciprocal tsv
+    end
+
+    tsv
+  end
+
+  def self.open(file, options = {}, persist_options = {})
+    options = {} if options.nil?
+    persist_options = {} if persist_options.nil?
+
+    namespace = options[:namespace]
+    old_file, file = file, file.sub('NAMESPACE', namespace) if namespace and String === file
+    old_file.annotate file if Path === old_file
+
+    Persist.persist_tsv(file, nil, options, {:persist => true, :prefix => "Association"}.merge(persist_options)) do |data|
+      options = options.clone
+
+      tsv = load_tsv(file, options)
+
+      tsv.annotate(data)
+      data.serializer = tsv.type if TokyoCabinet::HDB === data
+      data.merge! tsv
+      tsv.annotate data
+
+      data
+    end
+  end
+
+  def self.index(file, options = {}, persist_options = {})
+    options = {} if options.nil?
+    persist_options = {} if persist_options.nil?
+
+    Persist.persist_tsv(file, nil, options, {:persist => true, :prefix => "Association Index"}.merge(persist_options).merge(:engine => TokyoCabinet::BDB, :serializer => :clean)) do |assocs|
+      undirected = options[:undirected]
+      tsv = TSV === file ? file : Association.open(file, options, persist_options.merge(:persist => false))
+
+      key_field = [tsv.key_field, tsv.fields.first.split(":").last, undirected ? "undirected" : nil].compact * "~"
+
+      TSV.setup(assocs, :key_field => key_field, :fields => tsv.fields[1..-1], :type => :list, :serializer => :list)
+
+      tsv.with_unnamed do
+        tsv.with_monitor :desc => "Extracting annotations" do
+          case tsv.type
+          when :flat
+            tsv.through do |source, targets|
+              next if source.nil? or source.empty? or targets.nil? or targets.empty?
+
+              targets.each do |target|
+                next if target.nil? or target.empty?
+                key = [source, target] * "~"
+                assocs[key] = nil
+              end
+            end
+
+          when :double
+            tsv.through do |source, values|
+              next if values.empty?
+              next if source.nil?
+              next if values.empty?
+              targets = values.first
+              rest = Misc.zip_fields values[1..-1]
+
+              annotations = rest.length > 1 ?
+                targets.zip(rest) :
+                targets.zip(rest * targets.length) 
+
+              annotations.each do |target, info|
+                next if target.nil?
+                key = [source, target] * "~"
+                assocs[key] = info
+              end
+            end
+          else
+            raise "Type not supported: #{tsv.type}"
+          end
+        end
+      end
+      assocs.close
+
+      assocs
+    end
+  end
+
+  def self.connections(repo, entities)
+    source_field, target_field, undirected = repo.key_field.split("~")
+
+    source_type = Entity.formats[source_field].to_s
+    target_type = Entity.formats[target_field].to_s
+
+    source_entities = entities[source_type] || entities[source_field]
+    target_entities = entities[target_type] || entities[target_field]
+
+    return [] if source_entities.nil? or target_entities.nil?
+
+    source_entities.collect do |entity|
+      keys = repo.prefix(entity + "~")
+      keys.collect do |key|
+        source, target = key.split("~")
+        next unless target_entities.include? target
+        next if undirected and target > source
+        info = Hash[*repo.fields.zip(repo[key]).flatten]
+
+        {:source => source, :target => target, :info => info}
+      end.compact
+    end.flatten
+  end
+end

data/lib/rbbt/resource/path.rb

@@ -10,11 +10,16 @@ module Path
     string.resource = resource
     string
   end
+
+  def annotate(name)
+    Path.setup name.to_s, @pkgdir, @resource
+  end
+
   def join(name)
     if self.empty?
-      Path.setup name.to_s, @pkgdir, @resource
+      self.annotate name.to_s
     else
-      Path.setup File.join(self, name.to_s), @pkgdir, @resource
+      self.annotate File.join(self, name.to_s)
     end
   end
 

data/lib/rbbt/tsv/accessor.rb

@@ -540,6 +540,17 @@ end
     peek
   end
 
+  def summary
+    <<-EOF
+Key field = #{key_field}
+Fields = #{fields * ", "}
+Type = #{type}
+Example:
+  - #{key = keys.first}: #{self[key].inspect}
+
+    EOF
+  end
+
   def to_hash
     new = self.dup
     ENTRY_KEYS.each{|entry| new.delete entry}

data/lib/rbbt/tsv/attach/util.rb

@@ -237,19 +237,7 @@ module TSV
     end
   end
 
-  def self.build_traverse_index(files, options = {})
-    options       = Misc.add_defaults options, :in_namespace => false, :persist_input => true
-    in_namespace  = options[:in_namespace]
-    persist_input = options[:persist_input]
-
-    path = find_path(files, options)
-
-    return nil if path.nil?
-
-    traversal_ids = path.collect{|p| p.first}
-
-    Log.debug "Found Traversal: #{traversal_ids * " => "}"
-
+  def self.index_for_traversal(path, persist_input = false)
     data_key, data_file = path.shift
     data_index = if data_key == data_file.key_field
                    Log.debug "Data index not required '#{data_file.key_field}' => '#{data_key}'"
@@ -292,6 +280,23 @@ module TSV
     end
 
     current_index
+
+  end
+
+  def self.build_traverse_index(files, options = {})
+    options       = Misc.add_defaults options, :in_namespace => false, :persist_input => true
+    in_namespace  = options[:in_namespace]
+    persist_input = options[:persist_input]
+
+    path = find_path(files, options)
+
+    return nil if path.nil?
+
+    traversal_ids = path.collect{|p| p.first}
+
+    Log.debug "Found Traversal: #{traversal_ids * " => "}"
+
+    index_for_traversal path, persist_input
   end
 
 

data/lib/rbbt/tsv/filter.rb

@@ -187,14 +187,14 @@ module Filtered
     end
   end
 
-  def filtered_set(key, value)
+  def filtered_set(key, value, clean = false)
     if filters.empty?
-      self.send(:unfiltered_set, key, value)
+      self.send(:unfiltered_set, key, value, clean)
     else
       filters.each do |filter| 
         filter.add key if filter.match_entry key, value
       end
-      self.send(:unfiltered_set, key, value)
+      self.send(:unfiltered_set, key, value, clean)
     end
   end
 

data/lib/rbbt/tsv/manipulate.rb

@@ -257,7 +257,7 @@ module TSV
         data.namespace = namespace
         data.entity_options = entity_options
         data.entity_templates = entity_templates
-        data.type = type
+        data.type = zipped ? :list : type
       end
     end
   end

data/lib/rbbt/tsv/parser.rb

@@ -187,6 +187,12 @@ module TSV
 
     def add_to_data_merge_zipped(data, keys, values)
       num = keys.length
+
+      if values.first.length > 1 and num == 1
+        keys = keys * values.first.length
+        num = keys.length
+      end
+
       values = values.collect{|v| v.length != num ? [v.first] * num : v}
       all = values.unshift keys
       Misc.zip_fields(all).each do |values|
@@ -204,6 +210,12 @@ module TSV
 
     def add_to_data_zipped(data, keys, values)
       num = keys.length
+
+      if values.first.length > 1 and num == 1
+        keys = keys * values.first.length
+        num = keys.length
+      end
+
       values = values.collect{|v| v.length != num ? [v.first] * num : v}
       all = values.unshift keys
       Misc.zip_fields(all).each do |values|
@@ -309,7 +321,6 @@ module TSV
       options = header_options.merge options
 
       @type = Misc.process_options(options, :type) || :double
-      merge = Misc.process_options(options, :merge) || false
 
       @sep2 = Misc.process_options(options, :sep2) || "|"
       @cast = Misc.process_options options, :cast; @cast = @cast.to_sym if String === @cast
@@ -318,6 +329,9 @@ module TSV
       @select= Misc.process_options options, :select
       @zipped = Misc.process_options options, :zipped
       @namespace = Misc.process_options options, :namespace
+      merge = Misc.process_options(options, :merge)
+      merge = @zipped if merge.nil?
+      merge = false if merge.nil?
 
       case @type
       when :double 

data/lib/rbbt/tsv/util.rb

@@ -62,13 +62,16 @@ module TSV
     case
     when Integer === field
       field
-    when (field.nil? or field == :key or key_field == field)
+    when (field.nil? or field == :key)
       :key
-    when String === field
-      raise "No fields specified in TSV.identify_field" if fields.nil?
+    when (String === field and not fields.nil?)
       pos = fields.index field
+      pos ||= :key if key_field == field
       Log.medium "Field #{ field } was not found. Options: #{fields * ", "}" if pos.nil?
       pos
+    else
+      raise "No fields specified in TSV.identify_field" if fields.nil?
+      Log.medium "Field #{ field } was not found. Options: (#{key_field}), #{fields * ", "}"
     end
   end
 
@@ -76,5 +79,55 @@ module TSV
     TSV.identify_field(key_field, fields, field)
   end
 
+  def to_double
+    new = {}
+    case type
+    when :double
+      self
+    when :flat
+      through do |k,v|
+        new[k] = [v]
+      end
+    when :single
+      through do |k,v|
+        new[k] = [[v]]
+      end
+    when :list
+      through do |k,v|
+        new[k] = v.collect{|e| [e]}
+      end
+    end
+    self.annotate(new)
+    new.type = :double
+    new
+  end
+
+  def to_flat(field = nil)
+    new = {}
+    case type
+    when :double
+      if field.nil?
+        through do |k,v| new[k] = v.first end
+      else
+        pos = identify_field field
+        through do |k,v| new[k] = v[pos] end
+      end
+    when :flat
+      self
+    when :single
+      through do |k,v|
+        new[k] = [v]
+      end
+    when :list
+      through do |k,v|
+        new[k] = [v.first]
+      end
+    end
+    self.annotate(new)
+    new.type = :flat
+    new
+  end
+
+
 
 end

data/lib/rbbt/tsv.rb

@@ -96,7 +96,7 @@ module TSV
         Parser.new f, options
       end
     when (String === stream and stream.length < 300 and Open.exists? stream)
-      stream.open do |f|
+      Open.open(stream) do |f|
         Parser.new f, options
       end
     else

data/lib/rbbt/util/misc.rb

@@ -184,15 +184,15 @@ module Misc
   ARRAY_MAX_LENGTH = 1000
   STRING_MAX_LENGTH = ARRAY_MAX_LENGTH * 10
 
-  def self.sanitize_filename(filename, length = 200)
+  def self.sanitize_filename(filename, length = 254)
     if filename.length > length
-      if filename =~ /(\..{2,4})$/
+      if filename =~ /(\..{2,9})$/
         extension = $1
       else
         extension = ''
       end
 
-      post_fix = " TRUNCATED at #{length} (#{filename.length})" + extension
+      post_fix = "--#{filename.length}@#{length}_#{Misc.digest(filename)[0..4]}" + extension
 
       filename = filename[0..(length - post_fix.length - 1)] << post_fix
     else

data/lib/rbbt/util/named_array.rb

@@ -87,10 +87,11 @@ module NamedArray
   def [](key, clean = false)
     pos = Misc.field_position(fields, key)
     elem = super(pos)
+    return elem if clean
 
     return elem if @fields.nil? or @fields.empty?
 
-    field = NamedArray === @fields ? @fields.named_array_clean_get_brackets(pos) : @fields[pos]
+    field = NamedArray === @fields ? @fields[pos, true] : @fields[pos]
     elem = prepare_entity(elem, field, entity_options)
     elem
   end

data/lib/rbbt/workflow/step.rb

@@ -12,6 +12,7 @@ class Step
   class Aborted < Exception; end
 
   def initialize(path, task = nil, inputs = nil, dependencies = nil, bindings = nil)
+    path = Misc.sanitize_filename path
     @path = Path.setup(path)
     @task = task
     @bindings = bindings
@@ -172,6 +173,10 @@ class Step
         FileUtils.mkdir_p File.dirname(path) unless Open.exists? File.dirname(path)
         begin
           run(true)
+        rescue Step::Aborted
+          Log.debug("Forked process aborted: #{@path}")
+          log :aborted, "Aborted"
+          exit -1
         rescue Exception
           Log.debug("Exception caught on forked process: #{$!.message}")
           exit -1

data/share/rbbt_commands/app/start

@@ -15,7 +15,7 @@ app_dir = app_dir[app]
 server = options[:server] || 'thin'
 Misc.in_dir(app_dir) do
   require 'rack'
-  ENV["RBBT_FINDER"] = true if options.include?(:finder)
+  ENV["RBBT_FINDER"] = "true" if options.include?(:finder)
   ENV["RACK_ENV"] = options[:environment] if options.include?(:environment)
   Rack::Server.start(options.merge(:config => 'config.ru'))
 end

data/test/rbbt/test_association.rb

@@ -0,0 +1,76 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+require 'rbbt/workflow'
+require 'rbbt/association'
+require 'rbbt/entity'
+require 'rbbt/util/tmpfile'
+require 'test/unit'
+
+Workflow.require_workflow "Genomics"
+require 'rbbt/entity/gene'
+
+Workflow.require_workflow "TSVWorkflow"
+
+TEST_ASSOCIATIONS =<<-EOF
+#: :sep=" "#:namespace=Hsa/jan2013
+#Entity1 Entity2 Score Entity3 Gene
+a A 1 aa TP53
+b B 2 bb KRAS
+c C|K 3|4 cc|kk PTEN|PTEN
+EOF
+
+class TestAssociations < Test::Unit::TestCase
+  
+  FAssocs = ""
+  DAssocs = ""
+  def setup
+    FAssocs.replace TmpFile.tmp_file
+    DAssocs.replace TmpFile.tmp_file
+    Open.write(FAssocs, TEST_ASSOCIATIONS)
+  end
+  def teardown
+    FileUtils.rm FAssocs
+    FileUtils.rm_rf DAssocs
+  end
+
+  def test_simple_open
+    database = Association.open(FAssocs, {}, :dir => DAssocs)
+    assert_equal ["C", "K"], database["c"]["Entity2"]
+  end
+ 
+  def test_source_open
+    database = Association.open(FAssocs, {:source => "Entity2", :zipped => true}, :dir => DAssocs)
+    assert_equal ["c", "3", 'cc', "PTEN"], database["C"].flatten
+    assert_equal ["c", "4", 'kk', "PTEN"], database["K"].flatten
+  end
+  
+  def test_target_open
+    database = Association.open(FAssocs, {:source => "Entity2", :target => "Entity3", :zipped => true}, :dir => DAssocs)
+    assert_equal ["cc", "c", "3", "PTEN"], database["C"].flatten
+    assert_equal ["kk", "c", "4", "PTEN"], database["K"].flatten
+  end
+
+  def test_gene_open
+    database = Association.open(FAssocs, {:source => "Gene=~Associated Gene Name", :target => "Entity3", :zipped => true}, :dir => DAssocs)
+    assert_equal ["aa"], database["TP53"].first
+  end
+
+  def test_gene_open_translate
+    tp53 = Gene.setup("TP53", "Associated Gene Name", "Hsa/jan2013")
+    database = Association.open(FAssocs, {:source => "Gene=~Associated Gene Name", :source_type => "Ensembl Gene ID", :target => "Entity3", :zipped => true}, :dir => DAssocs)
+    assert_equal ["aa"], database[tp53.ensembl].first
+  end
+
+  def test_gene_target_open_translate
+    tp53 = Gene.setup("TP53", "Associated Gene Name", "Hsa/jan2013")
+    database = Association.open(FAssocs, {:target => "Gene=~Associated Gene Name=>Ensembl Gene ID", :source => "Entity3", :zipped => true}, :dir => DAssocs)
+    assert_equal [tp53.ensembl], database["aa"].first
+  end
+
+  def test_undirected
+    require 'rbbt/sources/pina'
+    require 'rbbt/gene_associations'
+    tp53 = Gene.setup("TP53", "Associated Gene Name", "Hsa/jan2013")
+    index = Association.index_database('pina', {:source_type => "Ensembl Gene ID", :target_type => "Ensembl Gene ID", :undirected => true}, {:dir => DAssocs})
+    assert Association.connections(index, "Gene" => tp53.pina_interactors.ensembl.compact).any?
+  end
+end

data/test/rbbt/tsv/test_attach.rb

@@ -446,5 +446,33 @@ bb   Id4
     assert_equal %w(ValueA ValueB OtherID), tsv1.fields
     assert_equal %w(Id1 Id4), tsv1["row3"]["OtherID"]
   end
+
+  def test_attach_flat
+    content1 =<<-EOF
+#Id    ValueA    ValueB
+row1    a|aa|aaa    b
+row2    A    B
+    EOF
+
+    content2 =<<-EOF
+#ValueA    OtherID
+a    Id1|Id2
+A    Id3
+    EOF
+
+    tsv1 = tsv2 = index = nil
+    TmpFile.with_file(content1) do |filename|
+      tsv1 = TSV.open(File.open(filename), :flat, :fields => ["ValueA"], :sep => /\s+/)
+      puts tsv1
+    end
+
+    TmpFile.with_file(content2) do |filename|
+      tsv2 = TSV.open(File.open(filename), :double, :sep => /\s+/)
+    end
+
+    res = tsv1.attach tsv2, :fields => ["OtherID"]
+    puts res
+
+  end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbbt-util
 version: !ruby/object:Gem::Version
-  version: 5.3.4
+  version: 5.4.1
 platform: ruby
 authors:
 - Miguel Vazquez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-02 00:00:00.000000000 Z
+date: 2013-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -173,6 +173,7 @@ files:
 - lib/rbbt/annotations.rb
 - lib/rbbt/annotations/annotated_array.rb
 - lib/rbbt/annotations/util.rb
+- lib/rbbt/association.rb
 - lib/rbbt/entity.rb
 - lib/rbbt/fix_width_table.rb
 - lib/rbbt/persist.rb
@@ -240,6 +241,7 @@ files:
 - test/rbbt/tsv/test_attach.rb
 - test/rbbt/tsv/test_manipulate.rb
 - test/rbbt/test_fix_width_table.rb
+- test/rbbt/test_association.rb
 - test/rbbt/test_workflow.rb
 - test/rbbt/workflow/test_step.rb
 - test/rbbt/workflow/test_task.rb
@@ -303,6 +305,7 @@ test_files:
 - test/rbbt/tsv/test_attach.rb
 - test/rbbt/tsv/test_manipulate.rb
 - test/rbbt/test_fix_width_table.rb
+- test/rbbt/test_association.rb
 - test/rbbt/test_workflow.rb
 - test/rbbt/workflow/test_step.rb
 - test/rbbt/workflow/test_task.rb