main 0.0.2 → 2.0.0

data/lib/main/arrayfields.rb

@@ -1,35 +1,30 @@
 #
 # The ArrayFields module implements methods which allow an Array to be indexed
-# by String or Symbol. It is not required to manually use this module to extend
-# Array's - they are auto-extended when Array#fields= is called
+# by String or Symbol. It is not required to manually use this module to
+# extend Arrays - they are auto-extended on a per-object basis when
+# Array#fields= is called
 #
   module ArrayFields 
-#{{{
-    VERSION = '3.6.0'
+    self::VERSION = '4.5.0' unless defined? self::VERSION
+    def self.version() VERSION end
   #
   # multiton cache of fields - wraps fields and fieldpos map to save memory
   #
     class FieldSet
-#{{{
       class << self
-#{{{
         def new fields
-#{{{
-          @sets ||= {}
-          obj = @sets[fields]
-          unless obj
-            obj = super  
-            @sets[fields] = obj
-          end
-          obj
-#}}}
+          @sets[fields] ||= super
+        end
+        def init_sets
+          @sets = {}
         end
-#}}}
       end
+
+      init_sets
+
       attr :fields
       attr :fieldpos
       def initialize fields
-#{{{
         raise ArgumentError, "<#{ fields.inspect }> not inject-able" unless
           fields.respond_to? :inject
 
@@ -43,25 +38,29 @@
           end
 
         @fields = fields
-#}}}
       end
       def pos f
-#{{{
         return @fieldpos[f] if @fieldpos.has_key? f 
         f = f.to_s
         return @fieldpos[f] if @fieldpos.has_key? f 
         f = f.intern
         return @fieldpos[f] if @fieldpos.has_key? f 
         nil
-#}}}
       end
-#}}}
     end
   #
   # methods redefined to work with fields as well as numeric indexes
   #
-    def [](idx, *args) 
-#{{{
+    def [] idx, *args
+      if @fieldset and (String === idx or Symbol === idx)
+        pos = @fieldset.pos idx
+        return nil unless pos
+        super(pos, *args)
+      else
+        super
+      end
+    end
+    def slice idx, *args
       if @fieldset and (String === idx or Symbol === idx)
         pos = @fieldset.pos idx
         return nil unless pos
@@ -69,11 +68,9 @@
       else
         super
       end
-#}}}
     end
-    alias slice []
+
     def []=(idx, *args) 
-#{{{
       if @fieldset and (String === idx or Symbol === idx) 
         pos = @fieldset.pos idx
         unless pos
@@ -84,10 +81,8 @@
       else
         super
       end
-#}}}
     end
     def at idx
-#{{{
       if @fieldset and (String === idx or Symbol === idx)
         pos = @fieldset.pos idx
         return nil unless pos
@@ -95,10 +90,8 @@
       else
         super
       end
-#}}}
     end
     def delete_at idx
-#{{{
       if @fieldset and (String === idx or Symbol === idx)
         pos = @fieldset.pos idx
         return nil unless pos
@@ -106,10 +99,8 @@
       else
         super
       end
-#}}}
     end
     def fill(obj, *args)
-#{{{
       idx = args.first
       if idx and @fieldset and (String === idx or Symbol === idx)
         idx = args.shift
@@ -118,67 +109,69 @@
       else
         super
       end
-#}}}
     end
+
     def values_at(*idxs)
-#{{{
       idxs.flatten!
       if @fieldset
         idxs.map!{|i| (String === i or Symbol === i) ? @fieldset.pos(i) : i}
       end
       super(*idxs)
-#}}}
     end
-    alias indices values_at
-    alias indexes values_at 
+    def indices(*idxs)
+      idxs.flatten!
+      if @fieldset
+        idxs.map!{|i| (String === i or Symbol === i) ? @fieldset.pos(i) : i}
+      end
+      super(*idxs)
+    end
+    def indexes(*idxs)
+      idxs.flatten!
+      if @fieldset
+        idxs.map!{|i| (String === i or Symbol === i) ? @fieldset.pos(i) : i}
+      end
+      super(*idxs)
+    end
+
     def slice!(*args)
-#{{{
       ret = self[*args]
       self[*args] = nil
       ret
-#}}}
     end
     def each_with_field
