hashmodel 0.4.0.beta1 → 0.4.0.beta2

data/spec/hash_model/hash_model_array_methods_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+  
+describe HashModel do
+
+
+  context "when using array methods and properties" do
+    
+    it "should return an array when calling to_ary" do
+      @hm.to_ary.class.should == Array
+    end
+    
+    it "should not return a HashModel when calling to_ary" do
+      @hm.to_ary.class.should_not == HashModel
+    end
+    
+    it "should return the flat records when calling to_ary" do
+      @hm.to_ary.should == @flat_records
+    end
+    
+    it "should return an array when calling to_a" do
+      @hm.to_a.class.should == Array
+    end
+    
+    it "should not return a HashModel when calling to_a" do
+      @hm.to_a.class.should_not == HashModel
+    end
+    
+    it "should return the flat records when calling to_a" do
+      @hm.to_a.should == @flat_records
+    end
+    
+    it "should report the length of the flat data" do
+      @hm.length.should == @flat_records.length
+    end
+    
+    it "should report the size of the flat data" do
+      @hm.size.should == @flat_records.size
+    end
+    
+    it "should return the correct flat record when using at" do
+      @hm.at(0).should == @flat_records[0]
+      @hm.at(2).should == @flat_records[2]
+    end
+
+    it "should collect across the flat data" do
+      extra = -1
+      @hm.collect {|record| record.merge!(:extra=>extra+=1)}.should == [
+        {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>0, :_group_id=>0, :extra=>0}, 
+        {:switch=>"--xtended", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>1, :_group_id=>0, :extra=>1}, 
+        {:switch=>"-y", :description=>"lucky what?", :_id=>2, :_group_id=>1, :extra=>2}, 
+        {:switch=>"--why", :description=>"lucky what?", :_id=>3, :_group_id=>1, :extra=>3}, 
+        {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>4, :_group_id=>2, :extra=>4}
+      ]
+    end
+
+    it "should map across the flat data" do
+      extra = -1
+      @hm.map {|record| record.merge!(:extra=>extra+=1)}.should == [
+        {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>0, :_group_id=>0, :extra=>0}, 
+        {:switch=>"--xtended", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>1, :_group_id=>0, :extra=>1}, 
+        {:switch=>"-y", :description=>"lucky what?", :_id=>2, :_group_id=>1, :extra=>2}, 
+        {:switch=>"--why", :description=>"lucky what?", :_id=>3, :_group_id=>1, :extra=>3}, 
+        {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>4, :_group_id=>2, :extra=>4}
+      ]
+    end
+    
+    it "should combination'ize the flat data" do
+      hm_combo = []
+      flat_combo = []
+      @hm.combination(2).each { |record| hm_combo << record }
+      @flat_records.combination(2) { |record| flat_combo << record }
+      hm_combo.should == flat_combo
+    end
+
+    it "should count the flat data" do
+      @hm.count.should == @flat_records.count
+    end
+
+    it "should cycle over the flat data" do
+      cycle = cycle2 = []
+      @hm.cycle(2) {|record| cycle << record}
+      @flat_records.cycle(2) {|record| cycle2 << record}
+      cycle.should == cycle2
+    end
+
+    it "should iterate with an index" do
+      collect = []
+      @hm.each_index {|index| collect << @hm[index][:switch]}
+      collect.should == ["-x", "--xtended", "-y", "--why", "-z"]
+    end
+    
+    it "should say if it's empty" do
+      @hm = HashModel.new
+      @hm.empty?.should == true
+      @hm << @records[0]
+      @hm.empty?.should == false
+    end
+
+    it "should fetch records given an index" do
+      @hm.fetch(2).should == @flat_records[2]
+    end
+
+    it "should return the default value if fetch index is out of bounds" do
+      @hm.fetch(10, "potato").should == "potato"
+    end
+
+    it "should run a block if fetch index is out of bounds" do
+      (@hm.fetch(10) {|index| index }).should == 10
+    end
+
+    it "should return the first flattened record" do
+      @hm.first.should == @flat_records.first
+    end
+
+    it "should return the last flattened record" do
+      @hm.last.should == @flat_records.last
+    end
+
+    it "should freeze the raw records" do
+      proc{@hm.freeze}.should change(@hm.raw_data,:frozen?)
+      .from(false)
+      .to(true)
+    end
+    
+    it "should permutate over the flat data" do
+      @hm.permutation(2).to_a.should == @flat_records.permutation(2).to_a
+      @hm.permutation.to_a.should == @flat_records.permutation.to_a
+      @hm.permutation.to_a.should_not == @records.permutation.to_a
+    end
+    
+  end
+end

