map 5.5.0 → 5.6.1

data/a.rb

@@ -1,9 +1,20 @@
+#!/usr/bin/env ruby
+
 # -*- encoding : utf-8 -*-
-require './lib/map.rb'
 
-args = [0, 1, {:k=>:v, :a=>false}]
+def assert(&block)
+  block.call
+end
+
+m = Map.new
+m.set(:a, :b, :c, 42)
+p m.get(:a, :b, 0)
+
+
+
+m = Map.new
+m.set(:a, 0, 42)  
+p m.get(:a, :b, 0)
+
 
-opts = Map.options_for!(args)
 
-p args
-p opts

data/lib/map.rb

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 class Map < Hash
-  Version = '5.5.0' unless defined?(Version)
+  Version = '5.6.1' unless defined?(Version)
   Load = Kernel.method(:load) unless defined?(Load)
 
   class << Map
@@ -721,8 +721,7 @@ class Map < Hash
       when Hash
         collection.has_key?(key)
       when Array
-        return false unless key
-        (0...collection.size).include?(Integer(key))
+        (0...collection.size).include?((Integer(key) rescue -1))
     end
   end
 
@@ -736,45 +735,70 @@ class Map < Hash
       spec[keys] = value
     end
 
-    spec.each do |keys, value|
-      keys = Array(keys).flatten
+    begin
+      spec.each do |keys, value|
+        keys = Array(keys).flatten
+        collection = self
+        key = keys.pop
 
-      collection = self
-
-      keys = key_for(keys)
+        while((k = keys.shift)) do
+          k = alphanumeric_key_for(k)
+          collection = collection[k]
+        end
 
-      if keys.size <= 1
-        key = keys.first
         collection[key] = value
-        next
       end
+    rescue
+      spec.each do |keys, value|
+        keys = Array(keys).flatten
+
+        collection = self
+
+        if keys.size <= 1
+          key = keys.first
+          collection[key] = value
+          next
+        end
+
+        leaf_for(keys, :autovivify => true) do |leaf, key|
+          leaf[key] = value
+        end
+      end
+    end
 
-      key = nil
+    return spec.values
+  end
+
+  def leaf_for(keys, options = {}, &block)
+    collection = self
+    key = nil
 
-      keys.each_cons(2) do |a, b|
-        a, b = alphanumeric_key_for(a), alphanumeric_key_for(b)
+    keys.each_cons(2) do |a, b|
+      a, b = alphanumeric_key_for(a), alphanumeric_key_for(b)
 
-        exists = collection_has_key?(collection, a)
+      exists = collection_has_key?(collection, a)
 
-        case b
-          when Numeric
-            #collection[a] ||= []
+      case b
+        when Numeric
+          if options[:autovivify]
             collection[a] = [] unless exists
-            raise(IndexError, "(#{ collection.inspect })[#{ a.inspect }]=#{ value.inspect }") unless collection[a].is_a?(Array)
+          end
+          raise(IndexError, "(#{ collection.inspect })[#{ a.inspect }][#{ b.inspect }]") unless collection[a].is_a?(Array)
 
-          when String, Symbol
-            #collection[a] ||= {}
-            collection[a] = {} unless exists
-            raise(IndexError, "(#{ collection.inspect })[#{ a.inspect }]=#{ value.inspect }") unless collection[a].is_a?(Hash)
-        end
-        collection = collection[a]
-        key = b
+        when String, Symbol
+          if options[:autovivify]
+            collection[a] = Map.new unless exists
+          end
+          raise(IndexError, "(#{ collection.inspect })[#{ a.inspect }][#{ b.inspect }]") unless collection[a].is_a?(Map)
       end
 
-      collection[key] = value
+      collection = collection[a]
+      key = b
     end
 
-    return spec.values
+    leaf = collection
+
+    block ? block.call(leaf, key) : [leaf, key]
   end
 
   def rm(*args)
