hashmodel 0.3.1 → 0.4.0.beta1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hashmodel (0.3.0.beta2)
+    hashmodel (0.4.0)
       file-tail
       sourcify
 
@@ -18,27 +18,28 @@ GEM
     diff-lcs (1.1.2)
     file-tail (1.0.5)
       spruz (>= 0.1.0)
-    gherkin (2.3.3)
+    gherkin (2.3.4)
       json (~> 1.4.6)
     json (1.4.6)
-    rspec (2.4.0)
-      rspec-core (~> 2.4.0)
-      rspec-expectations (~> 2.4.0)
-      rspec-mocks (~> 2.4.0)
-    rspec-core (2.4.0)
-    rspec-expectations (2.4.0)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
       diff-lcs (~> 1.1.2)
-    rspec-mocks (2.4.0)
+    rspec-mocks (2.5.0)
     ruby2ruby (1.2.5)
       ruby_parser (~> 2.0)
       sexp_processor (~> 3.0)
-    ruby_parser (2.0.5)
+    ruby_parser (2.0.6)
       sexp_processor (~> 3.0)
     sexp_processor (3.0.5)
-    sourcify (0.4.0)
+    sourcify (0.4.2)
+      file-tail (>= 1.0.5)
       ruby2ruby (>= 1.2.5)
       sexp_processor (>= 3.0.5)
-    spruz (0.2.2)
+    spruz (0.2.5)
     term-ansicolor (1.0.5)
 
 PLATFORMS
@@ -46,7 +47,5 @@ PLATFORMS
 
 DEPENDENCIES
   cucumber
-  file-tail
   hashmodel!
   rspec
-  sourcify

data/README.markdown

@@ -6,7 +6,8 @@ It is not meant as a data storage device for managing huge datasets.
 
 ## Synopsis
 
-The major usefulness of this class is it allows you to filter and search flattened records based on any field.
+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.
+
 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.
 
 Searches are very simple and logical. You can search using just using the value of the default index 
@@ -29,11 +30,9 @@ Or more powerfully you can search using boolean like logic e.g.
 
 ## Status
 
-2011.03.18 - Production: 0.3.1
-
-## Developer Notes
+2011.03.19 - Beta: 0.4.0.beta01
 
-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.
+Lots of changes with this one. Mostly the ability to write to the HashModel and a few bug fixes. See Version History for details.
 
 ## Usage
 
@@ -216,7 +215,61 @@ I've covered most of the major stuff here but to see all of the functionality ta
     >> {:parameter=>[{:type=>String}, "glorp", {:require=>true}], :switch=>[{:deep1=>{:deep3=>"deepTwo"}}, {:deep2=>"deepTwo"}, "--xtend"], :description=>"Xish stuff"}
   
 
-## Version History
+## Version History ##
+
+0.4.0.beta01 - 2011.03-19
+
+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. 
+
+**Additions/Changes**
+
+#### Methods: `update` and `update!` methods ####
+These methods use a `where` like search that is slightly different. 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.
+
+For instance:
+
+    # Default index search
+    my_hash_model.update("-x", :parameter__type=>Fixnum)
+    
+    # Boolean search 
+    my_hash_model.update(:parameter__type=>Fixnum) {:switch == "-x"}
+
+You don't have to put in any search criteria at all though, you can just put in the field you want updated and it will update all records that are in the current filter set. 
+
+
+#### Methods: `update` and `update!` methods ####
+Just like `update` and `update!` but will also add a hash if it doesn't exist already.
+
+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"}`.
+
+
+#### Methods: `delete` and `delete!` ####
+These use a the standard `where` type search used everywhere else. This function removes data from the raw data so if you have other flattened records that are based on that raw data they will no longer exist since the data that generated them is gone.  
+
+Just like an array these methods return the records they deleted.
+
+#### Method: `parent` ####
+Again this uses a `where` search and returns all raw parent records for flattened records matching the search criteria. (This method was there before but hadn't actually be coded, it was just a copy of some code I started but shouldn't have been in a release version).
+
+#### Changed: `filter` ####
+Filter has been changed from a property to a method. It is exactly like a `where` search but it's in-place and non-destructive. Since `where!` was changed to be truly destructive this change was needed. It also makes all the search functions identical in their usage.
+
+#### Changed: `where!` ####
+Changed to be truly destructive. If you run a where! on the class you're losing records that don't match it. The non-destructive version `where` is changed in that it does not contain the raw data of any records that don't match the `where` clause but the original HashModel remains untouched.
+
+#### Removed: `group!` ####
+Since bangs (!) are all now destructive, to bring the class inline with Ruby standards, it doesn't make logical sense to have a a group method that deletes all data except the search data then tries to find siblings; they were just deleted with the destructive call. Instead just use `group` and it will return the sibling records without touching the data in the HashModel.
+
+#### 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.
+
+Cleaned up RSpecs a little along the lines of reorganization.
+
+#### Bug fixes ####
+* 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. 
 
 0.3.1 - 2011.03.18
 
