motion-map 0.0.1 → 0.0.3

data/lib/motion-map/version.rb

@@ -1,3 +1,3 @@
 module MotionMap
-  VERSION = '0.0.1'
+  VERSION = '0.0.3'
 end

data/spec/helpers/map_helper.rb

@@ -1,6 +1,6 @@
 module MapHelper
   def new_int_map(n = 1024)
-    Map.new.tap do |m|
+    MotionMap::Map.new.tap do |m|
       n.times{|i| m[i.to_s] = i}
     end
   end

data/spec/map/map_spec.rb

@@ -1,29 +1,29 @@
-describe Map do
+describe MotionMap::Map do
   extend MapHelper
   
   describe 'constructor' do
     it 'supports bare constructor' do
-      map = Map.new
+      map = MotionMap::Map.new
       map .count.should == 0
     end
-
+  
     it 'can take a hash' do
-      map = Map.new( {} )
+      map = MotionMap::Map.new( {} )
       map.count.should == 0
     end
     
     it 'can take an empty array' do
       array = []
-      map = Map.new( array )
+      map = MotionMap::Map.new( array )
       map.count.should == 0
-      map = Map.new( *array )
+      map = MotionMap::Map.new( *array )
       map.count.should == 0      
     end
     
     it 'deals with nil correctly' do
-      map = Map.new( nil )
+      map = MotionMap::Map.new( nil )
       map.count.should == 0
-      map = Map.new( false )
+      map = MotionMap::Map.new( false )
       map.count.should == 0
     end
     
@@ -36,9 +36,9 @@ describe Map do
       expectations = [1, 2, 2]
       i = 0
       arrays.each do |array|
-        map = Map.new(array)
+        map = MotionMap::Map.new(array)
         map.count.should == expectations[i]
-        map = Map.new(*array)
+        map = MotionMap::Map.new(*array)
         map.count.should == expectations[i]
         i += 1
       end      
@@ -52,9 +52,9 @@ describe Map do
         [:key, :val]
       ]
       list.each do |args|
-        map = Map[*args]
-        map.class.should == Map
-        Map.new(*args).should == map
+        map = MotionMap::Map[*args]
+        map.class.should == MotionMap::Map
+        MotionMap::Map.new(*args).should == map
       end      
     end
   end
@@ -82,7 +82,7 @@ describe Map do
   
   describe 'accessors' do
     it 'Maps string/symbol indifferent for simple look-ups' do
-      map = Map.new
+      map = MotionMap::Map.new
       map[:k]  = :v
       map['a'] = 'b'
       map[:k].should      == :v
@@ -92,8 +92,7 @@ describe Map do
     end
     
     it 'Maps string/symbol indifferent for recursive look-ups' do
-      map = Map(:a => {:b => {:c => 42}})
-      
+      map = MotionMap::Map[:a => {:b => {:c => 42}}]      
       map[:a].should            == {:b => {:c => 42}}
       map[:a][:b][:c].should    == 42
       map['a'][:b][:c].should   == 42
@@ -103,15 +102,15 @@ describe Map do
       map[:a]['b']['c'].should  == 42
       map[:a][:b]['c'].should   == 42
       map['a'][:b]['c'].should  == 42
-  
-      map = Map[:a => [{:b => 42}]]
+        
+      map = MotionMap::Map[:a => [{:b => 42}]]
       map['a'].class.should    == Array
-      map['a'][0].class.should == Map
+      map['a'][0].class.should == MotionMap::Map
       map['a'][0]['b'].should  == 42
-  
-      map = Map(:a => [ {:b => 42}, [{:c => 'forty-two'}] ])
+        
+      map = MotionMap::Map[:a => [ {:b => 42}, [{:c => 'forty-two'}] ]]
       map['a'].class.should      == Array
-      map['a'][0].class.should   == Map
+      map['a'][0].class.should   == MotionMap::Map
       map['a'][1].class.should   == Array
       map['a'][0]['b'].should    == 42
       map['a'][1][0]['c'].should == 'forty-two'
