hashmodel 0.4.0.rc1 → 0.4.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hashmodel (0.4.0.rc1)
+    hashmodel (0.4.0)
       file-tail (~> 1.0)
       sourcify (~> 0.4)
 

data/README.markdown

@@ -1,12 +1,22 @@
 # HashModel
 
-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.
+A hash based MVC model class that makes searching and updating deeply nested hashes a breeze.
+It's meant to be used for small, in-memory hash based recordset that you want an easy, flexible way to query and update.
 It is not meant as a data storage device for managing huge datasets.
 
+## Testing for a Better Tomorrow ##
+
+I have the gem set up to ask if you would like to test on install so please allow the tests to run and upload. This will allow me to find any problems on different platforms. 
+
+You can take a look at the test results yourself here:
+
+<http://test.rubygems.org/gems/hashmodel/v/0.4.0>
+
+Thanks for your help.
+
 ## Synopsis ##
 
-The major usefulness of this class is it allows you to filter and search flattened records based on any field. You can even updated and delete data now! Exclamation!
+HashModel allows you to filter, search, and updated flattened records based on any field, even deeply nested ones. You can even updated and delete data!
 
 A field can contain anything, including another hash, a string, an array, or even an Object class like String or Array, not just an instance of an Object class.
 
@@ -21,28 +31,60 @@ Searches are very simple and logical. You can search using just using the value
     hash_model = HashModel.new(:raw_data=>records)  
     found = hash_model.where("-x")  => Returns an array of flattened records  
 
+If you want to filter the data temporarily, but not delete any data, use `filter`:
 
-Or more powerfully you can search using boolean like logic with dynamic variables:  
+    x = "-x"
+    found = hash_model.filter{:switch == x}
+    found == hash_model # => true
+    
+    # To clear the filter just call it without any parameters
+    hash_model.filter
+    found.filter
+    found == hash_model # => true
+
+If you want a copy of your data with just the records that don't match your query use `where`:
    
+    param_type = String
+    found = hash_model.where{:parameter__type == param_type}
+    found.raw_data != hash_model.raw_data # => true
+
+To permanently remove the raw data that doesn't match your query use `where!`:
+
+    param_type = String
+    found = hash_model.where!{:parameter__type == param_type}
+    found.raw_data == hash_model.raw_data # => true
+
+If you want a copy of your data with the data updated use `update`:
+
+    where = {:switch == "-x"}
+    param_type = String
+    updated = hash_model.update(:parameter__type => param_type) &where
+    updated.raw_data != hash_model.raw_data # => true
+
+As you would expect you can also update your data in place using `update!`:
+
     x = "-x"
     param_type = String
-    found = hash_model.where {:switch == x && :parameter__type == param_type}  => Returns an array of flattened records  
+    updated = hash_model.update!(x, :parameter__type => param_type) 
+    updated.raw_data == hash_model.raw_data # => true
 
-If you want to update a record in place you can do that as well:
+If you want to update a recored an add a field if it doesn't exist you can use `update_and_add`:
 
     x = "-x"
     param_type = String
-    updated = hash_model.update!(x, :parameter__type => param_type)  => Returns an array of flattened records  
+    updated = hash_model.update!(x, :parameter__type => param_type) 
+    updated.raw_data == hash_model.raw_data # => true
+
 
 For more info checkout the rdocs and also checkout the change history below. I go in-depth on the new method calls.
 
 ## Status ##
 
-2011.03.19 - Beta: 0.4.0.beta2
+2011.03.23 - Release: 0.4.0
 
 Lots of changes with this one. The major changes are the ability to write to the HashModel data. See Version History for details.
 
-I fixed a **huge** bug that caused variables not to be ignored in boolean searches. It's all fixed now and there are specs to prove make sure it doesn't happen again.
+I fixed a **huge** bug that caused variables to be ignored in boolean searches. It's all fixed now and there are specs to prove make sure it doesn't happen again.
 
 ## Demo App ##
 
@@ -233,11 +275,13 @@ I've covered most of the major stuff here but to see all of the functionality ta
 
 ## Version History ##
 
-0.4.0.beta2 - 2011.03-21
+0.4.0 - 2011.03-23
+
+**Lots of updates and a major bug fix for this release.**
 