@@ -253,7 +306,7 @@ e.g. hash_model.where{:x == "x" && :y == "y"} instead of the less natural hash_m
 * Released on wrong RubyGems account (yanked)
 
 
-##Contributing to HashModel
+## Contributing to HashModel ##
 
 * Pull requests are handled ASAP.
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
@@ -261,10 +314,10 @@ e.g. hash_model.where{:x == "x" && :y == "y"} instead of the less natural hash_m
 * Fork the project  
 * Start a feature/bugfix branch  
 * Commit and push until you are happy with your contribution  
-* Make sure to add RSpecs in a separate file so I can easily tell what changed (changes without specs will not be pulled) for it.
+* Make sure to add RSpecs in a separate file so I can easily tell what changed (changes without specs will not be pulled).
 * Changes to the configuration files, version numbers, or branches will not be pulled. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
 
-##Copyright
+## Copyright ##
 
-Copyright (c) 2010 Mike Bethany. See LICENSE.txt for further details.
+Copyrighted free software - Copyright (c) 2011 Mike Bethany. See LICENSE.txt for further details.
 

data/hashmodel.gemspec

@@ -15,6 +15,12 @@ Gem::Specification.new do |s|
   s.add_dependency "sourcify"
   s.add_dependency "file-tail"
   
+  # After hassling with version dependency it makes more sense NOT to
+  # declare version numbers and let it break if it is actually going
+  # to break instead of having it break every single time even if it
+  # wouldn't have broken with the new versions. Or maybe people need
+  # to be looser with their versioning requiremetns. My 2 cents.
+  #
   s.add_development_dependency "rspec"
   s.add_development_dependency "cucumber"
 

data/lib/hash_model/hash_model.rb

@@ -1,4 +1,11 @@
 require 'sourcify'
+require 'hash_model/hash_model_delete'
+require 'hash_model/hash_model_group'
+require 'hash_model/hash_model_filter'
+require 'hash_model/hash_model_update'
+require 'hash_model/hash_model_where'
+
+
 # A simple MVC type model class for storing hashes as flattenable, searchable records
 class HashModel
   include Enumerable
@@ -11,12 +18,13 @@ class HashModel
     mimic_methods
     
     # Set values given as hashes
-    parameters.each { |key,value| instance_variable_set("@#{key}", value) }
+    parameters.each { |key,value| 
+      instance_variable_set("@#{key}", smart_clone(value)) }
 
     # Allow a single hash to be added with :raw_data
     @raw_data = [@raw_data] if @raw_data.class == Hash
 
-    check_field_names(@raw_data) if !@raw_data.empty?
+    check_field_names(@raw_data) unless @raw_data.empty?
     
     # Setup the flat data
     flatten
@@ -25,12 +33,14 @@ class HashModel
 
   ## Properties
 
-  attr_accessor :flatten_index, :raw_data, :filter
-
+  attr_accessor :flatten_index, :raw_data, :filter_proc
+  
   # Sets field name used to flatten the recordset
   def flatten_index=(value)
     old_flatten = @flatten_index
+    old_filter = @filter_proc
     @flatten_index = value
+    @filter_proc = nil
     flatten
     
     # Verify the flatten index is a valid index
@@ -41,6 +51,7 @@ class HashModel
   
     unless flatten_found
       @flatten_index = old_flatten
+      @filter_proc = old_filter
       flatten 
       raise ArgumentError, "Flatten index could not be created: #{value}"
     end
@@ -49,12 +60,7 @@ class HashModel
 
   # Are the records being filtered?
   def filtered?
