rbbt-util 4.1.0 → 4.2.0

data/lib/rbbt/persist/tsv.rb

@@ -88,7 +88,7 @@ module Persist
     database
   end
 
-  def self.persist_tsv(source, filename, options, persist_options = {})
+  def self.persist_tsv(source, filename, options = {}, persist_options = {})
     persist_options[:prefix] ||= "TSV"
 
     data = case

data/lib/rbbt/resource/path.rb

@@ -181,7 +181,7 @@ module Path
     if identifier_file_path.nil?
       []
     else
-      [identifier_file_path.nil?]
+      [identifier_file_path]
     end
   end
 end

data/lib/rbbt/tsv.rb

@@ -1,6 +1,7 @@
 require 'yaml'
 
 require 'rbbt/util/misc'
+require 'rbbt/util/named_array'
 require 'rbbt/util/log'
 
 require 'rbbt/persist'
@@ -38,10 +39,11 @@ module TSV
 
     filename = get_filename source
     serializer = Misc.process_options options, :serializer
+    unnamed = Misc.process_options options, :unnamed
 
     Log.debug "TSV open: #{ filename } - #{options.inspect}"
 
-    Persist.persist_tsv source, filename, options, persist_options do |data|
+    data = Persist.persist_tsv source, filename, options, persist_options do |data|
       if serializer
         data.extend TSV unless TSV === data
         data.serializer = serializer
@@ -57,6 +59,10 @@ module TSV
 
       data
     end
+
+    data.unnamed = unnamed unless unnamed.nil?
+
+    data
   end
 
   def self.parse_header(stream, options = {})

data/lib/rbbt/tsv/accessor.rb

@@ -68,13 +68,14 @@ module TSV
 
   def tsv_get_brackets(key)
     value = serialized_get(key)
-    return value if @unnamed or fields.nil?
+    return value if value.nil? or @unnamed or fields.nil?
 
     case type
     when :double, :list
-      NamedArray.setup value, fields, key 
+      NamedArray.setup value, fields, key, namespace
     when :flat, :single
-      Entity.formats[fields.first].setup(value, :format => fields.first) if defined?(Entity) and Entity.respond_to?(:formats) and Entity.formats.include? fields.first
+      value = value.dup if value.frozen?
+      Entity.formats[fields.first].setup(value, (namespace ? {:namespace => namespace, :organism => namespace} : {}).merge({:format => fields.first})) if defined?(Entity) and Entity.respond_to?(:formats) and Entity.formats.include? fields.first
     end
     value
   end
@@ -88,7 +89,7 @@ module TSV
     return keys if @unnamed or key_field.nil?
 
     if defined?(Entity) and  Entity.respond_to?(:formats) and Entity.formats.include? key_field
-      Entity.formats[key_field].setup(keys.collect{|k| k.dup}, :format => key_field)
+      Entity.formats[key_field].setup(keys.collect{|k| k.dup}, (namespace ? {:namespace => namespace, :organism => namespace} : {}).merge({:format => key_field}) )
     else
       keys
     end
@@ -100,10 +101,10 @@ module TSV
 
     case type
     when :double, :list
-      values.each{|value| NamedArray.setup value, fields }
+      values.each{|value| NamedArray.setup value, fields, nil, namespace }
     when :flat, :single
       values.each{|value| 
-        Entity.formats[fields.first].setup(value, :format => fields.first)
+        Entity.formats[fields.first].setup(value, (namespace ? {:namespace => namespace, :organism => namespace} : {}).merge({:format => fields.first}))
       } if defined?(Entity) and Entity.respond_to?(:formats) and Entity.formats.include? fields.first
     end
       
@@ -126,13 +127,13 @@ module TSV
         if not fields.nil? 
           case type
           when :double, :list
-            NamedArray.setup value, fields, key if Array === value 
+            NamedArray.setup value, fields, key, namespace if Array === value 
           when :flat, :single
