hashmodel 0.3.0.beta1 → 0.3.0.beta2

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hashmodel (0.3.0.beta1)
+    hashmodel (0.3.0.beta2)
       file-tail
       sourcify
 

data/README.markdown

@@ -4,9 +4,10 @@ A simple MVC type model class for storing deeply nested hashes as records.
 It's meant to be used for small, in-memory recordset that you want an easy, flexible way to query.
 It is not meant as a data storage device for managing huge datasets.
 
-Note: 
-This is more of a programming exercise to learn about Ruby so if you're looking for a good
-model class take a look at ActiveModel, it's probably more of what you're looking for.
+Note:   
+This started out as a programming exercise to learn more about Ruby but is now fairly well featured so can be quite useful.
+It is not however a thoroughly tested or industrial strength model and it's not meant to be used to parse your entire user database.
+If you're looking for an excellent model class take a look at ActiveModel, it's probably more of what you're looking for.
 
 ## Synopsis
 
@@ -15,31 +16,40 @@ A field can contain anything, including another hash, a string, an array, or eve
 
 Searches are very simple and logical. You can search using just using the value of the default index 
 
+    require 'hashmodel'
     records = [  
       {:switch => ["-x", "--xtended"], :parameter => {:type => String, :require => 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)  
-    found = hm.where("-x")  => Returns an array of flattened records  
+    hash_model = HashModel.new(:raw_data=>records)  
+    found = hash_model.where("-x")  => Returns an array of flattened records  
 
 
 Or more powerfully you can search using boolean like logic e.g.  
    
-    hm = HashModel.new(:raw_data=>records)  
-    found = hm.where {:switch == "-x" && :parameter__type == String}  => Returns an array of flattened records  
+    hash_model = HashModel.new(:raw_data=>records)  
+    found = hash_model.where {:switch == "-x" && :parameter__type == String}  => Returns an array of flattened records  
 
 
 ## Status
 
-###**Beta: Probably good to go but needs some more real-world testing**###  
-The latest version is still beta but mostly because I didn't realize little time it would take to get the changes I wanted done in version 0.3.0 and I didn't want to release 0.2.0 and 0.3.0 within a day of each other.
+###**Beta**  
+
+I'm doing real-world testing now and am fixing design holes and adding functionality so I wouldn't use this version until I'm done. None of the previous versions were all that useful but after I release this version I'll only develop in branches.
+
+I expect the design to stay pretty stable from this point forward so no more surprising changes in the design or its use.
+
+## Developer Notes
+
+If you have problems running Autotest on your RSpecs try including the gem file-tail in your app. You **shouldn't** have to since I include it here but I had problems with Autotest and Sourcify and adding that fixed it.
 
 ## Usage
 
-These are just a few of the major methods of the class, to see all the functionality take a look at the RSpec files.
+I've covered most of the major stuff here but to see all of the functionality take a look at the RSpec files.
 
 ### **Creating with an array of hashes**  
+    require 'hashmodel'
     records = [  
       {:switch => ["-x", "--xtended"], :parameter => {:type => String, :require => true}, :description => "Xish stuff"},  
       {:switch => ["-y", "--why"],  :description => "lucky what?"},  
@@ -54,9 +64,13 @@ These are just a few of the major methods of the class, to see all the functiona
     >> {: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}  
 
+
 ### **Group ID's and Record ID's**
-    # You may have noticed that there are two fields you didn't add in the flattened records. These are the :_id field and the :_group_id fields.
-    # :_id is a unique ID for the flattened record while :_group_id is unique to the raw record you used to create the HashModel record.
+    # You may have noticed that there are two fields you didn't add in the 
+    # flattened records. These are the :_id field and the :_group_id fields.
+    # :_id is a unique ID for the flattened record while :_group_id is 
+    # unique to the raw record you used to create the HashModel record.
+
 
 ### **Adding hashes after creation : <<, +, add, concat, push**  
     hash_model = HashModel.new  
@@ -91,9 +105,9 @@ These are just a few of the major methods of the class, to see all the functiona
       {:switch => ["-y", "--why"],  :description => "lucky what?"},  
       {:switch => "-z",  :parameter => {:type => String}, :description => "zee svitch zu moost calz"},  
     ]  
-    hm = HashModel.new(:raw_data=>records) 
+    hash_model = HashModel.new(:raw_data=>records) 
     
-    puts hm.raw_data
+    puts hash_model.raw_data
     >> {:switch => ["-x", "--xtended"], :parameter => {:type => String, :require => true}, :description => "Xish stuff"}  
     >> {:switch => ["-y", "--why"],  :description => "lucky what?"}  
     >> {:switch => "-z",  :parameter => {:type => String}, :description => "zee svitch zu moost calz"}  
@@ -105,11 +119,18 @@ These are just a few of the major methods of the class, to see all the functiona
     hash_model.each do |record|
       # record is a hash
     end
-  
+
+### **Direct access to flattened records : []**
+    # the HashModel acts a lot like an array so you can iterate over it
+    hash_model = HashModel.new(:raw_data=>records)  
+
+    puts hash_model[0]
+    >> {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>0, :_group_id=>0}
+
   
 ### **Flattening records : flatten_index**
     # Flatten index is automatically set to the first field ever given
-    # but you can change it
+    # but you can change it to any field you want.
     hash_model = HashModel.new(:raw_data=>records)  
 		
     puts hash_model.flatten_index
@@ -130,24 +151,22 @@ These are just a few of the major methods of the class, to see all the functiona
 		
 
 ### **Searching Records : where**
-    # This is where the real power of the library is. You can do complex boolean searches using flattened field names.
-    
     # You can search using just a value and it will search based on the flatten_index
     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 => String, :required => true}, :description => "zee svitch zu moost calz", :something => 4},
     ]
