map 1.2.0 → 1.2.3

data/lib/map.rb

@@ -1,5 +1,5 @@
 class Map < Hash
-  Version = '1.2.0' unless defined?(Version)
+  Version = '1.2.3' unless defined?(Version)
   Load = Kernel.method(:load) unless defined?(Load)
 
   class << Map
@@ -7,41 +7,14 @@ class Map < Hash
       Map::Version
     end
 
-  # class constructor 
-  #
     def new(*args, &block)
-      case args.size
-        when 0
-          super(&block)
-
-        when 1
-          case args.first
-            when Hash
-              new_from_hash(args.first)
-            when Array
-              new_from_array(args.first)
-            else
-              new_from_hash(args.first.to_hash)
-          end
-
-        else
-          new_from_array(args)
+      allocate.instance_eval do
+        @keys = []
+        initialize(*args, &block)
+        self
       end
     end
 
-    def new_from_hash(hash)
-      map = new
-      map.update(hash)
-      map.default = hash.default
-      map
-    end
-
-    def new_from_array(array)
-      map = new
-      each_pair(array){|key, val| map[key] = val}
-      map
-    end
-
     def for(*args, &block)
       first = args.first
 
@@ -99,11 +72,37 @@ class Map < Hash
 
 # instance constructor 
 #
-  attr_accessor :keys
+  def keys
+    @keys ||= []
+  end
 
   def initialize(*args, &block)
-    super
-    @keys = []
+    case args.size
+      when 0
+        super(&block)
+
+      when 1
+        case args.first
+          when Hash
+            initialize_from_hash(args.first)
+          when Array
+            initialize_from_array(args.first)
+          else
+            initialize_from_hash(args.first.to_hash)
+        end
+
+      else
+        initialize_from_array(args)
+    end
+  end
+
+  def initialize_from_hash(hash)
+    map.update(hash)
+    map.default = hash.default
+  end
+
+  def initialize_from_array(array)
+    Map.each_pair(array){|key, val| map[key] = val}
   end
 
 # support methods
@@ -112,8 +111,12 @@ class Map < Hash
     self
   end
 
+  def klass
+    self.class
+  end
+
   def map_for(hash)
-    map = Map.new(hash)
+    map = klass.new(hash)
     map.default = hash.default
     map
   end
@@ -126,7 +129,7 @@ class Map < Hash
     return value.to_map if value.respond_to?(:to_map)
     case value
       when Hash
-        Map.for(value)
+        klass.for(value)
       when Array
         value.map{|v| convert_value(v)}
       else
@@ -170,18 +173,16 @@ class Map < Hash
   alias_method '__get__', '[]' unless method_defined?('__get__')
   alias_method '__update__', 'update' unless method_defined?('__update__')
 
-  def set(key, val)
+  def []=(key, val)
     key, val = convert(key, val)
-    @keys.push(key) unless has_key?(key)
+    keys.push(key) unless has_key?(key)
     __set__(key, val)
   end
-  alias_method 'store', 'set'
-  alias_method '[]=', 'set'
+  alias_method 'store', '[]='
 
-  def get(key)
-    __get__(key)
+  def [](key)
+    __get__(convert_key(key))
   end
-  alias_method '[]', 'get'
 
   def fetch(key, *args, &block)
     super(convert_key(key), *args, &block)
@@ -195,9 +196,7 @@ class Map < Hash
   alias_method 'member?', 'key?'
 
   def update(*args)
-    Map.each_pair(*args) do |key, val|
-      set(key, val)
-    end
+    Map.each_pair(*args){|key, val| store(key, val)}
     self
   end
   alias_method 'merge!', 'update'
@@ -218,7 +217,7 @@ class Map < Hash
 
   def values
     array = []
-    @keys.each{|key| array.push(self[key])}
+    keys.each{|key| array.push(self[key])}
     array
   end
   alias_method 'vals', 'values'