-Lots of updates and code fixes for this release. After using it for a little while I've broken down and added the write functionality I was avoiding previously. 
+After using it for a little while I've broken down and added the write functionality I was avoiding previously. 
 
-I fixed a **major** bug/design flaw that didn't let you use variables in a boolean block. For instance this was supposed to work but didn't:
+I also fixed a **major** bug/design flaw that didn't let you use variables in a boolean block. For instance this was supposed to work but didn't:
 
     x = "-x"
     hm.where{:x == x}
@@ -246,7 +290,7 @@ It works properly now.
 
 **Additions/Changes**
 
-#### Methods: `update` and `update!` methods ####
+#### Methods: `update` and `update!` ####
 These methods use a `where` like search that is slightly different. As you would expect the `update` method returns a changed copy of the HashModel while `update!` changes the data in place.
 
 The methods look like this `update(default_index_search, field_new_value_hash, boolean_search_block)`. So if you search using a single value, a default index search, then you put the update hashes at the end. If you want to search using a boolean search then you put the update hashes at the beginning.
@@ -273,7 +317,7 @@ You don't have to put in any search criteria at all though, you can just put in
 
 All of the `update` methods will return the records that were updated with the updates in place. If no records were updated then it will return an empty array. It currently returns the raw records that are or would be deleted but I will be changing it to return the flattened records. That will be in the next update.
 
-#### Methods: `update_and_add` and `update_and_add!` methods ####
+#### Methods: `update_and_add` and `update_and_add!` ####
 Just like `update` and `update!` but will also add a hash if it doesn't exist already. Again the ! method changes the records in place.
 
 For instance if your HashModel has a record like `{:a=>"a"}` and you do `my_hash_model.update(:b=>"b")` it won't change that record, but it you do `my_hash_model.update_and_add(:b=>"b")` then your record will be `{:a=>'a', :b=>"b"}`.
@@ -300,7 +344,7 @@ Since bangs (!) are all now destructive, to bring the class inline with Ruby sta
 #### Other changes ####
 Because of the new destructive methods all input values will be cloned. You don't have to worry about cloning input objects yourself. If it's clonable HashModel will clone it.
 
-I've reorganized the code into multiple files based on functionality to make it easier to debug when adding new features. This is in anticipation of a major cleanup and refactoring.
+I've reorganized the code into multiple files based on functionality to make it easier to debug when adding new features. I've done some refactoring but I plan on a major cleanup and refactoring for the next version. That version won't have too many new features but will be a major clean up and optimization.
 
 Cleaned up RSpecs a little along the lines of reorganization.
 