-    hm = HashModel.new(:raw_data=>records)
-    where = hm.where("-x")
+    hash_model = HashModel.new(:raw_data=>records)
+    where = hash_model.where("-x")
 
     puts where
     >> {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>0, :_group_id=>0}
     
-    # Best of all you can use complex boolean searches using normal and flattend field names.
+    # But the real power is the ability to search with complex boolean logic using normal and flattend field names.
     # Note that flattened field names are seperated with double under lines __
-    hm = HashModel.new(:raw_data=>records)
-    where = hm.where {:something == 7 || (:parameter__type == String && :parameter__required == true)}
+    hash_model = HashModel.new(:raw_data=>records)
+    where = hash_model.where {:something == 7 || (:parameter__type == String && :parameter__required == true)}
 
     puts where
     >> {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>0, :_group_id=>0}
@@ -155,25 +174,24 @@ These are just a few of the major methods of the class, to see all the functiona
     >> {:switch=>"-z", :parameter=>{:type=>String, :required=>true}, :description=>"zee svitch zu moost calz", :something=>4, :_id=>4, :_group_id=>2}
 
     # You can even search using hash values
-    hm = HashModel.new(:raw_data=>records)
-    where = hm.where {:parameter == {:type => String, :required => true}}
+    hash_model = HashModel.new(:raw_data=>records)
+    where = hash_model.where {:parameter == {:type => String, :required => true}}
     
     puts where
-    
     >> {: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}
 
 
 ### **Finding Sibling Records : group**
     # Since the HashModel class flattens records it is sometimes useful to know what records were created from the same raw data record.
-    # This works exactly like a where search so you can send just a value or send a block and get all of the sibling records for your search criteria.
+    # This works exactly like a #where search so you can send just a value or send a block and get all of the sibling records for your search criteria.
     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)
-    group = hm.group {(:parameter__type == String && :parameter__required == true && :something == 4) || :something == 7}
+    hash_model = HashModel.new(:raw_data=>records)
+    group = hash_model.group {(:parameter__type == String && :parameter__required == true && :something == 4) || :something == 7}
     
     puts group
     >> {:switch=>"-x", :parameter=>{:type=>String, :required=>true}, :description=>"Xish stuff", :something=>4, :_id=>0, :_group_id=>0}