@@ -841,49 +865,12 @@ class Map < Hash
     Map.alphanumeric_key_for(key)
   end
 
-## key path support
-#
-  def self.dot_key_for(*keys)
-    dot = keys.compact.flatten.join('.')
-    dot.split(%r/\s*[,.]\s*/).map{|part| part =~ %r/^\d+$/ ? Integer(part) : part}
-  end
-
-  def self.dot_keys
-    @@dot_keys = {} unless defined?(@@dot_keys)
-    @@dot_keys
-  end
-
-  def self.dot_keys?
-    ancestors.each do |ancestor|
-      return dot_keys[ancestor] if dot_keys.has_key?(ancestor)
-    end
-    false
-  end
-
-  def dot_keys?
-    @dot_keys = false unless defined?(@dot_keys)
-    @dot_keys
-  end
-
-  def self.dot_keys!(boolean = true)
-    dot_keys[self] = !!boolean
-  end
-
-  def dot_keys!(boolean = true)
-    @dot_keys = !!boolean
-  end
-
   def self.key_for(*keys)
-    return keys.flatten unless dot_keys?
-    self.dot_key_for(*keys)
+    return keys.flatten
   end
 
   def key_for(*keys)
-    if dot_keys?
-      self.class.dot_key_for(*keys)
-    else
-      self.class.key_for(*keys)
-    end
+    self.class.key_for(*keys)
   end
 
 ## TODO - technically this returns only leaves so the name isn't *quite* right.  re-factor for 3.0

data/map.gemspec

@@ -3,7 +3,7 @@
 
 Gem::Specification::new do |spec|
   spec.name = "map"
-  spec.version = "5.5.0"
+  spec.version = "5.6.1"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "map"
   spec.description = "description: map kicks the ass"

data/test/map_test.rb

@@ -349,26 +349,10 @@ Testing Map do
     assert{ m[:A].is_a?(Array) }
     assert{ m[:A].size == 3}
     assert{ m[:A][2] == 'forty-two' }
-    assert{ m[:x][:y].is_a?(Hash) }
+    assert{ m[:x][:y].is_a?(Map) }
     assert{ m[:x][:y][:z] == 42.0 }
   end
 
-  testing 'that maps can support compound key/val setting via key.dot notation' do
-    m = Class.new(Map){ dot_keys! }.new
-    assert{ m.set('a.b.c', 42) }
-    assert{ m[:a][:b][:c] == 42 }
-    assert{ m.get('a.b.c') == 42 }
-    assert{ m.set('x.y.z' => 42.0, 'A.2' => 'forty-two') }
-    assert{ m[:A].is_a?(Array) }
-    assert{ m[:A].size == 3}
-    assert{ m[:A][2] == 'forty-two' }
-    assert{ m[:x][:y].is_a?(Hash) }
-    assert{ m[:x][:y][:z] == 42.0 }
-    assert{ m.has?('a.b.c') }
-    assert{ m.has?('x.y.z') }
-    assert{ m.has?('A.2') }
-  end
-
   testing 'that Map#get supports providing a default value in a block' do
     m = Map.new
     m.set(:a, :b, :c, 42)
@@ -402,6 +386,11 @@ Testing Map do
     assert{ m.apply(defaults) }
     assert{ m[:array] == [0,1,2] }
     assert{ m[:hash] =~ {:a => false, :b => true, :c => 42} }
+
+    m = Map.new
+    assert{ m.apply :key => [{:key => :val}] }
+    assert{ m[:key].is_a?(Array) }
+    assert{ m[:key][0].is_a?(Map) }
   end
 
   testing 'that maps support depth_first_each' do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: map
 version: !ruby/object:Gem::Version
-  version: 5.5.0
+  version: 5.6.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-29 00:00:00.000000000 Z
+date: 2012-05-18 00:00:00.000000000 Z
 dependencies: []
 description: ! 'description: map kicks the ass'
 email: ara.t.howard@gmail.com