-    !!@filter
-  end
-
-  def filter=(filter)
-    @filter = filter
-    flatten
+    !!@filter_proc
   end
 
   # Trap changes to raw data so we can re-flatten the data
@@ -62,11 +68,10 @@ class HashModel
     value = [] if value.nil?
     raise SyntaxError, "Raw data may only be an array of hashes" if value.class != Array
     check_field_names(value)
-    @raw_data = value.clone
+    @raw_data = smart_clone(value)
     flatten
   end
 
-
   ## Public Methods 
 
   # Freeze all the data properties
@@ -79,7 +84,7 @@ class HashModel
   
   # Remove the in-place where filter
   def clear_filter
-    @filter = nil
+    @filter_proc = nil
     flatten
   end
   alias :clear_where :clear_filter # in case this makes more sense to people
@@ -90,23 +95,25 @@ class HashModel
     @modified_data = []
     @unflatten_data  = []
     @flatten_index = nil
-    @filter = nil
+    @filter_proc = nil
   end
 
-  # Force internal arrays to be cloned
+  # Force internal arrays and variables to be cloned
   def clone
+    return self if @raw_data.empty?
     flatten
     hm = HashModel.new(:raw_data=>@raw_data.clone)
     hm.flatten_index = @flatten_index
-    hm.filter = @filter
+    hm.filter_proc = @filter_proc
     hm
   end
 
   ## Operators
   
-  # Overload Array#<< function so we can create the flatten index as the first record is added
-  # and allows us to send back this instance of the HashModel instead of an array.
+  # Overload Array#<< function so we can create the flatten index as the first record is added.
+  # This also allows us to send back this instance of the HashModel instead of an array.
   def <<(value)
+    value = smart_clone(value)
     case value
       when HashModel
         @raw_data.concat(value.raw_data)
@@ -116,8 +123,7 @@ class HashModel
         check_field_names(value)
         @raw_data << value
       when Array
-        # It goes crazy if you don't clone the array before recursing
-        value.clone.each{ |member| self << member }
+        value.each{ |member| self << member }
       else
         raise SyntaxError, "You may only add a hash, another HashModel, or an array of either"
     end
@@ -152,7 +158,6 @@ class HashModel
   end
   alias :eql? :==
 
-
   # Remap spaceship to stop infinite loops
   alias :_spaceship_ :<=>
   private :_spaceship_
@@ -174,7 +179,6 @@ class HashModel
     end
   end
 
-
   ## Searching 
 
   # Tests flat or raw data depending of if you use flat or raw data
@@ -183,78 +187,17 @@ class HashModel
     @modified_data.include?(value) || @raw_data.include?(value)
   end
 
-  # Search creating a new instance of HashModel based on this one
-  def where(value=nil, &search)
-    self.clone.where!(value, &search)
-  end
-
-  # Search the flattened records using the default flatten index or a boolean block
-  def where!(value=nil, &search)
-    # Parameter checks
-    raise SyntaxError, "You may only provide a parameter or a block but not both" if value && !search.nil?
-    
-    # Allow clearing the filter and returning the entire recordset if nothing is given
-    if !value && search.nil?
-      @filter = nil
-      return flatten
-    end
-
-    # 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
-      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 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 { (.*) }$/)
-      end
-      string_search = match[1]
-    end # !value.nil?
-    
-    # Set and process the filter
-    @filter = string_search
-    flatten
-  end
-
-  # Return the other records created from the same raw data record as the one(s) searched for
-  def group(value=nil, &search)
-    self.clone.group!(value, &search)
-  end
-  
-  # Filter in place based on the parent record 
-  def group!(value=nil, &search)
-    # Filter the recordset if applicable
-    if !value.nil? || !search.nil?
-      where!(value, &search)
-    end
-    # Get all the unique group id's
-    group_ids = @modified_data.collect {|hash| hash[:_group_id]}.uniq
-    self.filter = "#{group_ids.to_s}.include? :_group_id"
-    flatten
-  end
-
-  # Find the raw data record for a given flat record
-  def parent(flat_record)
-    flatten
-    @raw_data[flat_record[:_group_id]]
+  # Find the raw data record based on the search criteria
+  def parents(index_search=nil, &block_search)
+    flat_records = where(index_search, &block_search)
+    flat_records.collect{|flat| @raw_data[flat[:_group_id]]}.uniq
   end
 
   # Set the array value for self to the flattened hashes based on the flatten_index
   def flatten
     # Don't flatten the data if we don't need to
