hashmodel 0.4.0.beta1 → 0.4.0.beta2

data/lib/hash_model/hash_model_delete.rb

@@ -0,0 +1,13 @@
+class HashModel
+  
+  # Returns a copy of the HashModel with raw data deleted based on the search criteria
+  def delete(index_search=:DontSearchForThis_195151c48a254db2949ed102c81ec579, &block_search)
+    self.clone.delete!(index_search, &block_search)
+  end
+  
+  # Deletes the raw data records based on the search criteria
+  def delete!(index_search=:DontSearchForThis_195151c48a254db2949ed102c81ec579, &block_search)
+    parents(index_search, &block_search).each{|parent| @raw_data.delete(parent)}
+  end
+
+end

data/lib/hash_model/hash_model_filter.rb

@@ -0,0 +1,37 @@
+class HashModel
+
+
+  # Filter the flattened records based on the value of the
+  # default index or by using a boolean logic block:
+  # filter("x")
+  # filter{:x==4 and :y!="potato"}
+  def filter(index_search=:DontSearchForThis_195151c48a254db2949ed102c81ec579, &block_search)
+    # Parameter checks
+    raise SyntaxError, "You may only provide a parameter or a block but not both" unless index_search==:DontSearchForThis_195151c48a254db2949ed102c81ec579 or block_search.nil?
+    return self if @raw_data.empty?
+
+    # Allow clearing the filter and returning the entire recordset if nothing is given
+    if index_search == :DontSearchForThis_195151c48a254db2949ed102c81ec579 && block_search.nil?
+      @filter_proc = nil
+      @filter_binding = nil
+      return flatten
+    end
+
+    # If given a parameter make our own search based on the flatten index
+    unless index_search == :DontSearchForThis_195151c48a254db2949ed102c81ec579
+      string_search = "(:#{@flatten_index} == #{index_search.inspect})".to_s # << the to_s makes sure it's evaluated now
+      @filter_binding = nil
+    else
+      # Convert the proc to a string so it can have :'s turned into @'s
+      # We only want the internals so we can write the proc the way we want
+      string_search = block_search.to_source(:strip_enclosure => true)
+      @filter_binding = block_search.binding
+    end
+    
+    # Set and process the filter
+    @filter_proc = string_search
+    flatten
+  end
+
+
+end

data/lib/hash_model/hash_model_flatten.rb

@@ -0,0 +1,47 @@
+class HashModel
+
+  # Processes the raw_data and flattens the records based on the filter (set by filter or a where search)
+  def flatten
+    # Don't flatten the data if we don't need to
+    return self unless dirty?
+
+    id = -1
+    group_id = -1
+    @modified_data.clear
+    # set the flatten index if this is the first time the function is called
+    @flatten_index = @raw_data[0].keys[0] if @raw_data != [] && @flatten_index.nil?
+    flatten_index = @flatten_index.to_s
+    # Change the filter so it looks for variables instead of symbols
+    unless @filter_proc.nil?
+      proc_filter = @filter_proc.clone
+      proc_filter.scan(/(:\S+) ==/).each {|match| proc_filter.sub!(match[0], match[0].sub(":","@"))}
+      proc_filter.sub!(":_group_id", "@_group_id")
+    end
+
+    # Flatten and filter the raw data
+    @raw_data.each do |record|
+      new_records, duplicate_data = flatten_hash(record, flatten_index)
+      # catch raw data records that don't have the flatten index
+      new_records << {@flatten_index.to_sym=>nil} if new_records.empty?
+      group_id += 1
+      new_records.collect! do |new_record|
+        # Double bangs aren't needed but are they more efficient?
+        new_record.merge!( duplicate_data.merge!( { :_id=>(id+=1), :_group_id=>group_id } ) )
+      end 
+
+      # Add the records to modified data if they pass the filter
+      new_records.each do |new_record|
+        unless @filter_proc.nil?
+          variables_string, remove_string = create_value_string(new_record)
+          @modified_data << new_record if eval("#{variables_string}return_value=#{proc_filter};#{remove_string}return_value", @filter_binding)
+        else
+          @modified_data << new_record
+        end
+      end
+
+    end # raw_data.each
+    set_dirty_hash
+    self
+  end # flatten
+
+end