@@ -308,6 +352,7 @@ Cleaned up RSpecs a little along the lines of reorganization.
 * Didn't use variable in where searches.
 * Threw error if you searched an empty HashModel (can't build a flatten index on nothing)
 * Couldn't change the flatten index in some rare cases. 
+* Threw error when filtering on non-existent fields.
 
 0.3.1 - 2011.03.18
 
@@ -343,6 +388,13 @@ e.g. hash_model.where{:x == "x" && :y == "y"} instead of the less natural hash_m
 * Initial publish  
 * Released on wrong RubyGems account (yanked)
 
+## Planned Updates ##
+
+* Add a simple load/save to file methodology that's **FAST!**
+* Make :\_group\_id and :\_id fields not show up by default. They'll still be accessible but they are really more internal values than external so it would be cleaner not to show them.
+* Major refactor for memory efficiency, speed, and general code de-stink.
+* Allow additive filters, i.e. filter on one thing then filter on another and they second filter is based on the first filter. This would also be applicable for `update` and `where` methods; any time a filter is given.
+
 
 ## Contributing to HashModel ##
 

data/hashmodel.gemspec

@@ -11,7 +11,14 @@ Gem::Specification.new do |s|
   s.email                   = ["mikbe.tk@gmail.com"]
   s.homepage                = "http://mikbe.tk"
   s.summary                 = %q{A hash based MVC model class that makes searching and updating deeply nested hashes a breeze.}
-  s.description             = %q{A hash based MVC model class that makes searching and updating deeply nested hashes a breeze. You can store deeply nested hashes and still easily flatten, query, and update the records using flattened field names.}
+  s.description             = 
+"""
+A hash based MVC model class that makes searching and updating deeply nested hashes a breeze.
+You can store deeply nested hashes and still easily flatten, query, and update the records using flattened field names.
+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.
+"""
+
   s.license                 = 'MIT'
   
   s.add_dependency "sourcify", "~>0.4"

data/lib/hash_model/hash_model_update.rb

@@ -11,7 +11,7 @@ class HashModel
   # 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
@@ -99,7 +99,7 @@ class HashModel
     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
+        return if target_hash.nil? or !(target_hash[source_hash_key] or add)
         target_hash[source_hash_key] = source_hash_value
         save_change << record_id
       else

data/lib/hash_model/version.rb

@@ -3,8 +3,8 @@ class HashModel
     MAJOR  = 0
     MINOR  = 4
     TINY   = 0
-    PRE    = "rc1"
-
+    PRE    = nil
+    
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
 
     SUMMARY = "HashModel #{STRING}"

data/spec/hash_model/hash_model_filter_spec.rb

@@ -0,0 +1,35 @@
+require "spec_helper"
+
+describe HashModel do
+
+  let(:hm){
+    HashModel.new(:raw_data=> [
+        {:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a =>"b2a", :b2b=>"b2b"}}},
+        {:a=>"17", :b=>"7291", :c=>"0"},
+        {:a=>"17", :b=>"080", :c=>"1"},
+        {:a=>"17", :b=>"24134", :c=>2}
+      ]
+    )
+  }
+
+  context "when using a block" do
+
+    it "should accept a block variable" do
+      where = lambda {:a == "a"}
+      lambda{hm.filter &where}.should change{hm.clone}
+      .from( [
+          {:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a =>"b2a", :b2b=>"b2b"}}},
+          {:a=>"17", :b=>"7291", :c=>"0"},
+          {:a=>"17", :b=>"080", :c=>"1"},
+          {:a=>"17", :b=>"24134", :c=>2}
+        ]
+      )
+      .to( [
+          {:a=>"a", :b=>{:b1=>"b1", :b2=>{:b2a =>"b2a", :b2b=>"b2b"}}, :_id=>0, :_group_id=>0}
+        ]
+      )
+    end
+  
+  end
+
+end

data/spec/hash_model/hash_model_update_spec.rb

@@ -5,7 +5,6 @@ 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
     
@@ -103,7 +102,46 @@ describe HashModel do
       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
-            
+      
+      context "and using variables for the update values" do
+      
+        it "should return the updated records" do
+          update_field = :b
+          update_to = "23"
+          update_hash = {update_field => update_to}
+          hm.update!(update_hash).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
+          update_field = :b
+          update_to = "23"
+          update_hash = {update_field => update_to}
+          lambda{hm.update!(update_hash)}.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
+          update_field = :a
+          update_to = "BBBB"
+          update_hash = {update_field => update_to}
+          hm.update!(update_hash).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 in a destructive update" do
+          update_field = :a
+          update_to = "BBBB"
+          update_hash = {update_field => update_to}
+          it {hm.update!(update_hash); hm.length.should == 0}
+        end
+      end
+       
     end
    
     context "when using non-destructive methods" do
@@ -141,6 +179,101 @@ describe HashModel do
       
       
     end
+
+    context "when the update field doesn't exist" 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 {lambda{hm.update({:parameter__type => String})}.should_not raise_error}
+      it {hm.update(:parameter__type => String).should be_empty}
+
+      context "and using a block variable search" do
+
+        it "should not raise an error" do
+          where = lambda {:a == "a"}
+          param_type = String
+          lambda{hm.update({:parameter__type => param_type}, &where)}.should_not raise_error
+        end
+      
+        it "should return an empty recordset" do
+          where = lambda {:a == "a"}
+          param_type = String
+          hm.update(:parameter__type => param_type, &where).should be_empty
+        end
+        
+      end
+      
+    end
+        
+    context "when the search field doesn't exist" 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 {lambda{hm.update({:b=>"blorg"},lambda {:parameter__type == String})}.should_not raise_error}
+      it {hm.update({:b=>"blorg"},lambda {:parameter__type == String}).should be_empty}
+
+      context "and using a block variable search" do
+
+        it "should not raise an error" do
+          param_type = String
+          where = lambda {:parameter__type == param_type}
+          update_to_value = "g"
+          update_to = {:a => update_to_value}
+          lambda{hm.update(update_to, &where)}.should_not raise_error
+        end
+      
+        it "should return an empty recordset" do
+          param_type = String
+          where = lambda {:parameter__type == param_type}
+          update_to_value = "g"
+          update_to = {:a => update_to_value}
+          hm.update(update_to, &where).should be_empty
+        end
+
+      end
+
+    end
+        
+    context "when the neither the search field nor the update field exist" 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 {lambda{hm.update({:g=>"blorg"},lambda {:parameter__type == String})}.should_not raise_error}
+      it {hm.update({:g=>"blorg"},lambda {:parameter__type == String}).should be_empty}
+
+      context "and using variables in the search and update" do
+
+        it "should not raise an error" do
+          param_type = String
+          where = lambda {:flappidy == param_type}
+          update_to_value = "malamute"
+          update_to = {:puppies => update_to_value}
+          lambda{hm.update(update_to, &where)}.should_not raise_error
+        end
+      
+        it "should return an empty recordset" do
+          param_type = String
+          where = lambda {:zippidy__do__da == param_type}
+          update_to_value = "delicious"
+          update_to = {:goldfish => update_to_value}
+          hm.update(update_to, &where).should be_empty
+        end
+
+      end
+
+    end
     
   end
 

