map 1.3.0 → 1.4.0

data/README

@@ -1,26 +1,55 @@
+NAME
+  map.rb
 
-m = Map.new
+SYNOPSIS
+  the ruby container you've always wanted: a string/symbol indifferent ordered
+  hash that works in all rubies
 
-m[:a] = :b
-m[:b] = :b
-m[:c] = :c
+INSTALL
+  gem install map
 
-p m.keys #=> [:a, :b, :c]  ### always ordered!
+URI
+  http://github.com/ahoward/map
 
+DESCRIPTION
 
-p m[:a]  #=> :a
-p m["a"] #=> :a
+# maps are ordered.  constructing them in an ordered fashion builds them that
+# way
+#
+  m = Map[:k, :v, :key, :val]
+  m = Map(:k, :v, :key, :val)
 
+  m = Map[[:k, :v], [:key, :val]]
+  m = Map[{:k => :v, :key => :val}]
 
-m = Map[:k, :v, :key, :val]
-m = Map[[:k, :v], [:key, :val]]
-m = Map[{:k => :v, :key => :val}]
 
-m = Map(:k, :v, :key, :val)
-m = Map([:k, :v], [:key, :val])
-m = Map(:k => :v, :key => :val)
+  m = Map.new
+  m[:a] = 0
+  m[:b] = 1
+  m[:c] = 2
 
+  p m.keys #=> ['a','b','c']  ### always ordered!
+  p m.keys #=> [0,1,2]        ### always ordered!
 
-m.update(:k2, :v2)
-m.update(:k2 => :v2)
+# maps don't care between symbol and string keys
+#
+  p m[:a]  #=> 0
+  p m["a"] #=> 0
 
+# many functions operate in a way one would expect from an ordered container
+#
+  m.update(:k2 => :v2)
+  m.update(:k2, :v2)
+
+# maps keep mapiness for even deep operations
+#
+  m.update :nested => {:hashes => {:are => :converted}}
+
+# maps can give back clever little struct objects
+#
+  m = Map(:foo => {:bar => 42})
+  s = m.struct
+  p s.foo.bar #=> 42
+
+USAGE
+  test/map_test.rb

data/TODO

@@ -1,4 +1,5 @@
 todo:
+  - struct tests
   - map.push(object)
 
 done:

data/a.rb

@@ -0,0 +1,9 @@
+
+class M < ::Map
+  def initialize(arg)
+    @arg = arg
+  end
+end
+
+m = M.new(42)
+m.update :k => {:a => :b}

data/lib/map.rb

@@ -1,5 +1,5 @@
 class Map < Hash
-  Version = '1.3.0' unless defined?(Version)
+  Version = '1.4.0' unless defined?(Version)
   Load = Kernel.method(:load) unless defined?(Load)
 
   class << Map
@@ -7,9 +7,33 @@ class Map < Hash
       Map::Version
     end
 
+    def libdir(*args, &block)
+      @libdir ||= File.expand_path(__FILE__).sub(/\.rb$/,'')
+      libdir = args.empty? ? @libdir : File.join(@libdir, *args.map{|arg| arg.to_s})
+    ensure
+      if block
+        begin
+          $LOAD_PATH.unshift(libdir) unless $LOAD_PATH.first==libdir
+          module_eval(&block)
+        ensure
+          $LOAD_PATH.shift() if $LOAD_PATH.first==libdir
+        end
+      end
+    end
+
+    def load(*args, &block)
+      libdir{ Load.call(*args, &block) }
+    end
+
+    def allocate
+      super.instance_eval do
+        @keys = []
+        self
+      end
+    end
+
     def new(*args, &block)
       allocate.instance_eval do
-        @keys = []
         initialize(*args, &block)
         self
       end
@@ -17,14 +41,17 @@ class Map < Hash
 
     def for(*args, &block)
       first = args.first
-
       if(args.size == 1 and block.nil?)
         return first.to_map if first.respond_to?(:to_map)
       end
-
       new(*args, &block)
     end
 
+    def coerce(other)
+      return other.to_map if other.respond_to?(:to_map)
+      allocate.update(other.to_hash)
+    end
+
   # iterate over arguments in pairs smartly.
   #
     def each_pair(*args)
@@ -114,7 +141,7 @@ class Map < Hash
   end
 
   def map_for(hash)
-    map = klass.new(hash)
+    map = klass.coerce(hash)
     map.default = hash.default
     map
   end
@@ -127,7 +154,7 @@ class Map < Hash
     return value.to_map if value.respond_to?(:to_map)
     case value
       when Hash
-        klass.for(value)
+        klass.coerce(value)
       when Array
         value.map{|v| convert_value(v)}
       else
@@ -331,15 +358,15 @@ class Map < Hash
   end
 
   def <=>(other)
-    keys <=> klass.for(other).keys
+    keys <=> klass.coerce(other).keys
   end
 
   def =~(hash)
-    to_hash == klass.for(hash).to_hash
+    to_hash == klass.coerce(hash).to_hash
   end
 
   def invert
-    inverted = klass.new
+    inverted = klass.allocate
     inverted.default = self.default
     keys.each{|key| inverted[self[key]] = key }
     inverted
@@ -423,3 +450,5 @@ private
     Map.new(*args, &block)
   end
 end
+
+Map.load('struct.rb')

data/lib/map/struct.rb

@@ -0,0 +1,48 @@
+class Map
+  class Struct
+    instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+
+    attr :map
+
+    def initialize(map)
+      @map = map
+    end
+
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      case method
+        when /=$/
+          key = method.chomp('=')
+          value = args.shift
+          @map[key] = value
+        else
+          key = method
+          raise(IndexError, key) unless @map.has_key?(key)
+          value = @map[key]
+      end
+      value.is_a?(Map) ? value.struct : value
+    end
+
+    Keys = lambda{|*keys| keys.flatten!; keys.compact!; keys.map!{|key| key.to_s}}
+
+    delegates = %w(
+      inspect
+    )
+
+    delegates.each do |delegate|
+      module_eval <<-__, __FILE__, __LINE__
+        def #{ delegate }(*args, &block)
+          @map.#{ delegate }(*args, &block)
+        end
+      __
+    end
+  end
+
+  def struct
+    @struct ||= Struct.new(map=self)
+  end
+
+  def Map.struct(*args, &block)
+    new(*args, &block).struct
+  end
+end

data/test/map_test.rb

@@ -175,6 +175,25 @@ Testing Map do
     assert{ a != b}
   end
 
+  testing 'simple struct usage' do
+    a = assert{ Map.new(:k => :v) }
+    s = assert{ a.struct }
+    assert{ s.k == :v }
+  end
+
+  testing 'nested struct usage' do
+    a = assert{ Map.new(:k => {:l => :v}) }
+    s = assert{ a.struct }
+    assert{ s.k.l == :v }
+  end
+
+  testing 'that subclassing and clobbering initialize does not kill nested coercion' do
+    c = Class.new(Map){ def initialize(arg) end }
+    o = assert{ c.new(42) }
+    assert{ Map === o }
+    assert{ o.update(:k => {: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: 27
+  hash: 7
   prerelease: false
   segments: 
   - 1
-  - 3
+  - 4
   - 0
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors: 
 - Ara T. Howard
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-11 00:00:00 -06:00
+date: 2010-10-21 00:00:00 -06:00
 default_executable: 
 dependencies: []
 
@@ -28,6 +28,8 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- a.rb
+- lib/map/struct.rb
 - lib/map.rb
 - Rakefile
 - README