map 5.6.1 → 5.8.0

data/a.rb

@@ -1,20 +1,56 @@
 #!/usr/bin/env ruby
-
 # -*- encoding : utf-8 -*-
 
+require './lib/map.rb'
+
+
 def assert(&block)
   block.call
 end
 
+
+###
 m = Map.new
-m.set(:a, :b, :c, 42)
-p m.get(:a, :b, 0)
+p m.add(
+  :comments => [
+    { :body => 'a' },
+    { :body => 'b' },
+  ],
+
+  [:comments, 0] => {'title' => 'teh title', 'description' => 'description'},
+  [:comments, 1] => {'description' => 'description'},
+)
+puts
+puts
+p :m => m
 
 
+__END__
+=begin
 
+{"comments"=>
+  [{"body"=>"a", "title"=>"teh title", "description"=>"description"},
+     {"body"=>"b", "description"=>"description"}]}
+
+=end
+
+
+###
 m = Map.new
-m.set(:a, 0, 42)  
-p m.get(:a, :b, 0)
+p m.add(
+  [:a, :b, :c] => 42,
+
+  [:a, :b] => {:d => 42.0}
+)
+puts
+puts
+p m
+
+=begin
 
+  {"a"=>{"b"=>{"c"=>42, "d"=>42.0}}}
 
+=end
 
+Map.new.add
+Map.new.add({})

data/lib/map.rb

@@ -1,6 +1,6 @@
 # -*- encoding : utf-8 -*-
 class Map < Hash
-  Version = '5.6.1' unless defined?(Version)
+  Version = '5.8.0' unless defined?(Version)
   Load = Kernel.method(:load) unless defined?(Load)
 
   class << Map
@@ -726,79 +726,162 @@ class Map < Hash
   end
 
   def set(*args)
-    if args.size == 1 and args.first.is_a?(Hash)
-      spec = args.shift
-    else
-      spec = {}
-      value = args.pop
-      keys = args
-      spec[keys] = value
+    case
+      when args.empty?
+        return []
+      when args.size == 1 && args.first.is_a?(Hash)
+        hash = args.shift
+      else
+        hash = {}
+        value = args.pop
+        key = Array(args).flatten
+        hash[key] = value
     end
 
-    begin
-      spec.each do |keys, value|
-        keys = Array(keys).flatten
-        collection = self
-        key = keys.pop
-
-        while((k = keys.shift)) do
-          k = alphanumeric_key_for(k)
-          collection = collection[k]
-        end
+    strategy = hash.map{|key, value| [Array(key), value]}
 
-        collection[key] = value
+    strategy.each do |key, value|
+      leaf_for(key, :autovivify => true) do |leaf, k|
+        leaf[k] = value
       end
-    rescue
-      spec.each do |keys, value|
-        keys = Array(keys).flatten
+    end
+
+    self
+  end
+
+  def add(*args)
+    case
+      when args.empty?
+        return []
+      when args.size == 1 && args.first.is_a?(Hash)
+        hash = args.shift
+      else
+        hash = {}
+        value = args.pop
+        key = Array(args).flatten
+        hash[key] = value
+    end
+
+    exploded = Map.explode(hash)
+
+    exploded[:branches].each do |key, type|
+      set(key, type.new) unless get(key).is_a?(type)
+    end
+
+    exploded[:leaves].each do |key, value|
+      set(key, value)
+    end
+
+    self
+  end
+
+  def Map.explode(hash)
+    accum = {:branches => [], :leaves => []}
+
+    hash.each do |key, value|
+      Map._explode(key, value, accum)
+    end
+
+    branches = accum[:branches]
+    leaves = accum[:leaves]
+
+    sort_by_key_size = proc{|a,b| a.first.size <=> b.first.size}
+
+    branches.sort!(&sort_by_key_size)
+    leaves.sort!(&sort_by_key_size)
+
+    accum
+  end
 
-        collection = self
+  def Map._explode(key, value, accum = {:branches => [], :leaves => []})
+    key = Array(key).flatten
 
-        if keys.size <= 1
-          key = keys.first
-          collection[key] = value
-          next
+    case value
+      when Array
+        accum[:branches].push([key, Array])
+
+        value.each_with_index do |v, k|
+          Map._explode(key + [k], v, accum)
         end
 
-        leaf_for(keys, :autovivify => true) do |leaf, key|
-          leaf[key] = value
+      when Hash
+        accum[:branches].push([key, Map])
+
+        value.each do |k, v|
+          Map._explode(key + [k], v, accum)
         end
-      end
+
+      else
+        accum[:leaves].push([key, value])
     end
 
-    return spec.values
+    accum
   end
 
-  def leaf_for(keys, options = {}, &block)
-    collection = self
-    key = nil
+  def Map.add(*args)
+    args.flatten!
+    args.compact!
+
+    Map.for(args.shift).tap do |map|
+      args.each{|arg| map.add(arg)}
+    end
+  end
+
+  def Map.combine(*args)
+    Map.add(*args)
+  end
+
+  def combine!(*args, &block)
+    add(*args, &block)
+  end
+
+  def combine(*args, &block)
+    dup.tap do |map|
+      map.combine!(*args, &block)
+    end
+  end
+
+  def leaf_for(key, options = {}, &block)
+    leaf = self
+    key = Array(key).flatten
+    k = alphanumeric_key_for(key.first)
 