-            Entity.formats[fields.first].setup(value, :format => fields.first) if defined?(Entity) and Entity.respond_to?(:formats) and Entity.formats.include? fields.first
+            Entity.formats[fields.first].setup(value, (namespace ? {:namespace => namespace, :organism => namespace} : {}).merge({:format => fields.first})) if defined?(Entity) and Entity.respond_to?(:formats) and Entity.formats.include? fields.first
           end
         end
         if defined?(Entity) and not key_field.nil? and Entity.respond_to?(:formats) and Entity.formats.include? key_field
-          key = Entity.formats[key_field].setup(key.dup, :format => key_field) 
+          key = Entity.formats[key_field].setup(key.dup, (namespace ? {:namespace => namespace, :organism => namespace} : {}).merge({:format => key_field})) 
         end
       end
 
@@ -155,13 +156,13 @@ module TSV
         if not fields.nil? 
           case type
           when :double, :list
-            NamedArray.setup value, fields, key if Array === value 
+            NamedArray.setup value, fields, key, namespace if Array === value 
           when :flat, :single
-            Entity.formats[fields.first].setup(value, :format => fields.first) if defined?(Entity) and Entity.respond_to?(:formats) and Entity.formats.include? fields.first
+            Entity.formats[fields.first].setup(value, (namespace ? {:namespace => namespace, :organism => namespace} : {}).merge({:format => fields.first})) if defined?(Entity) and Entity.respond_to?(:formats) and Entity.formats.include? fields.first
           end
         end
         if defined?(Entity) and not key_field.nil? and Entity.respond_to?(:formats) and Entity.formats.include? key_field
-          key = Entity.formats[key_field].setup(key.dup, :format => key_field) 
+          key = Entity.formats[key_field].setup(key.dup, (namespace ? {:namespace => namespace, :organism => namespace} : {}).merge({:format => key_field})) 
         end
       end
 
@@ -215,13 +216,16 @@ module TSV
     if not block_given?
       if fields == :all
         if just_keys
-          elems.sort_by{|key, value| key }.collect{|key, values| key}
+          keys = elems.sort_by{|key, value| key }.collect{|key, values| key}
+          Entity.formats[key_field].setup(keys, (namespace ? {:namespace => namespace, :organism => namespace} : {}).merge({:format => key_field})) if defined?(Entity) and Entity.respond_to?(:formats) and Entity.formats.include? key_field
         else
           elems.sort_by{|key, value| key }
         end
       else
         if just_keys
-          elems.sort_by{|key, value| value }.collect{|key, value| key}
+          keys = elems.sort_by{|key, value| value }.collect{|key, value| key}
+          Entity.formats[key_field].setup(keys, (namespace ? {:namespace => namespace, :organism => namespace} : {}).merge({:format => fields.first})) if defined?(Entity) and Entity.respond_to?(:formats) and Entity.formats.include? key_field
+          keys
         else
           elems.sort_by{|key, value| value }.collect{|key, value| [key, self[key]]}
         end
@@ -299,8 +303,9 @@ if '#{entry}' == 'serializer'
 
     else
       class << self
-        
+
         define_method :serialized_get do |key|
+          return nil unless self.include? key
           self.serializer_module.load(tsv_clean_get_brackets(key))
         end
 
@@ -335,7 +340,7 @@ end
     if @fields.nil? or @unnamed
       @fields
     else
-      NamedArray.setup @fields, @fields
+      NamedArray.setup @fields, @fields, nil, namespace
     end
   end
 

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

@@ -235,19 +235,10 @@ module TSV
 
       if current_index.nil?
         current_index = next_file.index(:target => next_key, :fields => [current_key], :persist => persist_input)
+        current_index = current_index.select :key => data_file.keys
       else
         next_index = next_file.index :target => next_key, :fields => [current_key], :persist => persist_input
 
