hashmodel 0.4.0.beta1 → 0.4.0.beta2

data/spec/hash_model/hash_model_spec.rb

@@ -18,7 +18,7 @@ describe HashModel do
         @hm = HashModel.new
         @hm << @records[0]
         proc{@hm.clear}.should change(@hm, :raw_data)
-          .from([{:switch => ["-x", "--xtended"], :parameter => {:type => String, :require => true}, :description => "Xish stuff"}])
+          .from([{:switch => ["-x", "--xtended"], :parameter => {:type => String, :required => true}, :description => "Xish stuff"}])
           .to([])
       end
       

data/spec/hash_model/hash_model_unflattening_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+  
+describe HashModel do
+
+  context "when unflattening behavior" do
+    
+    it "should allow access to the unflatten without an instance of HashModel" do
+        deep_hash =  { 
+          :parameter__type=>String,
+          :switch__deep1__deep3 => "deepTwo",
+          :parameter__type__ruby=>true,
+          :parameter => "glorp",
+          :parameter__required=>true,
+          :switch__deep2 => "deepTwo",
+          :description=>"Xish stuff",
+          :switch => "--xtend",
+        }
+        HashModel.unflatten(deep_hash).should == {
+            :parameter => [
+              {:type=>String}, 
+              "glorp", 
+              {:required=>true}
+            ], 
+            :switch => [
+              {:deep1 => {:deep3=>"deepTwo"}},
+              {:deep2=>"deepTwo"}, 
+              "--xtend"
+            ], 
+            :description=>"Xish stuff"
+          }
+    end
+    
+  end
+end

data/spec/hash_model/hash_model_update_spec.rb