-#{{{
       each_with_index do |elem, i|
         yield elem, @fieldset.fields[i]
       end
-#}}}
     end
   #
   # methods which give a hash-like interface 
   #
     def each_pair
-#{{{
       each_with_index do |elem, i|
         yield @fieldset.fields[i], elem
       end
-#}}}
     end
     def each_key
-#{{{
       @fieldset.each{|field| yield field}
-#}}}
     end
-    def each_value(*args, &block)
-#{{{
-      each(*args, &block)
-#}}}
+    def each_value *args, &block
+      each *args, &block
     end
     def fetch key
-#{{{
       self[key] or raise IndexError, 'key not found'
-#}}}
     end
+
     def has_key? key
-#{{{
       @fieldset.fields.include? key
-#}}}
     end
-    alias member? has_key?
-    alias key? has_key?
+    def member? key
+      @fieldset.fields.include? key
+    end
+    def key? key
+      @fieldset.fields.include? key
+    end
+
     def has_value? value
-#{{{
       if respond_to? 'include?'
         self.include? value
       else
@@ -186,21 +179,24 @@
         each{|val| a << val}
         a.include? value
       end
-#}}}
     end
-    alias value? has_value?
+    def value? value
+      if respond_to? 'include?'
+        self.include? value
+      else
+        a = []
+        each{|val| a << val}
+        a.include? value
+      end
+    end
+
     def keys
-#{{{
       fields
-#}}}
     end
     def store key, value
-#{{{
       self[key] = value
-#}}}
     end
     def values
-#{{{
       if respond_to? 'to_ary'
         self.to_ary
       else
@@ -208,10 +204,9 @@
         each{|val| a << val}
         a
       end
-#}}}
     end
+
     def to_hash
-#{{{
       if respond_to? 'to_ary'
         h = {}
         @fieldset.fields.zip(to_ary){|f,e| h[f] = e}
@@ -223,40 +218,81 @@
         @fieldset.fields.zip(a){|f,e| h[f] = e}
         h
       end
-#}}}
     end
-    alias to_h to_hash
+    def to_h
+      if respond_to? 'to_ary'
+        h = {}
+        @fieldset.fields.zip(to_ary){|f,e| h[f] = e}
+        h
+      else
+        a = []
+        each{|val| a << val}
+        h = {}
+        @fieldset.fields.zip(a){|f,e| h[f] = e}
+        h
+      end
+    end
+
     def update other
-#--{{{
       other.each{|k,v| self[k] = v}
       to_hash
-#--}}}
     end
     def replace other
-#--{{{
       Hash === other ? update(other) : super
-#--}}}
     end
     def invert
-#--{{{
       to_hash.invert
-#--}}}
     end
-#}}}
+
+    def to_pairs
+      fields.zip values
+    end
+    alias_method 'pairs', 'to_pairs'
+
+    def copy 
+      cp = clone
+      cp.fields = fields.clone
+      cp 
+    end
+
+    alias_method 'dup', 'copy'
+    alias_method 'clone', 'copy'
+
+    def deepcopy 
+      cp = Marshal.load(Marshal.dump(self))
+      cp.fields = Marshal.load(Marshal.dump(self.fields))
+      cp 
+    end
   end
+  Arrayfields = ArrayFields
+
+  module Arrayfields
+    def self.new *pairs
+      pairs = pairs.map{|pair| Enumerable === pair ? pair.to_a : pair}.flatten
+      raise ArgumentError, "pairs must be evenly sized" unless(pairs.size % 2 == 0)
+      (( array = [] )).fields = []
+      0.step(pairs.size - 2, 2) do |a|
+        b = a + 1
+        array[ pairs[a] ] = pairs[b]
+      end
+      array
+    end
+    def self.[] *pairs
+      new *pairs
+    end
+  end
+  def Arrayfields(*a, &b) Arrayfields.new(*a, &b) end
 #
 # Fieldable encapsulates methods in common for classes which may have their
-# fields set
+# fields set and subsequently be auto-extended by ArrayFields
 #
   module Fieldable
-#{{{
   #
   # sets fields an dynamically extends this Array instance with methods for
   # keyword access
   #
     def fields= fields