-        if TokyoCabinet::HDB === current_index
-          tmp = TSV.setup({}, :key_field => current_index.key_field, :fields => [current_index.fields], :serializer => current_index.serializer, :type => current_index.type, :filename => current_index.filename)
-          current_index.with_unnamed do
-            current_index.each do |key,value|
-              tmp.tsv_clean_set_brackets(key, current_index.tsv_clean_get_brackets(key))
-            end
-          end
-          current_index = tmp
-        end
-
         next_index.with_unnamed do
           current_index.with_unnamed do
             current_index.process current_index.fields.first do |values|

data/lib/rbbt/tsv/manipulate.rb

@@ -245,6 +245,7 @@ module TSV
         data.key_field = new_key_field_name
         data.fields = new_field_names
         data.filename = filename
+        data.namespace = namespace
         data.type = type
       end
     end
@@ -281,9 +282,10 @@ module TSV
     new = TSV.setup({}, :key_field => key_field, :fields => fields, :type => type, :filename => filename, :identifiers => identifiers)
 
     new.key_field = key_field
-    new.fields    = fields.dup
+    new.fields    = fields.dup unless fields.nil?
     new.type      = type
     new.filename  = filename
+    new.namespace = namespace
     
    case
     when (method.nil? and block_given?)
@@ -429,15 +431,31 @@ module TSV
   end
 
   def add_field(name = nil)
+    old_monitor = @monitor
+    @monitor = {:desc => "Adding field #{ name }"} if TrueClass === monitor
+
     through do |key, values|
       new_values = yield(key, values)
       new_values = [new_values] if type == :double and not Array === new_values
 
-      values << new_values
+      case
+      when (values.nil? and (fields.nil? or fields.empty?))
+        values = [new_values]
+      when values.nil?  
+        values = [nil] * fields.length + [new_values]
+      when NamedArray === values
+        values += [new_values]
+      else
+        values << new_values
+      end
       self[key] = values
     end
+    @monitor = old_monitor
 
-    self.fields = self.fields + [name] if fields != nil and name != nil
+    if not fields.nil? and not name.nil?
+      fields = self.fields + [name]
+      self.fields = fields
+    end
 
     self
   end

data/lib/rbbt/tsv/parser.rb

@@ -1,7 +1,7 @@
 require 'rbbt/util/cmd'
 module TSV
   class Parser
-    attr_accessor :header_hash, :sep, :sep2, :type, :key_position, :field_positions, :cast, :key_field, :fields, :fix, :select, :serializer, :straight, :take_all, :zipped
+    attr_accessor :header_hash, :sep, :sep2, :type, :key_position, :field_positions, :cast, :key_field, :fields, :fix, :select, :serializer, :straight, :take_all, :zipped, :namespace
 
     class SKIP_LINE < Exception; end
     class END_PARSING < Exception; end
@@ -62,6 +62,16 @@ module TSV
       line.split(@sep, -1)
     end
 
+    def get_values_single_from_flat(parts)
+      return parts.shift, parts.first if field_positions.nil? and key_position.nil?
+      if key_position == 0
+        [parts.shift, parts]
+      else
+        key = parts.shift
+        [parts, [key]]
+      end
+    end
+
     def get_values_single(parts)
       return parts.shift, parts.first if field_positions.nil? and key_position.nil?
       key = parts[key_position]
@@ -287,7 +297,8 @@ module TSV
       @header_hash = Misc.process_options(options, :header_hash) || "#"
       @sep = Misc.process_options(options, :sep) || "\t"
 
-      options = parse_header(stream).merge options
+      header_options = parse_header(stream)
+      options = header_options.merge options
 
       @type = Misc.process_options(options, :type) || :double
       merge = Misc.process_options(options, :merge) || false
@@ -298,6 +309,7 @@ module TSV
       @fix = Misc.process_options(options, :fix) 
       @select= Misc.process_options options, :select
       @zipped = Misc.process_options options, :zipped
+      @namespace = Misc.process_options options, :namespace
 
       case @type
       when :double 