@@ -120,7 +119,7 @@ describe Map do
   
   describe 'shift' do
     it 'supports shift like a good ordered container' do
-      map = Map.new
+      map = MotionMap::Map.new
       10.times do |i|
         key, val = i.to_s, i
         map.unshift(key, val)
@@ -129,7 +128,7 @@ describe Map do
         map.values.first.to_s.should == val.to_s
       end
   
-      map = Map.new
+      map = MotionMap::Map.new
       args = []
       10.times do |i|
         key, val = i.to_s, i
@@ -153,14 +152,14 @@ describe Map do
     end    
     
     it 'supports inheritence without cycles' do
-      c = Class.new(Map){}
+      c = Class.new(MotionMap::Map){}
       o = c.new
-      Map.should === o
+      MotionMap::Map.should === o
     end
     
     it 'captures equality correctly' do
-      a = Map.new
-      b = Map.new
+      a = MotionMap::Map.new
+      b = MotionMap::Map.new
       a.should == b
       a.should != 42
       b[:k] = :v
@@ -170,19 +169,19 @@ describe Map do
   
   describe 'keys as methods' do
     it 'works with simple usage' do
-      a = Map.new( k: :v)
+      a = MotionMap::Map.new( k: :v)
       a.k.should == :v
     end
   
     it 'works with complexusage' do
-      a = Map.new( k: {a: {b: 10}} )
+      a = MotionMap::Map.new( k: {a: {b: 10}} )
       a.k.a.b.should == 10
     end    
   end  
   
   describe 'subclassing' do
     it 'insures subclassing and clobbering initialize does not kill nested coersion' do
-      c = Class.new(Map){ def initialize(arg) end }
+      c = Class.new(MotionMap::Map){ def initialize(arg) end }
       o = c.new(42)
       o.class.should == c
       o.update(:k => {:a => :b})
@@ -190,26 +189,26 @@ describe Map do
     end    
     
     it 'ensures that subclassing does not kill class level coersion' do
-      c = Class.new(Map){ }
-      o = c.for(Map.new)
+      c = Class.new(MotionMap::Map){ }
+      o = c.for(MotionMap::Map.new)
       o.class.should == c
   
       d = Class.new(c)
-      o = d.for(Map.new)
+      o = d.for(MotionMap::Map.new)
       o.class.should == d
     end    
   end
   
   describe '#to_list' do
     it 'insures Maps can be converted to lists with numeric indexes' do
-      m = Map[0, :a, 1, :b, 2, :c]
+      m = MotionMap::Map[0, :a, 1, :b, 2, :c]
       m.to_list.should == [:a, :b, :c]
     end
   end    
   
   describe 'method_missing' do
     it 'ensures method_missing hacks allow setting values, but not getting them until they are set' do
-      m = Map.new
+      m = MotionMap::Map.new
       (m.missing rescue $!).class.should == NoMethodError
       m.missing = :val
       m[:missing].should == :val
@@ -217,7 +216,7 @@ describe Map do
     end
   
     it 'ensures method_missing hacks have sane respond_to? semantics' do
-      m = Map.new
+      m = MotionMap::Map.new
       m.respond_to?(:missing).should == false
       m.respond_to?(:missing=).should == true
       m.missing = :val
@@ -226,7 +225,7 @@ describe Map do
     end
     
     it 'ensures method missing with a block delegatets to fetch' do
-      m = Map.new
+      m = MotionMap::Map.new
       m.missing{ :val }.should == :val
       m.has_key?(:key).should == false
     end
@@ -234,34 +233,34 @@ describe Map do
   
   describe 'compound keys' do
     it 'Maps support compound key/val setting' do
-      m = Map.new
+      m = MotionMap::Map.new
       m.set(:a, :b, :c, 42)
       m.get(:a, :b, :c).should == 42
   