data/spec/hash_model/hash_model_comparisons_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+  
+describe HashModel do
+
+  context "when making comparisons" do
+    
+    it "should allow arrays to be compared to the HashModel" do
+      @hm.should == @flat_records
+    end
+    
+    it "should allow HashModels to be compared to the HashModel" do
+      hm2 = HashModel.new(:raw_data=>@records)
+      @hm.should == hm2
+    end
+
+    it "should compare using the raw data if sent an array without group_id's or id's" do
+      @hm.should == @records
+    end
+    
+    it "should return false if compared to something other than an Array or a HashModel" do
+      @hm.should_not == "potato"
+    end
+    
+    it "should allow arrays to be compared to the HashModel using eql?" do
+      @hm.eql?(@hm).should == true
+    end  
+    
+    it "should return false if compared to an array of something other than hashes" do
+      @hm.should_not == ["potato"]
+    end
+    
+    it "should use flattened records if <=>'d with an array with a group_id" do
+      (@hm <=> @flat_records).should == 0
+    end
+    
+    it "should use flattened records if <=>'d with an array without a group_id" do
+      (@hm <=> @records).should == 0
+    end
+    
+    it "should use flattened data if <=>'d with another HashModel" do
+      hm2 = @hm.clone
+      (@hm <=> hm2).should == 0
+    end
+    
+    it "should return nil if <=>'d with something other than an Array or a HashModel" do
+      (@hm <=> "potato").should == nil
+    end
+    
+    it "should compare to an empty array" do
+      @hm.where!("potato")
+      @hm.should == []
+    end
+    
+  end # comparisons
+end

data/spec/hash_model/hash_model_delete_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+  
+describe HashModel do
+
+  context "when deleting records" do
+
+    context "and doing it destructively" do
+      it "should delete the raw record the child record is based on" do
+        hm = HashModel.new << @records[1] << @records[2]
+        @hm.delete!("-x")
+        @hm.should == hm
+      end
+      it "should delete all the parents if there are more than one base on the search" do
+        hm = HashModel.new(:raw_data=>@records[1])
+        @hm.delete!{:parameter__type == String}
+        @hm.should == hm
+      end
+      it "returns the parent records that are deleted" do
+        @hm.delete!{:parameter__type == String}.should == [@records[0], @records[2]]
+       end
+    end
+
+    context "NON-destructively" do
+      # Arrays returns the records deleted, not the original array minus the deletion.
+      # The class now mimics that behavior to be less surprising and more Ruby like.
+      
+      it "should delete the raw record the child record is based on" do
+        hm = HashModel.new << @records[1] << @records[2]
+        @hm.delete("-x")
+        @hm.should_not == hm
+      end
+      it "should delete all the parents if there are more than one base on the search" do
+        hm = HashModel.new(:raw_data=>@records[1])
+        @hm.delete{:parameter__type == String}
+        @hm.should_not == hm
+      end
+      it "should delete the raw record the child record is based on" do
+        hm = HashModel.new << @records[0] 
+        hm2 = @hm.delete("-x")
+        hm2.should == hm
+      end
+      it "should delete all the parents if there are more than one base on the search" do
+        hm = HashModel.new(:raw_data=>[@records[0], @records[2]])
+        hm2 = @hm.delete{:parameter__type == String}
+        hm2.should == hm
+      end
+    end
+
+  end
+
+end