data/lib/hash_model/hash_model_group.rb

@@ -0,0 +1,18 @@
+class HashModel
+  
+  # Return the other records created from the same raw data record as the one(s) searched for
+  def group(index_search=:DontSearchForThis_195151c48a254db2949ed102c81ec579, &block_search)
+    group_hm = self.clone
+    # Filter the recordset if applicable
+    if !index_search.nil? || !block_search.nil?
+      group_hm.filter(index_search, &block_search)
+    end
+    # Get all the unique group id's
+    group_ids = group_hm.collect {|hash| hash[:_group_id]}.uniq
+    # reset the filter
+    group_hm.filter
+    group_hm.filter_proc = "#{group_ids.to_s}.include? :_group_id"
+    group_hm.flatten
+  end
+  
+end

data/lib/hash_model/hash_model_update.rb

@@ -0,0 +1,118 @@
+class HashModel
+
+  # Returns a copy of the HashModel that matches the search criteria
+  # updated using the update_hash. This affects the raw_data.
+  def update(index_search=:DontSearchForThis_195151c48a254db2949ed102c81ec579, update_hash, &block_search)
+    self.clone.update!(index_search, update_hash, &block_search)
+  end
+  
+  # Destructively updates the raw data for the records that match the
+  # search criteria. Since this affects the raw_data so if more than one record
+  # is based on the raw_data that's changed that record will be changed too.
+  # Returns the records that were updated.
+  def update!(index_search=:DontSearchForThis_195151c48a254db2949ed102c81ec579, update_hash, &block_search)
+    
+    # only filter if they sent something to be filter otherwise leave the filter alone
+    unless index_search == :DontSearchForThis_195151c48a254db2949ed102c81ec579 && block_search.nil?
+      old_filter = @filter_proc
+      old_binding = @filter_binding
+      filter(index_search, &block_search)
+    end
+
+    changed = recursive_update_root(update_hash)
+
+    if old_filter
+      @filter_proc = old_filter
+      @filter_binding = old_binding
+      flatten
+    end
+    
+    changed
+  end
+
+  # Updates existing hashes with a given value and also
+  # adds the full root to the key if it doesn't already exist.
+  # Returns a new instance of the original HashModel
+  def update_and_add(index_search=:DontSearchForThis_195151c48a254db2949ed102c81ec579, update_hash, &block_search)
+    self.clone.update_and_add!(index_search, update_hash, &block_search)
+  end
+  
+  # Updates existing hashes with a given value and also
+  # adds the full root to the key if it doesn't already exist.
+  # Destructively updated the existing HashModel
+  def update_and_add!(index_search=:DontSearchForThis_195151c48a254db2949ed102c81ec579, update_hash, &block_search)
+    
+    # only filter if they sent something to be filter otherwise leave the filter alone
+    unless index_search == :DontSearchForThis_195151c48a254db2949ed102c81ec579 && block_search.nil?
+      old_filter = @filter_proc
+      old_binding = @filter_binding
+      filter(index_search, &block_search)
+    end
+
+    changed = recursive_update_root(update_hash, true)
+
+    if old_filter
+      @filter_proc = old_filter
+      @filter_binding = old_binding
+      flatten
+    end
+    
+    changed
+  end
+
+  protected 
+  
+  # Loops through the filtered recordset and sends each record off to be recursivly changed
+  def recursive_update_root(update_hash, add=false)
+    changed_record_ids = []
+    each do |record|
+      save_change = []
+      update_hash.each do |key,value|
+        unflat = unflatten(key=>value)
+        recursive_update_worker(@raw_data[record[:_group_id]], unflat, key, nil,  add, record[:_id], save_change)
+      end
+      changed_record_ids << save_change.uniq[0] unless save_change.empty?
+    end
+    # clear the filter so we can get changed records if the filter is 
+    # the field that changed (also causes records to update)
+    # This looks ripe for a refactor
+    if @filter_proc
+      old_filter = @filter_proc
+      old_binding = @filter_binding
+      @filter_proc = nil
+      @filter_binding = nil
+    end
+    # now that we've changed the raw data update the values in the flattened records
+    filter
+    # Grab the changed records
+    changed = @modified_data.select{|record| changed_record_ids.include?(record[:_id])}
+    if old_filter
+      @filter_proc = old_filter
+      @filter_binding = old_binding
+      flatten
+    end
+    changed
+  end
+
+  # Loops through the hash that represents the changes to make and recurses into as needed
+  def recursive_update_worker(target_hash, source_hash, terminal_key, parent_key, add, record_id, save_change)
+    source_hash.each do |source_hash_key, source_hash_value|
+      current_key = "#{parent_key}#{"__" if parent_key}#{source_hash_key}".to_sym 
+      if current_key == terminal_key
+        return unless target_hash[source_hash_key] or add
+        target_hash[source_hash_key] = source_hash_value
+        save_change << record_id
+      else
+        if target_hash.is_a? Hash
+          recursive_update_worker(target_hash[source_hash_key], source_hash[source_hash_key], terminal_key, current_key, add, record_id, save_change)
+        else
+          if add
+            target_hash = source_hash
+            save_change << record_id
+          end
+        end
+      end
+    end
+  end
+
+end