-    keys.each_cons(2) do |a, b|
+    key.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?(leaf, a)
 
       case b
         when Numeric
           if options[:autovivify]
-            collection[a] = [] unless exists
+            leaf[a] = [] unless exists
+          end
+
+          case
+            when Array, Hash
+              nil
+            else
+              raise(IndexError, "(#{ leaf.inspect })[#{ a.inspect }][#{ b.inspect }]")
           end
-          raise(IndexError, "(#{ collection.inspect })[#{ a.inspect }][#{ b.inspect }]") unless collection[a].is_a?(Array)
 
         when String, Symbol
           if options[:autovivify]
-            collection[a] = Map.new unless exists
+            leaf[a] = Map.new unless exists
+          end
+
+          case
+            when Hash
+              nil
+            else
+              raise(IndexError, "(#{ leaf.inspect })[#{ a.inspect }][#{ b.inspect }]")
           end
-          raise(IndexError, "(#{ collection.inspect })[#{ a.inspect }][#{ b.inspect }]") unless collection[a].is_a?(Map)
       end
 
-      collection = collection[a]
-      key = b
+      leaf = leaf[a]
+      k = b
     end
 
-    leaf = collection
-
-    block ? block.call(leaf, key) : [leaf, key]
+    block ? block.call(leaf, k) : [leaf, k]
   end
 
   def rm(*args)

data/map.gemspec

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

data/test/map_test.rb

@@ -343,14 +343,26 @@ Testing Map do
   testing 'that maps support compound key/val setting' do
     m = Map.new
     assert{ m.set(:a, :b, :c, 42) }
-    assert{ m[:a][:b][:c] == 42 }
     assert{ m.get(:a, :b, :c) == 42 }
+
+    m = Map.new
+    assert{ m.set([:a, :b, :c], 42) }
+    assert{ m.get(:a, :b, :c) == 42 }
+
+    m = Map.new
+    assert{ m.set([:a, :b, :c] => 42) }
+    assert{ m.get(:a, :b, :c) == 42 }
+
+    m = Map.new
     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?(Map) }
     assert{ m[:x][:y][:z] == 42.0 }
+
+    assert{ Map.new.tap{|m| m.set} =~ {} }
+    assert{ Map.new.tap{|m| m.set({})} =~ {} }
   end
 
   testing 'that Map#get supports providing a default value in a block' do
@@ -393,6 +405,63 @@ Testing Map do
     assert{ m[:key][0].is_a?(Map) }
   end
 
+  testing 'that #add overlays the leaves of one hash onto another without nuking branches' do
+    m = Map.new
+
+    assert do
+      m.add(
+        :comments => [
+          { :body => 'a' },
+          { :body => 'b' },
+        ],
+
+        [:comments, 0] => {'title' => 'teh title', 'description' => 'description'},
+        [:comments, 1] => {'description' => 'description'},
+      )
+    end
+
+    assert do
+      m =~
+        {"comments"=>
+          [{"body"=>"a", "title"=>"teh title", "description"=>"description"},
+             {"body"=>"b", "description"=>"description"}]}
+    end
+
+    m = Map.new
+
+    assert do
+      m.add(
+        [:a, :b, :c] => 42,
+
+        [:a, :b] => {:d => 42.0}
+      )
+    end
+
+    assert do
+      m =~
+        {"a"=>{"b"=>{"c"=>42, "d"=>42.0}}}
+    end
+
+    assert{ Map.new.tap{|m| m.add} =~ {} }
+    assert{ Map.new.tap{|m| m.add({})} =~ {} }
+  end
+
+  testing 'that Map.combine is teh sweet' do
+    {
+      [{:a => {:b => 42}}, {:a => {:c => 42.0}}] =>
+        {"a"=>{"b"=>42, "c"=>42.0}},
+
+      [{:a => {:b => 42}}, {:a => {:c => 42.0, :d => [1]}}] =>
+        {"a"=>{"b"=>42, "d"=>[1], "c"=>42.0}},
+
+      [{:a => {:b => 42}}, {:a => {:c => 42.0, :d => {0=>1}}}] =>
+        {"a"=>{"b"=>42, "d"=>{0=>1}, "c"=>42.0}}
+
+    }.each do |args, expected|
+      assert{ Map.combine(*args) =~ expected }
+    end
+  end
+
   testing 'that maps support depth_first_each' do
     m = Map.new
     prefix = %w[ a b c ]

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: map
 version: !ruby/object:Gem::Version
-  version: 5.6.1
+  version: 5.8.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-05-18 00:00:00.000000000 Z
+date: 2012-05-22 00:00:00.000000000 Z
 dependencies: []
 description: ! 'description: map kicks the ass'
 email: ara.t.howard@gmail.com
@@ -49,7 +49,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: codeforpeople
-rubygems_version: 1.8.11
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: map