data/spec/hash_model/hash_model_flattening_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+  
+describe HashModel do
+  
+  context "when flattening" do
+    
+    it "should set the first field given as the default flatten index" do
+      @hm << {:switch => ["-x", "--xtended"], :description => "Xish stuff"}
+      @hm.add(:description => "blah,blah,blah")
+      @hm.flatten_index.should == :switch
+    end
+    
+    it "should set the flatten index properly if specified using parameter :flatten_index" do
+      @hm = HashModel.new(:raw_data=>@records, :flatten_index=>:parameter)
+      @hm.should == [
+        {:parameter=>{:type=>String}, :switch=>["-x", "--xtended"], :description=>"Xish stuff", :_id=>0, :_group_id=>0}, 
+        {:parameter=>{:required=>true}, :switch=>["-x", "--xtended"], :description=>"Xish stuff", :_id=>1, :_group_id=>0}, 
+        {:parameter=>nil, :switch=>["-y", "--why"], :description=>"lucky what?", :_id=>2, :_group_id=>1}, 
+        {:parameter=>{:type=>String}, :switch=>"-z", :description=>"zee svitch zu moost calz", :_id=>3, :_group_id=>2}
+      ]
+  
+    end
+  
+    it "should allow you to change the flatten index" do
+      @hm << {:switch => ["-x", "--xtended"], :description => "Xish stuff"}
+      proc do
+        @hm.flatten_index = :description
+      end.should change(@hm, :flatten_index).from(:switch).to(:description)
+    end
+    
+    it "should throw an error if an invalid flatten index is given" do
+        @records = [
+          { :switch => [ [5, 6], [1, :blah=>2] ] }
+        ]
+        @hm = HashModel.new(:raw_data=>@records)
+        proc {@hm.flatten_index = :switch__blah}.should raise_error(ArgumentError)
+    end
+    
+    it "shouldn't throw an error if a valid flatten index is given" do
+      proc {@hm.flatten_index = :parameter__type}.should_not raise_error
+    end
+
+    it "should reset the flatten index if an invalid flatten index is given" do
+        @records = [
+          { :switch => [ [5, 6], [1, :blah=>2] ] }
+        ]
+        @hm = HashModel.new(:raw_data=>@records)
+        proc {@hm.flatten_index = :switch__blah}.should raise_error(ArgumentError)
+        @hm.flatten_index.should == :switch
+    end
+
+    it "should set the flatten index when adding to an empty HashModel" do
+      @hm.flatten_index.should == :switch
+    end
+
+    it "should assign the flattened data to self correctly when adding records using <<" do
+      @hm = HashModel.new
+      @hm << @records[0]
+      @hm << @records[1]
+      @hm << @records[2]
+      @hm.should == @flat_records
+    end
+
+    it "should assign the flattened data to self correctly when adding with :raw_data=>records" do
+      @hm.should == @flat_records
+    end
+    
+    it "should add a nil value for the field index for records that don't have a field with the field index" do
+      @hm = HashModel.new
+      @hm << @records[0]
+      @hm << {:foo=>"bar"}
+      @hm.last.should == {:switch=>nil, :foo=>"bar", :_id=>2, :_group_id=>1}
+    end
+
+    it "should change the flattened data when changing the flatten index" do
+      @hm = HashModel.new(:raw_data=>@records)
+      @hm.flatten_index = :parameter__type
+      @hm.should == [
+        {:parameter__type=>String, :switch=>["-x", "--xtended"], :parameter__required=>true, :description=>"Xish stuff", :_id=>0, :_group_id=>0}, 
+        {:parameter__type=>nil, :switch=>["-y", "--why"], :description=>"lucky what?", :_id=>1, :_group_id=>1}, 
+        {:parameter__type=>String, :switch=>"-z", :description=>"zee svitch zu moost calz", :_id=>2, :_group_id=>2}
+      ]
+    end
+
+    it "should update the flattened data if the raw data is changed" do
+      @hm.raw_data = @records2.clone
+      @hm.should == @flat_records2
+    end
+
+  end # flattening behvior
+
+end

data/spec/hash_model/hash_model_group_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+describe HashModel do
+  
+  context "when grouping" do
+       
+    it "should return a HashModel object" do
+      @hm.group("-x").class.should == HashModel
+    end
+  
+    it "should return a different HashModel object" do
+      @hm.group("-x").object_id.should_not == @hm.object_id
+    end
+  
+    it "should return the records in the same raw data record when using a parameter" do
+      @hm.group("-x").should == [@flat_records[0], @flat_records[1]]
+    end
+  
+    it "should be chainable on a filtered HashModel" do
+      # Doesn't make logical sense anymore to do it this way since 
+      # when you #where the HashModel you've deleted all the other data
+      # Just use group like a #group like a where like above
+      # @hm.where("-x").group.should == [@flat_records[0],@flat_records[1]]
+    end 
+  
+    it "should return the records in the same raw data record when using a block" do
+      @hm.group{:switch == "-y"}.should == [@flat_records[2], @flat_records[3]]
+    end
+  
+    it "should group across group_id's if searching for something that returns records from multiple groups" do
+      @hm.group{: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=>4, :_group_id=>2}
+      ]
+    end
+  
+    it "should group with a complex 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.group {(: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 group with nested hashes 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.group {: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 # grouping
+end

data/spec/hash_model/hash_model_searching_spec.rb

@@ -0,0 +1,245 @@
+require 'spec_helper'
+  
+describe HashModel do
+
+  context "when 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
+      
+    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 "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 "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