@@ -183,14 +201,14 @@ These are just a few of the major methods of the class, to see all the functiona
 
 
 ### **Unflattening records : unflatten**
-    # Anywhere you can add a raw record you can add a flat record
-    hm = HashModel.new
-    hm << {:switch=>"-x", :parameter__type=>String, :parameter__require=>true, :description=>"Xish stuff"}
+    # You can also add flat records in the same way you add raw records. 
+    hash_model = HashModel.new
+    hash_model << {:switch=>"-x", :parameter__type=>String, :parameter__require=>true, :description=>"Xish stuff"}
     
-    puts hm.raw_data
+    puts hash_model.raw_data
     >> {:switch => "-x", :parameter => {:type => String, :require => true}, :description => "Xish stuff"}
     
-    # You can also call the unflatten method yourself on an instance or the class itself and send it a record. (It won't mess with the existing data.)
+    # You can also call the unflatten method on an instance or the class itself and send it a record. (It won't mess with the existing data.)
     deep_hash =  { 
       :parameter__type=>String,
       :switch__deep1__deep3 => "deepTwo",
@@ -211,12 +229,15 @@ These are just a few of the major methods of the class, to see all the functiona
 
 0.3.0.beta1 - 2011.01.09  
 
-* Changed HashModel\#where searches to use symbols instead of @variables.  
-e.g. hm.where{:x == "x" && :y == "y"} instead of the less natural hm.where{@x == "x" && @y == "y"}  
+* HashModel\#where searches can now use symbols instead of @variables (you can still use @ if you want).  
+e.g. hash_model.where{:x == "x" && :y == "y"} instead of the less natural hash_model.where{@x == "x" && @y == "y"}  
 * Converted the HashModel filter from a proc to a string so it can be viewed and allows the above behavior.  
-* Removed Jeweler and converted to Bundler gem building.
+* Changed name for require to mirror name of app (require 'hashmodel' instead of confusing require 'hash_model')  
+* Added flatten to multiple methods (clone, to\_s, to\_a, to\_ary) so they'll return flattened data if called without anything else happening first.  
+* Fixed design flaw that didn't allow arrays of arrays to be used as values or arrays as searches.  
+* Removed Jeweler and converted to Bundler gem building.  
 * Added usage instructions.  
-* To do: Refactor some ugly code, more usage examples?
+* To do: Refactor some ugly code  
 
 0.2.0 - 2011.01.08  
 

data/_brainstorm/_readme

@@ -0,0 +1 @@
+This is my scratchpad area where I try stuff out. Nothing really useful here.

data/_brainstorm/inspect.rb

@@ -0,0 +1,26 @@
+class TestSelf
+  include Enumerable
+  
+  attr_accessor :data
+  
+  def initialize(data=[])
+    @data = data
+  end
+  
+  def each
+    @data.each do |record| 
+      yield record
+    end
+  end
+  
+  def to_s
+    @data.to_s
+  end
+  
+end
+
+
+array = [1,2,3,4,5]
+ts = TestSelf.new(array)
+
+puts ts[2]

data/features/support/env.rb

@@ -8,7 +8,7 @@ rescue Bundler::BundlerError => e
 end
 
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'hash_model'
+require 'hashmodel'
 require 'rspec/expectations'
 
 # load helper functions

data/lib/hash_model/hash_model.rb

@@ -29,8 +29,22 @@ class HashModel
 
   # Sets field name used to flatten the recordset
   def flatten_index=(value)
+    old_flatten = @flatten_index
     @flatten_index = value
     flatten
+    
+    # Verify the flatten index is a valid index
+    flatten_found = false
+    @modified_data.each do |record|
+      break (flatten_found = true) if record[value]
+    end
+  
+    unless flatten_found
+      @flatten_index = old_flatten
+      flatten 
+      raise ArgumentError, "Flatten index could not be created: #{value}"
+    end
+    self
   end
 
   # Are the records being filtered?
@@ -49,6 +63,7 @@ class HashModel
     raise SyntaxError, "Raw data may only be an array of hashes" if value.class != Array
     check_field_names(value)
     @raw_data = value.clone
+    flatten
   end
 
 
@@ -78,8 +93,9 @@ class HashModel
     @filter = nil
   end
 
-  # Force arrays to be cloned
+  # Force internal arrays to be cloned
   def clone
+    flatten
     hm = HashModel.new(:raw_data=>@raw_data.clone)
     hm.flatten_index = @flatten_index
     hm.filter = @filter
@@ -125,7 +141,7 @@ class HashModel
         @modified_data  == value
       when Array
         # test for something other than hashes, a flattened recordset, or raw data
-        if !value.empty? && value[0].class == Hash && value[0].has_key?(:_group_id)
+        if value.empty? || (value[0].class == Hash && value[0].has_key?(:_group_id))
           @modified_data == value
         else
           @raw_data == value
@@ -186,16 +202,19 @@ class HashModel
     # If given a parameter make our own search based on the flatten index
     unless value.nil?
       # Make sure the field name is available to the proc
-      if value.class == String
-        string_search = ":#{@flatten_index} == \"#{value}\"".to_s
-      else
-        string_search = ":#{@flatten_index} == #{value}".to_s
+      case value
+        when String
+          string_search = ":#{@flatten_index} == \"#{value}\"".to_s
+        when Symbol
+          string_search = ":#{@flatten_index} == :#{value}".to_s
+        else
+          string_search = ":#{@flatten_index} == #{value}".to_s
       end
     else
       # Convert the proc to a string so it can be viewed
       # and later have :'s turned into @'s
       
-      # Sourcify can create single or multi-line procs
+      # Sourcify can create single or multi-line procs so we have to make sure we deal with them accordingly
       source = search.to_source
       unless (match = source.match(/^proc do\n(.*)\nend$/))
         match = source.match(/^proc { (.*) }$/)
@@ -261,11 +280,12 @@ class HashModel
         proc_filter.sub!(":_group_id", "@_group_id")
         proc_filter = "proc { #{proc_filter} }.call"
       end
-
+      
       # Add the records to modified data if they pass the filter
       new_records.each do |new_record|
         unless @filter.nil?
-          @modified_data << new_record if create_object_from_flat_hash(new_record).instance_eval proc_filter
+          flat = create_object_from_flat_hash(new_record)
+          @modified_data << new_record if flat.instance_eval proc_filter
         else
           @modified_data << new_record
         end
@@ -283,14 +303,21 @@ class HashModel
 
   # Return a string consisting of the flattened data
   def to_s
+    flatten
     @modified_data.to_s
   end
 
   # Return an array of the flattened data
   def to_ary
+    flatten
     @modified_data.to_ary
   end
   
+  def to_a
+    flatten
+    @modified_data.to_a
+  end
+  
   # Iterate over the flattened records
   def each
     @modified_data.each  do |record| 
@@ -452,7 +479,12 @@ class HashModel
         end # input.each
       when Array
         input.each do |value|
-          recordset, duplicate_data = flatten_hash(value, flatten_index, recordset, duplicate_data, parent_key)
+         case value
+            when Hash
+              recordset, duplicate_data = flatten_hash(value, flatten_index, recordset, duplicate_data, parent_key)
+            else
+              recordset << {parent_key.to_sym=>value}
+          end
         end
       else
         recordset << {parent_key.to_sym=>input}
@@ -473,8 +505,9 @@ class HashModel
           hash_record = create_object_from_flat_hash(value, hash_record, flat_key)
         end
       when Array
+        hash_record.instance_variable_set("@#{parent_key}", record)
         record.each do |value|
-          hash_record = create_object_from_flat_hash(value, hash_record, parent_key)
+          hash_record = create_object_from_flat_hash(value, hash_record, parent_key) if value.class == Hash
         end
       else
         hash_record.instance_variable_set("@#{parent_key}", record)

data/lib/hash_model/version.rb

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

data/spec/hash_model/hash_model_spec.rb

@@ -110,6 +110,45 @@ describe "HashModel" 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, :require => 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, :require=>true}, :description=>"Xish stuff", :_id=>0, :_group_id=>0}, 
+        {:switch=>"--xtended", :parameter=>{:type=>String, :require=>true}, :description=>"Xish stuff", :_id=>1, :_group_id=>0}, 
+        {:switch=>:default, :parameter=>{:type=>String, :require=>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 == [
@@ -433,6 +472,27 @@ describe "HashModel" 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
@@ -548,6 +608,11 @@ describe "HashModel" do
       (@hm <=> "potato").should == nil
     end
     
+    it "should compare to an empty array" do
+      @hm.where!("potato")
+      @hm.should == []
+    end
+    
   end # comparisons
 
   describe "searching and selecting records" do
@@ -569,7 +634,48 @@ describe "HashModel" do
       it "should return the same hash model when calling where" do
          @hm.where!("-x").object_id.should == @hm.object_id
       end
-     
+      
+      it "should return the entire flattened recordset if nothing is sent" do
+        @hm.where!("-x")
+        @hm.should == [@flat_records[0]]
+        @hm.where!
+        @hm.should == @flat_records
+      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, :require => 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, :require=>true}, :description=>"Xish stuff", :_id=>2, :_group_id=>0}]
+      end
+
+      it "should search using an array" do
+        @records = [
+          { :switch => [ [5,6], [1,2] ] }
+        ]
+        @hm = HashModel.new(:raw_data=>@records)
+        @hm.where([1,2]).should == [{:switch=>[1,2], :_id=>1, :_group_id=>0}]
+      end
+
+      it "should search using an array including a hash" do
+        @records = [
+          { :switch => [ [5,6], [1,:blah=>2] ] }
+        ]
+        @hm = HashModel.new(:raw_data=>@records)
+        @hm.where([1,:blah=>2]).should == [{:switch=>[1,:blah=>2], :_id=>1, :_group_id=>0}]
+      end
+
+    end
+  
+    context "filtering records" do
+  
       it "should filter the recordset" do
         @hm.where!("-x")
         @hm.should == [@flat_records[0]]