metadata

@@ -1,20 +1,20 @@
 --- !ruby/object:Gem::Specification
 name: hashmodel
 version: !ruby/object:Gem::Version
-  version: 0.4.0.rc1
-  prerelease: 6
+  version: 0.4.0
+  prerelease: 
 platform: ruby
 authors:
 - Mike Bethany
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-03-21 00:00:00.000000000 -04:00
+date: 2011-03-23 00:00:00.000000000 -04:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sourcify
-  requirement: &2158444080 !ruby/object:Gem::Requirement
+  requirement: &2154533780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -22,10 +22,10 @@ dependencies:
         version: '0.4'
   type: :runtime
   prerelease: false
-  version_requirements: *2158444080
+  version_requirements: *2154533780
 - !ruby/object:Gem::Dependency
   name: file-tail
-  requirement: &2158443580 !ruby/object:Gem::Requirement
+  requirement: &2154533200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -33,10 +33,10 @@ dependencies:
         version: '1.0'
   type: :runtime
   prerelease: false
-  version_requirements: *2158443580
+  version_requirements: *2154533200
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2158443080 !ruby/object:Gem::Requirement
+  requirement: &2154532600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -44,10 +44,10 @@ dependencies:
         version: '2.5'
   type: :development
   prerelease: false
-  version_requirements: *2158443080
+  version_requirements: *2154532600
 - !ruby/object:Gem::Dependency
   name: cucumber
-  requirement: &2158442600 !ruby/object:Gem::Requirement
+  requirement: &2154532020 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -55,10 +55,21 @@ dependencies:
         version: '0.3'
   type: :development
   prerelease: false
-  version_requirements: *2158442600
-description: A hash based MVC model class that makes searching and updating deeply
-  nested hashes a breeze. You can store deeply nested hashes and still easily flatten,
-  query, and update the records using flattened field names.
+  version_requirements: *2154532020
+description: ! '
+
+  A hash based MVC model class that makes searching and updating deeply nested hashes
+  a breeze.
+
+  You can store deeply nested hashes and still easily flatten, query, and update the
+  records using flattened field names.
+
+  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.
+
+'
 email:
 - mikbe.tk@gmail.com
 executables: []
@@ -101,6 +112,7 @@ files:
 - spec/hash_model/hash_model_array_methods_spec.rb
 - spec/hash_model/hash_model_comparisons_spec.rb
 - spec/hash_model/hash_model_delete_spec.rb
+- spec/hash_model/hash_model_filter_spec.rb
 - spec/hash_model/hash_model_flattening_spec.rb
 - spec/hash_model/hash_model_group_spec.rb
 - spec/hash_model/hash_model_searching_spec.rb
@@ -130,9 +142,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>'
+  - - ! '>='
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.6.2
@@ -150,6 +162,7 @@ test_files:
 - spec/hash_model/hash_model_array_methods_spec.rb
 - spec/hash_model/hash_model_comparisons_spec.rb
 - spec/hash_model/hash_model_delete_spec.rb
+- spec/hash_model/hash_model_filter_spec.rb
 - spec/hash_model/hash_model_flattening_spec.rb
 - spec/hash_model/hash_model_group_spec.rb
 - spec/hash_model/hash_model_searching_spec.rb