-      m = Map.new
+      m = MotionMap::Map.new
       m.set([:a, :b, :c], 42)
       m.get(:a, :b, :c) == 42
   
-      m = Map.new
+      m = MotionMap::Map.new
       m.set([:a, :b, :c] => 42)
       m.get(:a, :b, :c) == 42
   
-      m = Map.new
+      m = MotionMap::Map.new
       m.set([:x, :y, :z] => 42.0, [:A, 2] => 'forty-two')
       m[:A].class.should     == Array
       m[:A].size.should      == 3
       m[:A][2].should        == 'forty-two'
-      m[:x][:y].class.should == Map
+      m[:x][:y].class.should == MotionMap::Map
       m[:x][:y][:z].should   == 42.0
   
-      Map.new.tap{|m| m.set}.should =~ {}
-      Map.new.tap{|m| m.set({})}    =~ {}
+      MotionMap::Map.new.tap{|m| m.set}.should =~ {}
+      MotionMap::Map.new.tap{|m| m.set({})}    =~ {}
     end 
   end
   
   describe '#get' do
     it 'supports providing a default value in a block' do
-      m = Map.new
+      m = MotionMap::Map.new
       m.set(:a, :b, :c, 42)
       m.set(:z, 1)
   
@@ -269,12 +268,12 @@ describe Map do
       m.get(:z){2}.should         == 1
       m.get(:a, :b, :d){1}.should == 1
       m.get(:a, :b, :c){1}.should == 42
-      m.get(:a, :b){1}.should     == Map({:c => 42})
+      m.get(:a, :b){1}.should     == MotionMap::Map[{:c => 42}]
       m.get(:a, :aa){1}.should    == 1
     end    
     
     it 'ensures setting a sub-container does not eff up the container values' do
-      m = Map.new
+      m = MotionMap::Map.new
       m.set(:array => [0,1,2])
       m.get(:array, 0).should == 0
       m.get(:array, 1).should == 1
@@ -289,21 +288,21 @@ describe Map do
   
   describe 'merging' do
     it 'ensures #apply selectively merges non-nil values' do
-      m = Map.new(:array => [0, 1], :hash => {:a => false, :b => nil, :c => 42})
-      defaults = Map.new(:array => [nil, nil, 2], :hash => {:b => true})
+      m = MotionMap::Map.new(:array => [0, 1], :hash => {:a => false, :b => nil, :c => 42})
+      defaults = MotionMap::Map.new(:array => [nil, nil, 2], :hash => {:b => true})
   
       m.apply(defaults)
       m[:array].should == [0,1,2]
       m[:hash].should  =~ {:a => false, :b => true, :c => 42}
   
-      m = Map.new
+      m = MotionMap::Map.new
       m.apply :key => [{:key => :val}]
       m[:key].class.should    == Array
-      m[:key][0].class.should == Map
+      m[:key][0].class.should == MotionMap::Map
     end  
     
     it 'ensures #add overlays the leaves of one hash onto another without nuking branches' do
