map 2.7.1 → 2.8.0

data/TODO

@@ -1,4 +1,7 @@
 todo:
+  - #slice operator
+  - depth first each-ish delete operator
+
   - struct tests
   - map.push(object)
 

data/lib/map.rb

@@ -1,5 +1,5 @@
 class Map < Hash
-  Version = '2.7.1' unless defined?(Version)
+  Version = '2.8.0' unless defined?(Version)
   Load = Kernel.method(:load) unless defined?(Load)
 
   class << Map
@@ -145,8 +145,17 @@ class Map < Hash
 
       args
     end
-
     alias_method '[]', 'new'
+
+    def intersection(a, b)
+      a, b, i = Map.for(a), Map.for(b), Map.new
+      a.depth_first_each{|key, val| i.set(key, val) if b.has?(key)}
+      i
+    end
+
+    def match(haystack, needle)
+      intersection(haystack, needle) == needle
+    end
   end
 
   unless defined?(Dynamic)
@@ -443,22 +452,54 @@ class Map < Hash
     end
   end
 
-# misc
+# equality / sorting / matching support 
 #
-  def ==(hash)
-    return false unless(Map === hash)
-    return false if keys != hash.keys
-    super hash
+  def ==(other)
+    case other
+      when Map
+        return false if keys != other.keys
+        super(other)
+
+      when Hash
+        self == Map.from_hash(other, self)
+
+      else
+        false
+    end
   end
 
   def <=>(other)
-    keys <=> klass.coerce(other).keys
+    cmp = keys <=> klass.coerce(other).keys
+    return cmp unless cmp.zero?
+    values <=> klass.coerce(other).values
   end
 
   def =~(hash)
     to_hash == klass.coerce(hash).to_hash
   end
 
+# reordering support
+#
+  def reorder(order = {})
+    order = Map.for(order)
+    map = Map.new
+    keys = order.depth_first_keys | depth_first_keys
+    keys.each{|key| map.set(key, get(key))}
+    map
+  end
+
+  def reorder!(order = {})
+    replace(reorder(order))
+  end
+
+# support for building ordered hasshes from a map's own image
+#
+  def Map.from_hash(hash, order = nil)
+    map = Map.for(hash)
+    map.reorder!(order) if order
+    map
+  end
+
   def invert
     inverted = klass.allocate
     inverted.default = self.default
@@ -697,6 +738,8 @@ class Map < Hash
     Map.alphanumeric_key_for(key)
   end
 
+## TODO - technically this returns only leaves so the name isn't *quite* right.  re-factor for 3.0
+#
   def Map.depth_first_each(enumerable, path = [], accum = [], &block)
     Map.pairs_for(enumerable) do |key, val|
       path.push(key)
@@ -710,10 +753,22 @@ class Map < Hash
     if block
       accum.each{|keys, val| block.call(keys, val)}
     else
-      [path, accum]
+      accum
     end
   end
 
+  def Map.depth_first_keys(enumerable, path = [], accum = [], &block)
+    accum = Map.depth_first_each(enumerable, path = [], accum = [], &block)
+    accum.map!{|kv| kv.first}
+    accum
+  end
+
+  def Map.depth_first_values(enumerable, path = [], accum = [], &block)
+    accum = Map.depth_first_each(enumerable, path = [], accum = [], &block)
+    accum.map!{|kv| kv.last}
+    accum
+  end
+
   def Map.pairs_for(enumerable, *args, &block)
     if block.nil?
       pairs, block = [], lambda{|*pair| pairs.push(pair)}
@@ -736,9 +791,57 @@ class Map < Hash
     pairs ? pairs : result
   end
 