@@ -596,14 +702,7 @@ describe "HashModel" do
         proc {@hm.where!}.should change(@hm, :filtered?).from(true).to(false)
       end
       
-      it "should return the entire flattened recordset if nothing is sent" do
-        @hm.where!("-x")
-        @hm.should == [@flat_records[0]]
-        @hm.where!
-        @hm.should == @flat_records
-      end
-      
-    end # in place
+    end # filtering
     
     context "not in place" do
 

data/spec/spec_helper.rb

@@ -1,6 +1,6 @@
 $: << '.'
 $LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
-require 'hash_model'
+require 'hashmodel'
 require 'rspec'
 require 'rspec/matchers'
 
@@ -28,7 +28,7 @@ module Kernel
   def dp(value)
     puts ""
     puts "*" * 40
-    puts "value: #{value}"
+    puts value
     puts "&" * 40
     puts ""
   end

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 3
   - 0
-  - beta1
-  version: 0.3.0.beta1
+  - beta2
+  version: 0.3.0.beta2
 platform: ruby
 authors: 
 - Mike Bethany
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-09 00:00:00 -05:00
+date: 2011-01-11 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -88,10 +88,12 @@ files:
 - LICENSE.txt
 - README.markdown
 - Rakefile
+- _brainstorm/_readme
 - _brainstorm/block_wheres.rb
 - _brainstorm/clone.rb
 - _brainstorm/hash_model_examples.rb
 - _brainstorm/hash_test.rb
+- _brainstorm/inspect.rb
 - _brainstorm/instance_vars.rb
 - _brainstorm/proc_tests.rb
 - _brainstorm/ref_val.rb
@@ -108,10 +110,10 @@ files:
 - features/support/env.rb
 - features/support/helper.rb
 - hashmodel.gemspec
-- lib/hash_model.rb
 - lib/hash_model/exceptions.rb
 - lib/hash_model/hash_model.rb
 - lib/hash_model/version.rb
+- lib/hashmodel.rb
 - spec/hash_model/hash_model_spec.rb
 - spec/spec_helper.rb
 has_rdoc: true