-    return self if !dirty?
-    
+    return self unless dirty?
+
     id = -1
     group_id = -1
     @modified_data.clear
@@ -262,6 +205,17 @@ class HashModel
     @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")
+      proc_filter = "proc { #{proc_filter} }.call"
+    end
+    #dp "newfilter: #{proc_filter}"
+
+
     # Flatten and filter the raw data
     @raw_data.each do |record|
       new_records, duplicate_data = flatten_hash(record, flatten_index)
@@ -272,18 +226,11 @@ class HashModel
         # Double bangs aren't needed but are they more efficient?
         new_record.merge!( duplicate_data.merge!( { :_id=>(id+=1), :_group_id=>group_id } ) )
       end 
-      
-      # Change the filter so it looks for variables instead of symbols
-      unless @filter.nil?
-        proc_filter = @filter.clone
-        proc_filter.scan(/(:\S+) ==/).each {|match| proc_filter.sub!(match[0], match[0].sub(":","@"))}
-        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?
+        #dp "rec: #{new_record}"
+        unless @filter_proc.nil?
           flat = create_object_from_flat_hash(new_record)
           @modified_data << new_record if flat.instance_eval proc_filter
         else
@@ -310,42 +257,41 @@ class HashModel
   # Return an array of the flattened data
   def to_ary
     flatten
-    @modified_data.to_ary
+    @modified_data.clone.to_ary
   end
   
+  # Outputs the flattened data
   def to_a
     flatten
-    @modified_data.to_a
+    @modified_data.clone.to_a
   end
   
   # Iterate over the flattened records
   def each
     @modified_data.each  do |record| 
-      # change or manipulate the values in your value array inside this block
-      yield record
+       yield record
     end
   end
   
   # Convert a flat record into an unflattened record
-  def unflatten(input)
-    HashModel.unflatten(input)
+  def unflatten(flat_record)
+    HashModel.unflatten(flat_record)
   end
 
   # Convert a flat record into an unflattened record
-  def self.unflatten(input)
+  def self.unflatten(flat_record)
     # Seriously in need of a refactor, just looking at this hurts my brain
     # There's a lot of redundancy here.
-    case input
+    case flat_record
       when Hash
         new_record = {}
-        input.each do |key, value|
+        flat_record.each do |key, value|
           # recursively look for flattened keys
           keys = key.to_s.split("__", 2)
           if keys[1]
             key = keys[0].to_sym
             value = unflatten({keys[1].to_sym => value})
           end
-      
           # Don't overwrite existing value
           if (existing = new_record[key])
             # convert to array and search for subkeys if appropriate
@@ -382,11 +328,19 @@ class HashModel
         new_record
       when Array
         # recurse into array
-        input.collect! {|item| unflatten(item) }
+        flat_record.collect! {|item| unflatten(item) }
       else
-        input
+        flat_record
     end
   end
+
+  protected
+  
+  # Allows access to the internal filter, needed to make sure clones filter properly
+  def filter_proc=(filter)
+    @filter_proc = filter
+    flatten
+  end
   
   private
 
@@ -419,15 +373,15 @@ class HashModel
   end
 
   # Checks hash keys for reserved field names
-  def check_field_names(input)
-    case input
+  def check_field_names(argument_list)
+    case argument_list
       when Hash
-        input.each do |key, value|
+        argument_list.each do |key, value|
           raise ReservedNameError, "use of reserved name :#{key} as a field name." if [:_id, :_group_id].include?(key)
           check_field_names(value)
         end  
       when Array
-        input.clone.each { |record| check_field_names(record) }
+        argument_list.clone.each { |record| check_field_names(record) }
     end
   end
 
@@ -439,7 +393,7 @@ class HashModel
   # Create a hash based on internal values
   def get_current_dirty_hash
     # self.hash won't work
-    [@raw_data.hash, @filter.hash, @flatten_index.hash].hash
+    [@raw_data.hash, @filter_proc.hash, @flatten_index.hash].hash
   end
   
   # Recursively convert a single record into an array of new 
@@ -563,4 +517,20 @@ class HashModel
     end
   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>
+  def smart_clone(object)
+    # Stupid error trapping
+    begin
+      object.clone
+    rescue
+      object
+    end
+  end
+
 end # HashModel