data/lib/hash_model/hash_model_where.rb

@@ -0,0 +1,27 @@
+class HashModel
+
+  # Search creating a new instance of HashModel based on this one
+  def where(index_search=:DontSearchForThis_195151c48a254db2949ed102c81ec579, &block_search)
+    self.clone.where!(index_search, &block_search)
+  end
+
+  # Search the flattened records using the default flatten index or a boolean block
+  def where!(index_search=:DontSearchForThis_195151c48a254db2949ed102c81ec579, &block_search)
+    filter(index_search, &block_search)
+    
+    # Delete the raw records that don't have matches
+    good_group_ids = unflatten(@modified_data).collect{|record| record[:_group_id]}.uniq
+    index = -1;
+    @raw_data.delete_if {|record| !good_group_ids.include?(index+=1)}
+    
+    # Remove the non-matching values from raw data for the filter_index
+    good_values = self.collect{|record| record[@flatten_index]}
+    @raw_data.each do |record|
+      if record[@flatten_index].is_a? Array
+        record[@flatten_index].delete_if{|value| !good_values.include?(value) }
+      end
+    end
+    self
+  end
+
+end

data/lib/hash_model/version.rb

@@ -3,7 +3,7 @@ class HashModel
     MAJOR  = 0
     MINOR  = 4
     TINY   = 0
-    PRE    = "beta1"
+    PRE    = "beta2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
 

data/lib/hashmodel.rb

@@ -1,5 +1,6 @@
 $: << '.'
 require 'sourcify'
+require 'monkey_patch/deep_clone'
 require 'hash_model/version'
 require 'hash_model/exceptions'
 require 'hash_model/hash_model'

data/lib/monkey_patch/deep_clone.rb

@@ -0,0 +1,27 @@
+class Object
+  
+  # Make sure there are no references left over
+  def deep_clone
+    Marshal.load(Marshal.dump(self))
+  end
+
+  # It's annoying to raise an error if an object can't
+  # be cloned, like in the case of symbols, It is much
+  # more friendly, and less surprising too, just to
+  # return the same object so you can go about your work.
+  # The only reason I clone is to protect the values, if
+  # the values don't need to be protected I don't want an
+  # annoying error message hosing up my whole day. </rant>
+  #
+  # Note: this is needed so deep_clone can work properly... don't get me started.
+  alias :__stupid_clone__ :clone
+  def clone
+    # I wonder what this will break...
+    begin
+      self.__stupid_clone__
+    rescue
+      self
+    end
+  end
+
+end

data/spec/hash_model/_current_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe HashModel do
+    
+
+end

data/spec/hash_model/hash_model_adding_records_spec.rb