@@ -0,0 +1,147 @@
+require "spec_helper"
+
+describe HashModel do
+
+  context "when updating records" do
+
+    let(:hm){HashModel.new(:raw_data=> {:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a =>"b2a", :b2b=>"b2b"}}} )}
+
+    
+    context "and the search key exists in the target" do
+    
+      it "should update the value properly" do
+        update = {:b__b2__b2b=>"potato"}
+        lambda{hm.update!(update)}.should change{hm.deep_clone}
+          .from([{:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a=>"b2a", :b2b=>"b2b"}}, :_id=>0, :_group_id=>0}])
+          .to([{:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a=>"b2a", :b2b=>"potato"}}, :_id=>0, :_group_id=>0}])
+      end
+    
+      it "should update a mid-level hash" do
+        update = {:b__b2=>"potato"}
+        lambda{hm.update!(update)}.should change{hm.deep_clone}
+          .from([{:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a=>"b2a", :b2b=>"b2b"}}, :_id=>0, :_group_id=>0}])
+          .to([{:a=>"a", :b=>{:b1=>"b1", :b2=>"potato"}, :_id=>0, :_group_id=>0}])
+      end
+    
+      it "should update a multiple update hashes at once" do
+        update = {:b__b2=>"potato", :a=>"blorg", :b__b1=>"fish"}
+        lambda{hm.update!(update)}.should change{hm.deep_clone}
+          .from([{:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a=>"b2a", :b2b=>"b2b"}}, :_id=>0, :_group_id=>0}])
+          .to([{:a=>"blorg", :b=>{:b1=>"fish", :b2=>"potato"}, :_id=>0, :_group_id=>0}])
+      end
+    
+      it "should update with a hash as the value" do
+        update = {:b__b2=>{:d=>"d"}}
+        lambda{hm.update!(update)}.should change{hm.deep_clone}
+          .from([{:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a=>"b2a", :b2b=>"b2b"}}, :_id=>0, :_group_id=>0}])
+          .to([{:a=>"a", :b=>{:b1=>"b1", :b2=>{:d=>"d"}}, :_id=>0, :_group_id=>0}])
+      end
+    
+      it "should update with an array as the value" do
+        update = {:b__b2=>[1,2,3]}
+        lambda{hm.update!(update)}.should change{hm.deep_clone}
+          .from([{:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a=>"b2a", :b2b=>"b2b"}}, :_id=>0, :_group_id=>0}])
+          .to([{:a=>"a", :b=>{:b1=>"b1", :b2=>[1,2,3]}, :_id=>0, :_group_id=>0}])
+      end
+    
+    
+    end
+    
+    context "but the search key does NOT exist in the target" do
+    
+      it "should NOT by default add a field" do
+        update = {:b__b2__b2c=>"potato"}
+        lambda{hm.update!(update)}.should_not change{hm.deep_clone}
+      end
+    
+      it "should add a field if told to do so (by using update_and_add)" do
+        update = {:b__b2__b2c=>"potato"}
+        lambda{hm.update_and_add!(update)}.should change{hm.deep_clone}
+          .from([{:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a=>"b2a", :b2b=>"b2b"}}, :_id=>0, :_group_id=>0}])
+          .to([{:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a=>"b2a", :b2b=>"b2b", :b2c=>"potato"}}, :_id=>0, :_group_id=>0}])
+      end
+    
+      it "should only return records that are changed" do
+        hm << {:a=>"17", :b=>"1870"}
+        update = {:b__b2__b2b=>"potato"}
+        hm.update!(update).should == [
+          {:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a=>"b2a", :b2b=>"potato"}}, :_id=>0, :_group_id=>0} 
+        ]
+      end
+    
+    end
+ 
+    context "when updating a filtered HashModel" do
+      
+      before(:each) do
+        hm << {:a=>"17", :b=>"7291", :c=>"0"}
+        hm << {:a=>"17", :b=>"080", :c=>"1"}
+        hm << {:a=>"17", :b=>"24134", :c=>2}
+        hm.filter("17")
+      end
+      
+      it "should return the updated records" do
+        hm.update!(:b=>"23").should == [
+          {:a=>"17", :b=>"23", :c=>"0", :_id=>1, :_group_id=>1}, 
+          {:a=>"17", :b=>"23", :c=>"1", :_id=>2, :_group_id=>2}, 
+          {:a=>"17", :b=>"23", :c=>2, :_id=>3, :_group_id=>3}
+        ]
+      end
+      
+      it "should not update records not in the current filter" do
+        lambda{hm.update!(:b=>"23")}.should_not change{hm.raw_data.clone[0]}
+      end
+      
+      it "should return the updated records even if the primary key is the one changed" do
+        hm.update!(:a=>"BBBB").should == [
+          {:a=>"BBBB", :b=>"7291", :c=>"0", :_id=>1, :_group_id=>1}, 
+          {:a=>"BBBB", :b=>"080", :c=>"1", :_id=>2, :_group_id=>2}, 
+          {:a=>"BBBB", :b=>"24134", :c=>2, :_id=>3, :_group_id=>3}
+        ]
+      end
+      
+      context "after changing the filtered field to something that doesn't match the filter" do
+        it {hm.update!(:a=>"BBBB"); hm.length.should == 0}
+      end
+            
+    end
+   
+    context "when using non-destructive methods" do
+      
+      it {lambda{hm.update(:b__b2__b2b=>"potato")}.should_not change{hm.deep_clone}}
+      
+      it {lambda{hm.update_and_add(:b__b2__b2j=>"potato")}.should_not change{hm.deep_clone}}
+      
+    end
+    
+    context "when sending a filter with the update" do
+      
+      before(:each) do
+        hm << {:a=>"17", :b=>"7291", :c=>"0"}
+        hm << {:a=>"17", :b=>"080", :c=>"1"}
+        hm << {:a=>"17", :b=>"24134", :c=>2}
+      end
+      
+      it {hm.update("17", {:b=>3434}).should == [
+        {:a=>"17", :b=>3434, :c=>"0", :_id=>1, :_group_id=>1}, 
+        {:a=>"17", :b=>3434, :c=>"1", :_id=>2, :_group_id=>2}, 
+        {:a=>"17", :b=>3434, :c=>2, :_id=>3, :_group_id=>3}]
+      }
+      
+      it "should reset the original filter" do
+        hm.update("17", {:b=>3434})
+        hm.should == [
+          {:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a=>"b2a", :b2b=>"b2b"}}, :_id=>0, :_group_id=>0}, 
+          {:a=>"17", :b=>"7291", :c=>"0", :_id=>1, :_group_id=>1}, 
+          {:a=>"17", :b=>"080", :c=>"1", :_id=>2, :_group_id=>2}, 
+          {:a=>"17", :b=>"24134", :c=>2, :_id=>3, :_group_id=>3}
+        ]
+        
+      end
+      
+      
+    end
+    
+  end
+
+end