-      m = Map.new
+      m = MotionMap::Map.new
   
       m.add(
         :comments => [
@@ -319,15 +318,15 @@ describe Map do
             [{"body"=>"a", "title"=>"teh title", "description"=>"description"},
                {"body"=>"b", "description"=>"description"}]}
   
-      m = Map.new
+      m = MotionMap::Map.new
       m.add(
         [:a, :b, :c] => 42,
         [:a, :b] => {:d => 42.0}
       )
       m.should =~ {"a"=>{"b"=>{"c"=>42, "d"=>42.0}}}
   
-      Map.new.tap{|m| m.add}.should     =~ {}
-      Map.new.tap{|m| m.add({})}.should =~ {}
+      MotionMap::Map.new.tap{|m| m.add}.should     =~ {}
+      MotionMap::Map.new.tap{|m| m.add({})}.should =~ {}
     end      
     
     it 'ensures that Map.combine is teh sweet' do
@@ -336,14 +335,14 @@ describe Map do
         [{: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|
-        Map.combine(*args).should =~ expected
+        MotionMap::Map.combine(*args).should =~ expected
       end
     end    
   end
   
   describe 'traversal' do
     it 'supports depth_first_each' do
-      m      = Map.new
+      m      = MotionMap::Map.new
       prefix = %w[ a b c ]
       keys   = []
       n      = 0.42
@@ -355,8 +354,8 @@ describe Map do
         m.set(key => val)
         n *= 10
       end
-      m.get(:a).class.should         == Map
-      m.get(:a, :b).class.should     == Map
+      m.get(:a).class.should         == MotionMap::Map
+      m.get(:a, :b).class.should     == MotionMap::Map
       m.get(:a, :b, :c).class.should == Array
   
       n = 0.42
@@ -370,12 +369,12 @@ describe Map do
     it 'ensures #each_pair works on arrays' do
       each  = []
       array = %w( a b c )
-      Map.each_pair(array){|k,v| each.push(k,v)}
+      MotionMap::Map.each_pair(array){|k,v| each.push(k,v)}
       each.should == ['a', 'b', 'c', nil]
     end
     
     it 'supports breath_first_each' do
-      m = Map[
+      m = MotionMap::Map[
         'hash'         , {'x' => 'y'},
         'nested hash'  , {'nested' => {'a' => 'b'}},
         'array'        , [0, 1, 2],
@@ -384,7 +383,7 @@ describe Map do
       ]
   
       accum = []
-      m.breadth_first_each(Map){|k, v| accum.push([k, v])}
+      m.breadth_first_each(MotionMap::Map){|k, v| accum.push([k, v])}
       expected =
         [
          [["hash"], {"x"=>"y"}],
@@ -413,7 +412,7 @@ describe Map do
   
   describe '#contains' do
     it 'handles needle-in-a-haystack like #contains? method' do
-      haystack = Map[
+      haystack = MotionMap::Map[
         'hash'         , {'x' => 'y'},
         'nested hash'  , {'nested' => {'a' => 'b'}},
         'array'        , [0, 1, 2],
@@ -442,21 +441,21 @@ describe Map do
   end
   
   it 'ensures #blank? method that is sane' do
-    m = Map.new(:a => 0, :b => ' ', :c => '', :d => {}, :e => [], :f => false)
+    m = MotionMap::Map.new(:a => 0, :b => ' ', :c => '', :d => {}, :e => [], :f => false)
     m.each do |key, val|
       m.blank?(key).should == true
     end
   
-    m = Map.new(:a => 1, :b => '_', :d => {:k=>:v}, :e => [42], :f => true)
+    m = MotionMap::Map.new(:a => 1, :b => '_', :d => {:k=>:v}, :e => [42], :f => true)
     m.each do |key, val|
       m.blank?(key).should == false
     end
-    Map.new.blank?.should == true
+    MotionMap::Map.new.blank?.should == true
   end  
   
   it 'ensures self referential Maps do not make #inspect puke' do
-    a = Map.new
-    b = Map.new
+    a = MotionMap::Map.new
+    b = MotionMap::Map.new
   
     b[:a] = a
     a[:b] = b
@@ -471,7 +470,7 @@ describe Map do
   end
     
   it 'has a clever little rm operator' do
-    m = Map.new
+    m = MotionMap::Map.new
     m.set :a, :b, 42
     m.set :x, :y, 42
     m.set :x, :z, 42
@@ -501,7 +500,7 @@ describe Map do
   end
   
   it 'Maps a clever little question method' do
-    m = Map.new
+    m = MotionMap::Map.new
     m.set(:a, :b, :c, 42)
     m.set([:x, :y, :z] => 42.0, [:A, 2] => 'forty-two')
   
@@ -517,5 +516,5 @@ describe Map do
     m.y?.should     == false
   
     m.A?.should     == true
-  end    
+   end    
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: motion-map
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Fernand Galiana
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-19 00:00:00.000000000 Z
+date: 2013-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   prerelease: false