+  def Map.breadth_first_each(enumerable, accum = [], &block)
+    levels = []
+
+    keys = Map.depth_first_keys(enumerable)
+
+    keys.each do |key|
+      key.size.times do |i|
+        k = key.slice(0, i + 1)
+        level = k.size - 1
+        levels[level] ||= Array.new
+        last = levels[level].last
+        levels[level].push(k) unless last == k
+      end
+    end
+
+    levels.each do |level|
+      level.each do |key|
+        val = enumerable.get(key)
+        block ? block.call(key, val) : accum.push([key, val])
+      end
+    end
+
+    block ? enumerable : accum
+  end
+
+  def Map.keys_for(enumerable)
+    keys = enumerable.respond_to?(:keys) ? enumerable.keys : Array.new(enumerable.size){|i| i}
+  end
+
   def depth_first_each(*args, &block)
     Map.depth_first_each(enumerable=self, *args, &block)
   end
+
+  def depth_first_keys(*args, &block)
+    Map.depth_first_keys(enumerable=self, *args, &block)
+  end
+
+  def depth_first_values(*args, &block)
+    Map.depth_first_values(enumerable=self, *args, &block)
+  end
+
+  def breadth_first_each(*args, &block)
+    Map.breadth_first_each(enumerable=self, *args, &block)
+  end
+
+  def contains(other)
+    other = other.is_a?(Hash) ? Map.coerce(other) : other
+    breadth_first_each{|key, value| return true if value == other}
+    return false
+  end
+  alias_method 'contains?', 'contains'
 end
 
 module Kernel

data/map.gemspec

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

data/test/map_test.rb

@@ -371,6 +371,65 @@ Testing Map do
     assert{ each_pair = ['a', 'b', 'c', nil] }
   end
 
+  testing 'that maps support breath_first_each' do
+    map = Map[
+      'hash'         , {'x' => 'y'},
+      'nested hash'  , {'nested' => {'a' => 'b'}},
+      'array'        , [0, 1, 2],
+      'nested array' , [[3], [4], [5]],
+      'string'       , '42'
+    ]
+
+    accum = []
+    Map.breadth_first_each(map){|k, v| accum.push([k, v])}
+    expected =
+      [[["hash"], {"x"=>"y"}],
+       [["nested hash"], {"nested"=>{"a"=>"b"}}],
+       [["array"], [0, 1, 2]],
+       [["nested array"], [[3], [4], [5]]],
+       [["string"], "42"],
+       [["hash", "x"], "y"],
+       [["nested hash", "nested"], {"a"=>"b"}],
+       [["array", 0], 0],
+       [["array", 1], 1],
+       [["array", 2], 2],
+       [["nested array", 0], [3]],
+       [["nested array", 1], [4]],
+       [["nested array", 2], [5]],
+       [["nested hash", "nested", "a"], "b"],
+       [["nested array", 0, 0], 3],
+       [["nested array", 1, 0], 4],
+       [["nested array", 2, 0], 5]]
+  end
+
+  testing 'that maps have a needle-in-a-haystack like #contains? method' do
+    haystack = Map[
+      'hash'         , {'x' => 'y'},
+      'nested hash'  , {'nested' => {'a' => 'b'}},
+      'array'        , [0, 1, 2],
+      'nested array' , [[3], [4], [5]],
+      'string'       , '42'
+    ]
+
+    needles = [
+      {'x' => 'y'},
+      {'nested' => {'a' => 'b'}},
+      {'a' => 'b'},
+      [0,1,2],
+      [[3], [4], [5]],
+      [3],
+      [4],
+      [5],
+      '42',
+      0,1,2,
+      3,4,5
+    ]
+
+    needles.each do |needle|
+      assert{ haystack.contains?(needle) }
+    end
+  end
+
   testing 'that #update and #replace accept map-ish objects' do
     o = Object.new
     def o.to_map() {:k => :v} end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: map
 version: !ruby/object:Gem::Version 
-  hash: 17
+  hash: 47
   prerelease: 
   segments: 
   - 2
-  - 7
-  - 1
-  version: 2.7.1
+  - 8
+  - 0
+  version: 2.8.0
 platform: ruby
 authors: 
 - Ara T. Howard
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-02 00:00:00 -07:00
+date: 2011-04-08 00:00:00 -06:00
 default_executable: 
 dependencies: []