data/spec/hash_model/hash_model_where_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+
+describe HashModel do
+
+  describe "searching and selecting records" do
+ 
+    context "when searhing non-destructively" do
+
+      it "should return an empty set if the HashModel is empty" do
+        empty = HashModel.new
+        empty.where("fudge").should == []
+      end
+      
+      it "should have a length of 0 if the HashModel is empty" do
+        empty = HashModel.new
+        empty.length.should == 0
+      end
+      
+      it "should accept a parameter as input" do
+        proc{@hm.where("-x")}.should_not raise_error
+      end
+
+      it "should raise an error if a block and a parameter are given" do
+        proc{@hm.where("-x"){@switch == "-x"}}.should raise_error
+      end    
+    
+      it "should return a HashModel when searching" do
+        @hm.where("-x").class.should == HashModel
+      end
+  
+      it "should return a different hash model when calling where" do
+         @hm.where("-x").object_id.should_not == @hm.object_id
+      end
+      
+      it "should shouldn't destroy records" do
+        lambda{@hm.where("-x")}.should_not change{@hm}
+      end
+      
+      it "should delete data from raw records if that data doesn't fit the search criteria" do
+        records = {:switch=>[[1,2],[3,4]]}
+        hm = HashModel.new(:raw_data=>records)
+        hm.where([1,2]).raw_data[0][:switch].should_not include([3,4])
+      end
+      
+    end
+    
+    context "when searhing destructively" do
+  
+      it "should return the same hash model when calling where!" do
+         @hm.where!("-x").object_id.should == @hm.object_id
+      end
+      
+      it "should should destroy records" do
+        lambda{@hm.where!("-x")}.should change{@hm.raw_data.clone}
+      end
+      
+    end
+
+    context "non-string search values" do
+
+      it "should search using the flatten_index if a symbol is used with where" do
+        @records = [
+          {:switch => ["-x", "--xtended", :default], :parameter => {:type => String, :required => true}, :description => "Xish stuff"},
+          {:switch => ["-y", "--why"],  :description => "lucky what?"},
+          {:switch => "-z",  :parameter => {:type => String}, :description => "zee svitch zu moost calz"},
+        ]
+        @hm = HashModel.new(:raw_data=>@records)
+        @hm.where(:default).should == [{:switch=>:default, :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>0, :_group_id=>0}]
+      end
+
+      it "should search using an array" do
+        recs = [[1,2],[3,4]]
+        hm = HashModel.new(:raw_data=>{:switch=>recs})
+        hm.where([1,2]).should == [{:switch=>[1, 2], :_id=>0, :_group_id=>0}]
+      end
+
+    end
+  
+    context "filtering records" do
+  
+      it "should filter the recordset" do
+        @hm.filter("-x")
+        @hm.should == [@flat_records[0]]
+      end
+   
+      it "should tell you if it is filtering records" do
+        @hm.filter("-x")
+        @hm.filtered?.should == true
+      end
+      
+      it "should let you clear the filter" do
+        @hm.filter("-x")
+        proc {@hm.clear_filter}.should change(@hm, :filtered?).from(true).to(false)
+      end
+      
+      it "should show all the records when the filter is cleared" do
+        @hm.filter("-x")
+        @hm.clear_filter
+        @hm.should == @flat_records
+      end
+      
+      it "should clear the filter if nothing is sent" do
+        @hm.filter("-x")
+        proc {@hm.where!}.should change(@hm, :filtered?).from(true).to(false)
+      end
+      
+      context "when searching for records with nil values" do
+      
+        it "should search the flatten index" do
+          @hm.flatten_index = :parameter__type
+          @hm.filter(nil).should == [
+            {:parameter__type=>nil, :switch=>["-y", "--why"], :description=>"lucky what?", :_id=>1, :_group_id=>1}
+          ]
+        end
+
+        it "should search using a block" do
+          @hm.filter{:parameter__type == nil}.should == [@flat_records[2], @flat_records[3]]
+        end
+
+      end
+      
+    end # filtering
+    
+    context "not in place" do
+
+      it "should return a HashModel object" do
+        @hm = HashModel.new(:raw_data=>@records)
+        @hm.where("-x").class.should == HashModel
+      end
+  
+      it "should return a new HashModel" do
+         @hm.where("-x").object_id.should_not == @hm.object_id
+      end
+
+      it "should search the flatten index if given a parameter" do
+        @hm = HashModel.new(:raw_data=>@records)
+        @hm.where("-x").should == [@flat_records[0]]
+      end
+    
+      it "should search the flatten index if given a block" do
+        @hm.where{:parameter__type == String}.should == [
+          {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>0, :_group_id=>0},
+          {:switch=>"--xtended", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>1, :_group_id=>0}, 
+          {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>2, :_group_id=>1}
+        ]
+      end
+    
+    end # not in place
+
+    context "when using blocks" do
+      
+      it "should search using a single value boolean block" do
+        @hm.where {:switch == "-x"}.should == [@flat_records[0]]
+      end
+
+      it "should search using a complex boolean block" do
+        records = [
+          {:switch => ["-x", "--xtended"], :parameter => {:type => String, :required => true}, :description => "Xish stuff", :something => 4},
+          {:switch => ["-y", "--why"],  :description => "lucky what?"},
+          {:switch => "-z",  :parameter => {:type => String, :required => true}, :description => "zee svitch zu moost calz", :something => 4},
+        ]
+        @hm = HashModel.new(:raw_data=>records)
+        @hm.where {:something == 4 && :parameter__required == true}.should == [
+          {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>0, :_group_id=>0}, 
+          {:switch=>"--xtended", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>1, :_group_id=>0}, 
+          {:switch=>"-z", :parameter=>{:type=>String, :required=>true}, :description=>"zee svitch zu moost calz", :something=>4, :_id=>2, :_group_id=>1}
+        ]
+      end
+      
+      it "should search a complex boolean block regardless of order" do
+        records = [
+          {:switch => ["-x", "--xtended"], :parameter => {:type => String, :required => true}, :description => "Xish stuff", :something => 4},
+          {:switch => ["-y", "--why"],  :description => "lucky what?"},
+          {:switch => "-z",  :parameter => {:type => String, :required => true}, :description => "zee svitch zu moost calz", :something => 4},
+        ]
+        @hm = HashModel.new(:raw_data=>records)
+        @hm.where {:parameter__type == String && :parameter__required == true && :something == 4}.should == [
+          {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>0, :_group_id=>0}, 
+          {:switch=>"--xtended", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>1, :_group_id=>0}, 
+          {:switch=>"-z", :parameter=>{:type=>String, :required=>true}, :description=>"zee svitch zu moost calz", :something=>4, :_id=>2, :_group_id=>1}
+        ]
+      end
+
+      it "should search using a complex, multi-line boolean block" do
+        records = [
+          {:switch => ["-x", "--xtended"], :parameter => {:type => String, :required => true}, :description => "Xish stuff", :something => 4},
+          {:switch => ["-y", "--why"],  :description => "lucky what?", :something => 7},
+          {:switch => "-z",  :parameter => {:type => Integer, :required => true}, :description => "zee svitch zu moost calz", :something => 4},
+        ]
+        @hm = HashModel.new(:raw_data=>records)
+        @hm.where {(:parameter__type == String && :parameter__required == true && :something == 4) || :something == 7}.should == [
+          {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>0, :_group_id=>0}, 
+          {:switch=>"--xtended", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>1, :_group_id=>0}, 
+          {:switch=>"-y", :description=>"lucky what?", :something=>7, :_id=>2, :_group_id=>1}, 
+          {:switch=>"--why", :description=>"lucky what?", :something=>7, :_id=>3, :_group_id=>1}
+        ]
+      end
+    
+      it "should search with nested hashes in a block" do
+        records = [
+          {:switch => ["-x", "--xtended"], :parameter => {:type => String, :required => true}, :description => "Xish stuff", :something => 4},
+          {:switch => ["-y", "--why"],  :description => "lucky what?", :something => 7},
+          {:switch => "-z",  :parameter => {:type => Integer, :required => true}, :description => "zee svitch zu moost calz", :something => 4},
+        ]
+        @hm = HashModel.new(:raw_data=>records)
+        @hm.where {:parameter == {:type => String, :required => true}}.should == [
+          {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>0, :_group_id=>0}, 
+          {:switch=>"--xtended", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>1, :_group_id=>0}
+        ]
+      end
+      
+    end
+
+    context "when using variables to search" do
+      
+      it "should work with a block" do
+        variable = "-x"
+        @hm.filter{:switch == variable}.should == [@flat_records[0]]
+      end
+      
+      it "should work with a default index search" do
+        variable = "-x"
+        @hm.filter(variable).should == [@flat_records[0]]
+      end
+      
+      it "should work with classes" do
+        variable = String
+        @hm.filter{:parameter__type == variable}.should == [@flat_records[0], @flat_records[1], @flat_records[4]]
+      end
+
+      it "should work with deeply nested default indexes" do
+        @hm.flatten_index = :parameter__type
+        variable = nil
+        @hm.filter(variable).should == [
+          {:parameter__type=>nil, :switch=>["-y", "--why"], :description=>"lucky what?", :_id=>1, :_group_id=>1}
+        ]
+      end
+      
+    end
+
+    context "searching for the parent" do
+      it "should return the raw record the child record is based on" do
+        @hm.parents("-x").should == [@records[0]]
+      end
+      it "should return all the parents if there are more than one base on the search" do
+        @hm.parents{:parameter__type == String}.should == [@records[0],@records[2]]
+      end
+    end
+
+    it "should return false if tested for inclusion of anything other than a hash" do
+      @hm.include?([:switch=>"-x"]).should == false
+    end
+    
+    it "should match flat data if search criteria includes an _group_id field" do
+      @hm.include?(@flat_records[2]).should == true
+    end
+    
+    it "should search raw data if search criteria includes an _group_id field" do
+      @hm.include?(@records[2]).should == true
+    end
+
+    it "should return the flattened record index using the index method" do
+      @hm.index(@flat_records[3]).should == 3
+    end
+    
+    context "when using take" do
+      it "should return the first n flat records" do
+        @hm.take(2).should == @flat_records.take(2)
+      end
+    
+      it "should return the first n flat records while block is true" do
+        @hm.take_while {|record| record[:_id] < 4}.should == @flat_records[0..3]
+      end
+      
+    end
+
+    it "should return values at x,y,z" do
+      @hm.values_at(1,3,5).should == @flat_records.values_at(1,3,5)
+    end
+    
+    it "should zip things" do
+      hm2 = HashModel.new(:raw_data=>@records2)
+      @hm.zip(hm2).should == @flat_records.zip(@flat_records2)
+    end
+    
+  end # searching records
+end