@@ -314,9 +326,15 @@ module TSV
           self.instance_eval do alias add_to_data add_to_data_no_merge_double end
         end
       when :single
-        self.instance_eval do alias get_values get_values_single end
-        self.instance_eval do alias cast_values cast_values_single end
-        self.instance_eval do alias add_to_data add_to_data_no_merge_list end
+        if header_options[:type] == :flat
+          self.instance_eval do alias get_values get_values_single_from_flat end
+          self.instance_eval do alias cast_values cast_values_single end
+          self.instance_eval do alias add_to_data add_to_data_no_merge_double end
+        else
+          self.instance_eval do alias get_values get_values_single end
+          self.instance_eval do alias cast_values cast_values_single end
+          self.instance_eval do alias add_to_data add_to_data_no_merge_list end
+        end
       when :list
         self.instance_eval do alias get_values get_values_list end
         self.instance_eval do alias cast_values cast_values_list end
@@ -343,6 +361,7 @@ module TSV
       data.type = @type
       data.key_field = @key_field
       data.fields = @fields
+      data.namespace = @namespace
       data
     end
   end

data/lib/rbbt/tsv/util.rb

@@ -46,7 +46,7 @@ module TSV
 
     path = Persist.persistence_path(filename, persist_options)
     TmpFile.with_file(values * "\n") do |value_file|
-      cmd = "cat '#{ path }' | grep -w -F -f '#{ value_file }' |cut -f 2 |sort|uniq -c|sed 's/^ *//;s/ /\\t/'"
+      cmd = "cat '#{ path }' | grep -w -F -f '#{ value_file }' |cut -f 2 |sort|uniq -c|sed 's/^ *//;s/ /\t/'"
       begin
         TSV.open(CMD.cmd(cmd), :key_field => 1, :type => :single, :cast => :to_i)
       rescue

data/lib/rbbt/util/chain_methods.rb

@@ -2,6 +2,7 @@ require 'rbbt/util/log'
 require 'set'
 
 module ChainMethods
+
   def self.chain_methods_extended(base)
     if not base.respond_to? :chain_prefix
       metaclass = class << base
@@ -14,10 +15,6 @@ module ChainMethods
       end
 
       metaclass.module_eval do
-        def setup_chain(object)
-          object.extend self
-        end
-
         def setup_chains(base)
           raise "No prefix specified for #{self.to_s}" if self.chain_prefix.nil? or (String === self.chain_prefix and self.chain_prefix.empty?)
           methods = self.chained_methods
@@ -26,17 +23,6 @@ module ChainMethods
 
           prefix = self.chain_prefix
 
-          #do_chain = true
-          #methods.collect{|new_method|
-          #  original = new_method.sub(prefix.to_s + '_', '')
-          #  clean = prefix.to_s + '_clean_' + original
-          #  if base.respond_to? clean
-          #    do_chain = false
-          #    break
-          #  end
-          #}
-
-
           if not base.respond_to?(:processed_chains) or base.processed_chains.nil? or not base.processed_chains.include? prefix
             class << base
               attr_accessor :processed_chains 
@@ -61,6 +47,7 @@ module ChainMethods
                   alias_method clean_method, original 
                 rescue
                 end
+
                 alias_method original, new_method
               end
             end
@@ -73,17 +60,19 @@ module ChainMethods
           alias prev_chain_methods_extended extended if methods.include? "extended"
 
           def extended(base)
-            prev_chain_methods_extended(base) if methods.include? "prev_chain_methods_extended"
+            if self.respond_to? :prev_chain_methods_extended 
+              prev_chain_methods_extended(base)
+            end
             setup_chains(base)
           end
         end
       end
-    end
-
-    base.chain_prefix = base.to_s.downcase.to_sym
-  end
-  
-  def self.extended(base)
-    chain_methods_extended(base)
   end
+
+  base.chain_prefix = base.to_s.downcase.to_sym
+end
+
+def self.extended(base)
+  chain_methods_extended(base)
+end
 end