-#{{{
-      extend ArrayFields unless defined? @fieldset 
+      extend ArrayFields unless ArrayFields === self
 
       @fieldset = 
         if ArrayFields::FieldSet === fields
@@ -264,7 +300,6 @@
         else
           ArrayFields::FieldSet.new fields
         end
-#}}}
     end
   #
   # access to fieldset
@@ -274,19 +309,58 @@
   # access to field list
   #
     def fields
-#{{{
       @fieldset and @fieldset.fields
-#}}}
     end
-#}}}
   end
 #
-# The Array class is extened with a methods to allow keyword access 
+# Array instances are extened with two methods only: Fieldable#fields= and
+# Fieldable#fields.  only when Fieldable#fields= is called will the full set
+# of ArrayFields methods auto-extend the Array instance.  the Array class also
+# has added a class generator when the fields are known apriori.
 #
   class Array
-#{{{
     include Fieldable
-#}}}
+
+    class << self
+      def struct *fields
+        fields = fields.flatten
+        Class.new(self) do
+          include ArrayFields
+          const_set :FIELDS, ArrayFields::FieldSet.new(fields)
+          fields.each do |field|
+            field = field.to_s
+            if field =~ %r/^[a-zA-Z_][a-zA-Z0-9_]*$/
+              begin
+                module_eval <<-code
+                  def #{ field } *a
+                    a.size == 0 ? self['#{ field }'] : (self.#{ field } = a.shift) 
+                  end
+                  def #{ field }= value
+                    self['#{ field }'] = value
+                  end
+                code
+              rescue SyntaxError
+                :by_ignoring_it
+              end
+            end
+          end
+          def initialize *a, &b
+            super
+          ensure
+            @fieldset = self.class.const_get :FIELDS
+          end
+          def self.[] *elements
+            array = new
+            array.replace elements
+            array
+          end
+        end
+      end
+      def fields *fields, &block
+        (( array = new(&block) )).fields = fields.map{|x| Enumerable === x ? x.to_a : x}.flatten
+        array
+      end
+    end
   end
 #
 # proxy class that allows an array to be wrapped in a way that still allows #
@@ -300,48 +374,61 @@
 #
 #
   class FieldedArray
-#{{{
     include Fieldable
     class << self
-
       def [](*pairs)
-#{{{
         pairs.flatten!
-        raise ArgumentError, "argument must be key/val paris" unless 
-          (pairs.size % 2 == 0 and pairs.size >= 2)
+        raise ArgumentError, "argument must be key/val pairs" unless 
+          (pairs.size % 2 == 0)
         fields, elements = [], []
-        #pairs.each do |f,e| 
         while((f = pairs.shift) and (e = pairs.shift)) 
-          raise ArgumentError, "field must be String or Symbol" unless
-            (String === f or Symbol === f)
           fields << f and elements << e
         end
         new fields, elements
-#}}}
       end
-
     end
-    def initialize fields, array
-#{{{
+    def initialize fields = [], array = []
       @a = array
       self.fields = fields
-#}}}
     end
     def method_missing(meth, *args, &block)
-#{{{
       @a.send(meth, *args, &block)
-#}}}
     end
     delegates =
-#{{{
       %w(
         to_s
         to_str
         inspect
       )
-#}}}
     delegates.each do |meth| 
       class_eval "def #{ meth }(*a,&b); @a.#{ meth }(*a,&b);end"
     end
-#}}}
   end
+  Fieldedarray = FieldedArray
+
+  class PseudoHash < ::Array
+    class << self
+      def [](*pairs)
+        pairs.flatten!
+        raise ArgumentError, "argument must be key/val pairs" unless 
+          (pairs.size % 2 == 0 and pairs.size >= 2)
+        keys, values = [], []
+        while((k = pairs.shift) and (v = pairs.shift)) 
+          keys << k and values << v
+        end
+        new keys, values
+      end
+    end
+    def initialize keys = [], values = []
+      self.fields = keys
+      self.replace values
+    end
+    def to_yaml opts = {}
+      YAML::quick_emit object_id, opts do |out|
+        out.map taguri, to_yaml_style do |map|
+          each_pair{|f,v| map.add f,v}
+        end
+      end
+   end 
+  end
+  Pseudohash = PseudoHash