@@ -228,32 +227,32 @@ class Map < Hash
   end
 
   def first
-    [@keys.first, self[@keys.first]]
+    [keys.first, self[keys.first]]
   end
 
   def last
-    [@keys.last, self[@keys.last]]
+    [keys.last, self[keys.last]]
   end
 
 # iterator methods
 #
   def each_with_index
-    @keys.each_with_index{|key, index| yield([key, self[key]], index)}
+    keys.each_with_index{|key, index| yield([key, self[key]], index)}
     self
   end
 
   def each_key
-    @keys.each{|key| yield(key)}
+    keys.each{|key| yield(key)}
     self
   end
 
   def each_value
-    @keys.each{|key| yield self[key]}
+    keys.each{|key| yield self[key]}
     self
   end
 
   def each
-    @keys.each{|key| yield(key, self[key])}
+    keys.each{|key| yield(key, self[key])}
     self
   end
   alias_method 'each_pair', 'each'
@@ -262,18 +261,18 @@ class Map < Hash
 #
   def delete(key)
     key = convert_key(key)
-    @keys.delete(key)
+    keys.delete(key)
     super(key)
   end
 
   def clear
-    @keys = []
+    keys.clear
     super
   end
 
   def delete_if
     to_delete = []
-    @keys.each{|key| to_delete.push(key) if yield(key)}
+    keys.each{|key| to_delete.push(key) if yield(key)}
     to_delete.each{|key| delete(key)}
     map
   end
@@ -287,7 +286,7 @@ class Map < Hash
 #
   def shift
     unless empty?
-      key = @keys.first
+      key = keys.first
       val = delete(key)
       [key, val]
     end
@@ -298,7 +297,7 @@ class Map < Hash
       if key?(key)
         delete(key)
       else
-        @keys.unshift(key)
+        keys.unshift(key)
       end
       __set__(key, val)
     end
@@ -310,7 +309,7 @@ class Map < Hash
       if key?(key)
         delete(key)
       else
-        @keys.push(key)
+        keys.push(key)
       end
       __set__(key, val)
     end
@@ -319,7 +318,7 @@ class Map < Hash
 
   def pop
     unless empty?
-      key = @keys.last
+      key = keys.last
       val = delete(key)
       [key, val]
     end
@@ -328,18 +327,23 @@ class Map < Hash
 # misc
 #
   def ==(hash)
-    return false if @keys != hash.keys
+    return false unless(Map === hash)
+    return false if keys != hash.keys
     super hash
   end
 
+  def <=>(other)
+    keys <=> klass.for(other).keys
+  end
+
   def =~(hash)
-    to_hash == Map.for(hash).to_hash
+    to_hash == klass.for(hash).to_hash
   end
 
   def invert
-    inverted = Map.new
+    inverted = klass.new
     inverted.default = self.default
-    @keys.each{|key| inverted[self[key]] = key }
+    keys.each{|key| inverted[self[key]] = key }
     inverted
   end
 

data/test/map_test.rb

@@ -160,6 +160,21 @@ Testing Map do
     assert{ map =~ hash }
   end
 
+  testing 'that inheritence works without cycles' do
+    c = Class.new(Map){}
+    o = assert{ c.new }
+    assert{ Map === o }
+  end
+
+  testing 'equality' do
+    a = assert{ Map.new }
+    b = assert{ Map.new }
+    assert{ a == b}
+    assert{ a != 42 }
+    b[:k] = :v
+    assert{ a != b}
+  end
+
 protected
   def new_int_map(n = 1024)
     map = assert{ Map.new }

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: map
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 25
   prerelease: false
   segments: 
   - 1
   - 2
-  - 0
-  version: 1.2.0
+  - 3
+  version: 1.2.3
 platform: ruby
 authors: 
 - Ara T. Howard
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-05 00:00:00 -06:00
+date: 2010-10-06 00:00:00 -06:00
 default_executable: 
 dependencies: []