data/lib/rbbt/util/misc.rb

@@ -7,6 +7,65 @@ require 'net/smtp'
 module Misc
   class FieldNotFoundError < StandardError;end
 
+  def self.ensembl_server(organism)
+    date = organism.split("/")[1]
+    if date.nil?
+      "www.ensembl.org"
+    else
+      "#{ date }.archive.ensembl.org"
+    end
+  end
+
+  def self.filename?(string)
+    String === string and string.length > 0 and string.length < 250 and File.exists?(string)
+  end
+
+  def self.max(list)
+    max = nil
+    list.each do |v|
+      next if v.nil?
+      max = v if max.nil? or v > max
+    end
+    max
+  end
+
+  def self.google_venn(list1, list2, list3, name1 = nil, name2 = nil, name3 = nil, total = nil)
+    name1 ||= "list 1"
+    name2 ||= "list 2"
+    name3 ||= "list 3"
+
+    sizes = [list1, list2, list3, list1 & list2, list1 & list3, list2 & list3, list1 & list2 & list3].collect{|l| l.length}
+
+    total = total.length if Array === total
+
+    label = "#{name1}: #{sizes[0]} (#{name2}: #{sizes[3]}, #{name3}: #{sizes[4]})"
+    label << "|#{name2}: #{sizes[1]} (#{name1}: #{sizes[3]}, #{name3}: #{sizes[5]})"
+      label << "|#{name3}: #{sizes[2]} (#{name1}: #{sizes[4]}, #{name2}: #{sizes[5]})"
+      if total
+        label << "| INTERSECTION: #{sizes[6]} TOTAL: #{total}"
+      else
+        label << "| INTERSECTION: #{sizes[6]}"
+      end
+
+    max = total || sizes.max
+    sizes = sizes.collect{|v| (v.to_f/max * 100).to_i.to_f / 100}
+    url = "https://chart.googleapis.com/chart?cht=v&chs=500x300&chd=t:#{sizes * ","}&chco=FF6342,ADDE63,63C6DE,FFFFFF&chdl=#{label}"
+  end
+
+  def self.sum(list)
+    list.compact.inject(0.0){|acc,e| acc += e}
+  end
+
+  def self.mean(list)
+    sum(list) / list.compact.length
+  end
+
+  def self.sd(list)
+    return nil if list.length < 3
+    mean = mean(list)
+    Math.sqrt(list.compact.inject(0.0){|acc,e| d = e - mean; acc += d * d}) / (list.compact.length - 1)
+  end
+
   def self.consolidate(list)
     list.inject(nil){|acc,e|
       if acc.nil?
@@ -34,7 +93,7 @@ module Misc
     IndiferentHash.setup(options)
     options = Misc.add_defaults options, :from_alias => nil, :to_alias => nil, :server => 'localhost', :port => 25, :user => nil, :pass => nil, :auth => :login
     IndiferentHash.setup(options)
-    
+
     server, port, user, pass, from_alias, to_alias, auth = Misc.process_options options, :server, :port, :user, :pass, :from_alias, :to_alias, :auth
 
     msg = <<-END_OF_MESSAGE
@@ -43,11 +102,11 @@ To: #{to_alias} <#{to}>
 Subject: #{subject}
 
 #{message}
-    END_OF_MESSAGE
+END_OF_MESSAGE
 
-    Net::SMTP.start(server, port, server, user, pass, auth) do |smtp|
-      smtp.send_message msg, from, to
-    end
+Net::SMTP.start(server, port, server, user, pass, auth) do |smtp|
+  smtp.send_message msg, from, to
+end
   end
 
   def self.counts(array)
@@ -55,9 +114,34 @@ Subject: #{subject}
     array.each do |e|
       counts[e] += 1
     end
+
+    class << counts; self;end.class_eval do
+      def to_s
+        sort{|a,b| a[1] == b[1] ? a[0] <=> b[0] : a[1] <=> b[1]}.collect{|k,c| "%3d\t%s" % [c, k]} * "\n"
+      end
+    end
+
     counts
   end
 
+  def self.proportions(array)
+    total = array.length
+
+    proportions = Hash.new 0
+
+    array.each do |e|
+      proportions[e] += 1.0 / total
+    end
+
+    class << proportions; self;end.class_eval do
+      def to_s
+        sort{|a,b| a[1] == b[1] ? a[0] <=> b[0] : a[1] <=> b[1]}.collect{|k,c| "%3d\t%s" % [c, k]} * "\n"
+      end
+    end
+
+    proportions
+  end
+
   IUPAC2BASE = {
     "A" => ["A"],
     "C" => ["C"],
@@ -85,6 +169,29 @@ Subject: #{subject}
     "U" => "A",
   }
 
+  THREE_TO_ONE_AA_CODE = {
+    "ala" =>   "A",
+    "arg" =>   "R",
+    "asn" =>   "N",
+    "asp" =>   "D",
+    "cys" =>   "C",
+    "glu" =>   "E",
+    "gln" =>   "Q",
+    "gly" =>   "G",
+    "his" =>   "H",
+    "ile" =>   "I",
+    "leu" =>   "L",
+    "lys" =>   "K",
+    "met" =>   "M",
+    "phe" =>   "F",
+    "pro" =>   "P",
+    "ser" =>   "S",
+    "thr" =>   "T",
+    "trp" =>   "W",
+    "tyr" =>   "Y",
+    "val" =>   "V"
+  }
+
   def self.IUPAC_to_base(iupac)
     IUPAC2BASE[iupac]
   end
@@ -259,7 +366,7 @@ Subject: #{subject}
 
   def self.lock(file, *args)
     FileUtils.mkdir_p File.dirname(File.expand_path(file)) unless File.exists?  File.dirname(File.expand_path(file))
-    lockfile = Lockfile.new(file + '.lock')
+    lockfile = Lockfile.new(file + '.lock', :max_age => 1200, :suspend => 240)
     lockfile.lock do
       yield file, *args
     end
@@ -344,24 +451,34 @@ Subject: #{subject}
   end
 
   def self.hash2md5(hash)
-    o = {}
+    str = ""
     hash.keys.sort_by{|k| k.to_s}.each do |k|
       next if k == :monitor or k == "monitor" or k == :in_situ_persistence or k == "in_situ_persistence"
       v = hash[k]
       case
-      when v.inspect =~ /:0x0/
-        o[k] = v.inspect.sub(/:0x[a-f0-9]+@/,'')
-        #when Resource::Path === v
-        #  o[k] = "" << String.new(v.to_s)
+      when Hash === v
+        str << k.to_s << "=>" << hash2md5(v)
+      when Symbol === v
+        str << k.to_s << "=>" << v.to_s
+      when String === v
+        str << k.to_s << "=>" << v
       else
-        o[k] = v
+        v_ins = v.inspect
+
+        case
+        when v_ins =~ /:0x0/
+          str << k.to_s << "=>" << v_ins.sub(/:0x[a-f0-9]+@/,'')
+        else
+          str << k.to_s << "=>" << v.to_s
+        end
+
       end
     end
 
-    if o.empty?
+    if str.empty?
       ""
     else
-      Digest::MD5.hexdigest(o.sort_by{|k| k.to_s}.inspect)
+      Digest::MD5.hexdigest(str)
     end
   end
 
@@ -455,7 +572,7 @@ Subject: #{subject}
     raise FieldNotFoundError, "Field information missing" if fields.nil? && ! quiet
     fields.each_with_index{|f,i| return i if f == field}
     field_re = Regexp.new /#{field}/i
-    fields.each_with_index{|f,i| return i if f =~ field_re}
+      fields.each_with_index{|f,i| return i if f =~ field_re}
     raise FieldNotFoundError, "Field #{ field.inspect } was not found" unless quiet
   end
 
@@ -477,134 +594,6 @@ Subject: #{subject}
 
 end
 
-module NamedArray
-  extend ChainMethods
-
-  self.chain_prefix = :named_array
-  attr_accessor :fields
-  attr_accessor :key
-
-  def self.setup(array, fields, key = nil)
-    array.extend NamedArray
-    array.fields = fields
-    array.key = key
-    array
-  end
-
-  def merge(array)
-    double = Array === array.first 
-    new = self.dup
-    (0..length - 1).each do |i|
-      if double
-        new[i] = new[i] + array[i]
-      else
-        new[i] << array[i]
-      end
-    end
-    new
-  end
-
-  def positions(fields)
-    if Array ==  fields
-      fields.collect{|field|
-        Misc.field_position(@fields, field)
-      }
-    else
-      Misc.field_position(@fields, fields)
-    end
-  end
-
-  def named_array_get_brackets(key)
-    if defined? Entity
-      entity = (defined?(Entity) and Entity.respond_to?(:formats)) ? Entity.formats[key] : nil
-      if entity
-        elem = if entity.annotations.first == :format
-                 entity.setup(named_array_clean_get_brackets(Misc.field_position(fields, key)), key)
-               else
-                 entity.setup(named_array_clean_get_brackets(Misc.field_position(fields, key)))
-               end
-        elem.context = self
-        elem
-      else
-        named_array_clean_get_brackets(Misc.field_position(fields, key))
-      end
-    else
-      named_array_clean_get_brackets(Misc.field_position(fields, key))
-    end
-  end
-
-  def named_array_each(&block)
-    if defined?(Entity) and not @fields.nil? and not @fields.empty?
-      @fields.zip(self).each do |field,elem|
-        entity = (defined?(Entity) and Entity.respond_to?(:formats)) ? Entity.formats[field] : nil
-
-        if entity
-          elem = elem.dup if elem.frozen?
-          if entity.annotations.first == :format
-            entity.setup(elem, field) 
-          else
-            entity.setup(elem)
-          end
-          elem.context = self
-          elem
-        end
-
-        yield(elem)
-        elem
-      end
-    else
-      named_array_clean_each &block
-    end
-  end
-
-  def named_array_collect
-    res = []
-
-    named_array_each do |elem|
-      if block_given?
-        res << yield(elem)
-      else
-        res << elem
-      end
-    end
-
-    res
-  end
-
-  def named_array_set_brackets(key,value)
-    named_array_clean_set_brackets(Misc.field_position(fields, key), value)
-  end
-
-  def named_array_values_at(*keys)
-    keys = keys.collect{|k| Misc.field_position(fields, k) }
-    named_array_clean_values_at(*keys)
-  end
-
-  def zip_fields
-    return [] if self.empty?
-    zipped = Misc.zip_fields(self)
-    zipped = zipped.collect{|v| NamedArray.setup(v, fields)}
-    zipped 
-  end
-
-  def detach(file)
-    file_fields = file.fields.collect{|field| field.fullname}
-    detached_fields = []
-    self.fields.each_with_index{|field,i| detached_fields << i if file_fields.include? field.fullname}
-    fields = self.fields.values_at *detached_fields
-    values = self.values_at *detached_fields
-    values = NamedArray.name(values, fields)
-    values.zip_fields
-  end
-
-  def report
-    fields.zip(self).collect do |field,value|
-      "#{ field }: #{ Array === value ? value * "|" : value }"
-    end * "\n"
-  end
-
-end
-
 class RBBTError < StandardError
   attr_accessor :info
 
@@ -664,7 +653,7 @@ module IndiferentHash
 
   def self.setup(hash)
     return hash if IndiferentHash === hash
-    hash.extend IndiferentHash
+    hash.extend IndiferentHash unless IndiferentHash === hash
     hash
   end
 end