@@ -0,0 +1,338 @@
+require 'spec_helper'
+  
+describe HashModel do
+
+  context "when adding records" do
+
+    it "should allow a hash of values to be added" do
+      proc { @hm << {:switch => ["-x", "--xtended"], :description => "Xish stuff"} }.should_not raise_error
+    end
+
+    it "should allow a single hash to be added with :raw_data" do
+      hash = {:switch => ["-x", "--xtended"], :description => "Xish stuff"}
+      @hm = HashModel.new(:raw_data => hash)
+      @hm.raw_data.should == [{:switch=>["-x", "--xtended"], :description=>"Xish stuff"}]
+    end
+
+    it "should allow a hash of values to be added using the keyword 'add'" do
+      proc { @hm.add(:switch => ["-x", "--xtended"], :description => "Xish stuff") }.should_not raise_error
+    end
+    
+    it "should allow an array of hashes to be added as if they were multiple records" do
+      proc { @hm << @records }.should_not raise_error
+    end
+    
+    it "should allow another HashModel to be added" do
+      @hm.add(@hm2).should == @flat_records_all
+    end
+    
+    it "should add a hash with a symbol as a value" do
+      @hm = HashModel.new
+      @hm << {:switch => :default}
+      @hm.should == [{:switch=>:default, :_id=>0, :_group_id=>0}]
+    end
+     
+    it "should add an array with mixed value types" 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.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=>:default, :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>2, :_group_id=>0},
+        {:switch=>"-y", :description=>"lucky what?", :_id=>3, :_group_id=>1}, 
+        {:switch=>"--why", :description=>"lucky what?", :_id=>4, :_group_id=>1}, 
+        {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>5, :_group_id=>2}
+      ]
+    end
+    
+    it "should add an array of arrays as values and not recurse into them" do
+        @records = [
+          { :switch => [ [5, 6], [1, 2] ] }
+        ]
+        @hm = HashModel.new(:raw_data=>@records)
+        @hm.should == [{:switch=>[5, 6], :_id=>0, :_group_id=>0}, {:switch=>[1, 2], :_id=>1, :_group_id=>0}]
+    end
+    
+    it "shouldn't recurse into arrays with hash values" do
+        @records = [
+          { :switch => [ [5, 6], [1, :blah=>2] ] }
+        ]
+        @hm = HashModel.new(:raw_data=>@records)
+        @hm.should == [{:switch=>[5, 6], :_id=>0, :_group_id=>0}, {:switch=>[1, :blah=>2], :_id=>1, :_group_id=>0}]
+    end
+    
+    it "should allow an array of HashModels to be added" do
+      @hm.add([@hm, @hm2])
+      @hm.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=>"-y", :description=>"lucky what?", :_id=>2, :_group_id=>1}, 
+        {:switch=>"--why", :description=>"lucky what?", :_id=>3, :_group_id=>1}, 
+        {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>4, :_group_id=>2}, 
+        {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>5, :_group_id=>3}, 
+        {:switch=>"--xtended", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>6, :_group_id=>3}, 
+        {:switch=>"-y", :description=>"lucky what?", :_id=>7, :_group_id=>4}, 
+        {:switch=>"--why", :description=>"lucky what?", :_id=>8, :_group_id=>4}, 
+        {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>9, :_group_id=>5}, 
+        {:switch=>"-p", :parameter=>{:type=>Hash, :required=>false}, :description=>"Pea soup", :_id=>10, :_group_id=>6}, 
+        {:switch=>"--pea", :parameter=>{:type=>Hash, :required=>false}, :description=>"Pea soup", :_id=>11, :_group_id=>6}, 
+        {:switch=>"-q", :description=>"exit the game", :_id=>12, :_group_id=>7}, 
+        {:switch=>"--quit", :description=>"exit the game", :_id=>13, :_group_id=>7}, 
+        {:switch=>"-r", :parameter=>{:type=>Fixnum}, :description=>"Arrrrrrrrrrgh!", :_id=>14, :_group_id=>8}
+      ]
+    end
+    
+    it "should allow field names that are longer versions of other names" do
+      @hm = HashModel.new
+      @hm << {:long => "short", :longer => "long"}
+      @hm.should == [{:long => "short", :longer => "long"}]
+    end
+    
+    it "should raise an error if something other than a hash, an array of hashes, or another HashModel (or an array of them) is added" do
+      proc { @hm << ["-x", "--xtended", "Xish stuff"] }.should raise_error
+    end
+  
+    it "should allow an array of hashes to be specified when creating the HashModel" do
+      proc { HashModel.new(:raw_data=>@records) }.should_not raise_error
+    end
+  
+    it "should retain the raw data used when creating the HashModel" do
+      @hm.raw_data.should == @records
+    end
+
+    it "should return a HashModel object when adding records using <<" do
+      (@hm << @records[0]).class.should == HashModel
+    end
+
+    it "should return the same HashModel instance when adding records using <<" do
+      (@hm << @records[0]).object_id.should == @hm.object_id
+    end
+    
+    it "should allow chaining of record adds using <<" do
+      proc {@hm << @records[0] << @records[1] << @records[2]}.should_not raise_error
+    end
+
+    it "should contain all of the records when chaining record adds" do
+      @hm = HashModel.new
+      @hm << @records[0] << @records[1] <<@records[2]
+      @hm.raw_data.should == @records
+    end
+
+    context "flattened records" do
+    
+      it "should allow a flattened record to be added" do
+        @hm = HashModel.new
+        @hm << {:switch=>"-x", :parameter__type=>String, :parameter__required=>true, :description=>"Xish stuff"}
+        @hm.raw_data.should == [{:switch => "-x", :parameter => {:type => String, :required => true}, :description => "Xish stuff"}]
+      end
+
+      it "should allow a flattened record to be added even with arrays in it" do
+        @hm = HashModel.new
+        @hm << {:switch=>["-x", "--xtend"], 
+                  :parameter__type=>String, 
+                  :parameter__required=>true, 
+                  :description=>"Xish stuff", 
+                  :field__field2 => {:field3 => "ff3", :field4 => "ff4"}
+               }
+        @hm.raw_data.should == [ 
+                                {
+                                    :switch => ["-x", "--xtend"], 
+                                    :parameter => {:type => String, :required => true}, 
+                                    :description => "Xish stuff", 
+                                    :field => {:field2 => {:field3 => "ff3", :field4 => "ff4"}}
+                                 }
+                               ]
+      end
+      
+      it "should allow deeply flattened record to be added" 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",
+        }
+        @hm = HashModel.new
+        @hm << deep_hash
+        @hm.raw_data.should == [
+          {
+            :parameter => [
+              {:type=>String}, 
+              "glorp", 
+              {:required=>true}
+            ], 
+            :switch => [
+              {:deep1 => {:deep3=>"deepTwo"}},
+              {:deep2=>"deepTwo"}, 
+              "--xtend"
+            ], 
+            :description=>"Xish stuff"
+          }
+        ] 
+      end
+      
+      
+    end
+
+    context "using the + sign" do
+
+      it "should return a HashModel class when adding an Array" do
+        (@hm + @records2).class.should == HashModel
+      end
+
+      it "should return a HashModel class when adding a HashModel" do
+        (@hm + @hm2).class.should == HashModel
+      end
+
+      it "should return a different HashModel instance" do
+        (@hm + @records2).object_id.should_not == @hm.object_id
+      end
+
+      it "should contain the records of both recordsets when adding an Array" do
+        (@hm + @records2).raw_data.should == (@records + @records2)
+      end
+
+      it "should contain the records of both recordsets when adding a HashModel" do
+        (@hm + @hm2).raw_data.should == (@records + @records2)
+      end
+      
+      it "should use the flatten index of the receiver HashModel" do
+        hm2 = HashModel.new
+        hm2 << {:potato=>7}
+        (@hm + hm2).flatten_index.should == :switch
+        (hm2 + @hm).flatten_index.should == :potato
+      end
+      
+    end # "when using the plus sign"
+
+    context "using the += sign" do
+
+      it "should return a HashModel class" do
+        (@hm += @records2).class.should == HashModel
+      end
+
+      it "should return the same HashModel instance when using += to add an array" do
+        (@hm += @records2).object_id.should == @hm.object_id
+      end
+
+      it "should contain the records of both recordsets when adding an Array" do
+        @hm += @records2
+        @hm.raw_data.should == (@records + @records2)
+      end
+
+      it "should contain the records of both recordsets when adding a HashModel" do
+        @hm += @hm2
+        @hm.raw_data.should == (@records + @records2)
+      end
+      
+      it "should not alter the added HashModel" do
+        proc{@hm += @hm2}.should_not change(@hm2, :raw_data)
+      end
+      
+    end # "when using the += sign"
+
+    context "using the * sign" do
+      
+      it "should return a HashRecord" do
+        (@hm * 2).class.should == HashModel
+      end
+      
+      it "should return a different HashRecord" do
+        (@hm * 2).object_id.should_not == @hm.object_id
+      end
+      
+      it "should return a HashModel with twice the amount of raw data if * 2'd" do
+        (@hm * 2).raw_data.should == [
+          {:switch=>["-x", "--xtended"], :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"},
+          {:switch=>["-x", "--xtended"], :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"}
+        ]
+      end
+      
+    end
+
+    context "using the *= sign" do
+    
+      it "should return the same HashModel" do
+       (@hm *= 2).object_id.should == @hm.object_id
+      end
+      
+      it "should change current raw to twice its old raw data if *= 2'd" do
+        @hm *= 2
+        @hm.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=>"-y", :description=>"lucky what?", :_id=>2, :_group_id=>1}, 
+          {:switch=>"--why", :description=>"lucky what?", :_id=>3, :_group_id=>1},
+          {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>4, :_group_id=>2}, 
+          {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>5, :_group_id=>3}, 
+          {:switch=>"--xtended", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :_id=>6, :_group_id=>3}, 
+          {:switch=>"-y", :description=>"lucky what?", :_id=>7, :_group_id=>4}, 
+          {:switch=>"--why", :description=>"lucky what?", :_id=>8, :_group_id=>4}, 
+          {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>9, :_group_id=>5}
+        ]
+      end
+      
+    end
+
+    context "using concat" do
+      
+      it "should concatinate using a single Hash" do
+        @hm.concat(@records2[0]).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=>"-y", :description=>"lucky what?", :_id=>2, :_group_id=>1}, 
+          {:switch=>"--why", :description=>"lucky what?", :_id=>3, :_group_id=>1}, 
+          {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>4, :_group_id=>2}, 
+          {:switch=>"-p", :parameter=>{:type=>Hash, :required=>false}, :description=>"Pea soup", :_id=>5, :_group_id=>3}, 
+          {:switch=>"--pea", :parameter=>{:type=>Hash, :required=>false}, :description=>"Pea soup", :_id=>6, :_group_id=>3}
+        ]
+      end
+      
+      it "should concatinate using an array" do
+        @hm.concat(@records2).should == @flat_records_all
+      end
+      
+      it "should concatinate using a HashModel" do
+        @hm.concat(@hm2).should == @flat_records_all
+      end
+      
+    end
+
+    context "using push" do
+      
+      it "should add a single Hash" do
+        @hm.push(@records2[0]).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=>"-y", :description=>"lucky what?", :_id=>2, :_group_id=>1}, 
+          {:switch=>"--why", :description=>"lucky what?", :_id=>3, :_group_id=>1}, 
+          {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>4, :_group_id=>2}, 
+          {:switch=>"-p", :parameter=>{:type=>Hash, :required=>false}, :description=>"Pea soup", :_id=>5, :_group_id=>3}, 
+          {:switch=>"--pea", :parameter=>{:type=>Hash, :required=>false}, :description=>"Pea soup", :_id=>6, :_group_id=>3}
+        ]
+      end
+      
+      it "should add an array" do
+        @hm.push(@records2).should == @flat_records_all
+      end
+      
+      it "should add a HashModel" do
+        @hm.push(@hm2).should == @flat_records_all
+      end
+      
+    end
+
+  end # adding records
+
+end