accessor.rb in rbbt-util-4.1.0

- old
+ new

@@ -2,11 +2,11 @@
 
 module TSV
   extend ChainMethods
   self.chain_prefix = :tsv
 
-  attr_accessor :unnamed
+  attr_accessor :unnamed, :serializer_module
 
   def with_unnamed
     saved_unnamed = @unnamed 
     @unnamed = true
     res = yield
@@ -45,78 +45,129 @@
         def write?
           @writable
         end
       end
     end
+
+    if not data.respond_to? :serialized_get
+      class << data
+        alias serialized_get tsv_clean_get_brackets
+        alias serialized_set tsv_clean_set_brackets
+      end
+    end
   end
 
   KEY_PREFIX = "__tsv_hash_"
 
   ENTRIES = []
   ENTRY_KEYS = []
 
-  def serialized_get(key)
-    raise "Uninitialized serializer" if serializer == :type
-    serialized_value = tsv_clean_get_brackets(key) 
-    SERIALIZER_ALIAS[serializer.to_sym].load(serialized_value) unless serialized_value.nil?
+  #{{{ Chained Methods
+  def tsv_empty?
+    length == 0
   end
 
-  def serialized_set(key, value)
-    raise "Uninitialized serializer" if serializer == :type
-    if value.nil?
-      tsv_clean_set_brackets(key, nil)
-    else
-      tsv_clean_set_brackets(key, SERIALIZER_ALIAS[serializer.to_sym].dump(value))
-    end
-  end
-
-  #{{{ Chained Methods
   def tsv_get_brackets(key)
-    value = if serializer.nil?
-            tsv_clean_get_brackets(key)
-          else
-            serialized_get(key)
-          end
+    value = serialized_get(key)
+    return value if @unnamed or fields.nil?
 
-    NamedArray.setup value, fields if Array === value and not @unnamed
+    case type
+    when :double, :list
+      NamedArray.setup value, fields, key 
+    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
+    end
     value
   end
 
   def tsv_set_brackets(key,value)
-    if serializer.nil?
-      tsv_clean_set_brackets(key, value)
-    else
-      serialized_set(key, value)
-    end
+    serialized_set(key, value)
   end
 
   def tsv_keys
-    tsv_clean_keys - ENTRY_KEYS
+    keys = tsv_clean_keys - ENTRY_KEYS
+    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)
+    else
+      keys
+    end
   end
 
   def tsv_values
     values = values_at(*keys)
-    values.each{|value| NamedArray.setup value, fields} if Array === values.first and not @unnamed
+    return values if @unnamed or fields.nil?
+
+    case type
+    when :double, :list
+      values.each{|value| NamedArray.setup value, fields }
+    when :flat, :single
+      values.each{|value| 
+        Entity.formats[fields.first].setup(value, :format => fields.first)
+      } if defined?(Entity) and Entity.respond_to?(:formats) and Entity.formats.include? fields.first
+    end
+      
     values
   end
 
   def tsv_each
+    fields = self.fields
+
+    serializer = self.serializer
+    serializer_module = SERIALIZER_ALIAS[serializer] unless serializer.nil?
     tsv_clean_each do |key, value|
       next if ENTRY_KEYS.include? key
 
-      value = SERIALIZER_ALIAS[serializer].load(value) unless serializer.nil?
-      NamedArray.setup value, fields if Array === value and not @unnamed
+      # TODO Update this to be more efficient
+      value = serializer_module.load(value) unless serializer.nil?
+
+      # Annotated with Entity and NamedArray
+      if not @unnamed
+        if not fields.nil? 
+          case type
+          when :double, :list
+            NamedArray.setup value, fields, key 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
+          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) 
+        end
+      end
+
       yield key, value if block_given?
       [key, value]
     end
   end
 
   def tsv_collect
+    serializer = self.serializer
+    serializer_module = SERIALIZER_ALIAS[serializer] unless serializer.nil?
     tsv_clean_collect do |key, value|
       next if ENTRY_KEYS.include? key
-      value = SERIALIZER_ALIAS[serializer].load(value) unless serializer.nil? or not String === value 
-      NamedArray.setup value, fields if Array === value and not @unnamed
+
+      # TODO Update this to be more efficient
+      value = serializer_module.load(value) unless serializer.nil?
+
+      # Annotated with Entity and NamedArray
+      if not @unnamed
+        if not fields.nil? 
+          case type
+          when :double, :list
+            NamedArray.setup value, fields, key 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
+          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) 
+        end
+      end
+
+
       if block_given?
         yield key, value
       else
         [key, value]
       end
@@ -227,13 +278,46 @@
     @#{entry} = YAML.load(self.tsv_clean_get_brackets('#{key}') || nil.to_yaml)
   end
   @#{entry}
 end
 
-def #{ entry }=(value)
-  @#{entry} = value
-  self.tsv_clean_set_brackets '#{key}', value.to_yaml
+
+if '#{entry}' == 'serializer'
+
+  def #{ entry }=(value)
+    @#{entry} = value
+    self.tsv_clean_set_brackets '#{key}', value.to_yaml
+
+    return if value.nil?
+
+    self.serializer_module = SERIALIZER_ALIAS[value.to_sym]
+    
+    if serializer_module.nil?
+      class << self
+        alias serialized_get tsv_clean_get_brackets
+        alias serialized_set tsv_clean_set_brackets
+      end
+
+    else
+      class << self
+        
+        define_method :serialized_get do |key|
+          self.serializer_module.load(tsv_clean_get_brackets(key))
+        end
+
+        define_method :serialized_set do |key, value|
+          tsv_clean_set_brackets key, self.serializer_module.dump(value)
+        end
+      end
+    end
+
+  end
+else
+  def #{ entry }=(value)
+    @#{entry} = value
+    self.tsv_clean_set_brackets '#{key}', value.to_yaml
+  end
 end
 "
     end
   end
 
@@ -321,36 +405,41 @@
       keys = self.keys.sort
     end
 
     str = ""
 
-    str << "#: " << Misc.hash2string(ENTRIES.collect{|key| [key.to_sym, self.send(key)]}) << "\n" unless no_options
+    str << "#: " << Misc.hash2string((ENTRIES - ["key_field", "fields"]).collect{|key| [key.to_sym, self.send(key)]}) << "\n" unless no_options
     if fields
       str << "#" << key_field << "\t" << fields * "\t" << "\n"
     end
 
-    saved_unnamed = @unnamed
-    @unnamed = false
-    if keys.nil?
-      each do |key, values|
-        key = key.to_s if Symbol === key
-        str << key.dup 
-        str << values_to_s(values)
+    with_unnamed do
+      if keys.nil?
+        each do |key, values|
+          key = key.to_s if Symbol === key
+          str << key.to_s
+          str << values_to_s(values)
+        end
+      else
+        keys.zip(values_at(*keys)).each do |key, values|
+          key = key.to_s if Symbol === key
+          str << key.to_s << values_to_s(values)
+        end
       end
-    else
-      keys.zip(values_at(*keys)).each do |key, values|
-        key = key.to_s if Symbol === key
-        str << key.dup << values_to_s(values)
-      end
-    end
 
-    @unnamed = saved_unnamed
+    end
     str
   end
 
   def value_peek
     peek = {}
     keys[0..10].zip(values[0..10]).each do |k,v| peek[k] = v end
     peek
+  end
+
+  def to_hash
+    new = self.dup
+    ENTRY_KEYS.each{|entry| new.delete entry}
+    new
   end
 end
 