hashmodel 0.1.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,14 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "rspec", ">= 2.2.0"
+  gem "cucumber", ">= 0.10.0"
+  gem "bundler", ">= 1.0.0"
+  gem "jeweler", ">= 1.5.0.pre5"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,41 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    builder (3.0.0)
+    cucumber (0.10.0)
+      builder (>= 2.1.2)
+      diff-lcs (~> 1.1.2)
+      gherkin (~> 2.3.2)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    diff-lcs (1.1.2)
+    gherkin (2.3.2)
+      json (~> 1.4.6)
+      term-ansicolor (~> 1.0.5)
+    git (1.2.5)
+    jeweler (1.5.1)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    json (1.4.6)
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (2.2.0)
+      rspec-core (~> 2.2)
+      rspec-expectations (~> 2.2)
+      rspec-mocks (~> 2.2)
+    rspec-core (2.2.1)
+    rspec-expectations (2.2.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.2.0)
+    term-ansicolor (1.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (>= 1.0.0)
+  cucumber (>= 0.10.0)
+  jeweler (>= 1.5.0.pre5)
+  rcov
+  rspec (>= 2.2.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Mike Bethany
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,44 @@
+# 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.
+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.
+
+## Synopsis
+
+The major usefulness of this class is it allows you to filter and search flattened records based on any field.
+A field can contain anything, including another hash, a string, and array, or even an Object class like String or Array, not
+just an instance of an Object class.
+
+You can also search using boolean like logic e.g.  
+   
+@hm = HashModel.new(:raw\_data=>@records)  
+found = @hm.where {@switch == "-x" && @parameter\_type == String}  
+
+## Usage
+
+Coming soon...
+
+For now take a look at the spec files to see simple examples of how to use the HashModel
+
+
+
+== Contributing to hash\_model
+
+* Please feel free to correct any mistakes I make by correcting the code and sending me a pull request. 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
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project  
+* Start a feature/bugfix branch  
+* Commit and push until you are happy with your contribution  
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. 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 (c) 2010 Mike Bethany. See LICENSE.txt for further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require './lib/hash_model/version'
+version = MikBe::HashModel::VERSION::STRING
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "hashmodel"
+  gem.version = version
+  gem.summary = %Q{Store small amounts of dynamic data and easily search fields (even nested ones)}
+  gem.description = %Q{A simple MVC type model class for storing records as an array of hashes. You can store deeply nested hashes and still easily flatten and querying the records using flattened field names.}
+  gem.email = "mikbe.tk@gmail.com"
+  gem.homepage = "http://github.com/mikbe/hashmodel"
+  gem.authors = ["Mike Bethany"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features)
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "hash_model #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/autotest/discover.rb

@@ -0,0 +1,3 @@
+Autotest.add_discovery {"rspec2"}
+#Autotest.add_discovery {"cucumber"}
+#AUTOFEATURE=true

data/features/README

@@ -0,0 +1,9 @@
+These features really only make sense to write when I'm trying to figure out what
+functionality I want to add. When I already know it just seems redundant to do it
+here since this app is such a low level library.
+
+The Cucumber methodologies don't seem to be necessary most of the time since I
+RSpec seems to be a more natural fit for a programming library. I'm probably
+wrong but it really does seem to be a lot of redundancy for this application.
+
+Oh, plus they suck... I'm still learning.

data/features/hash_model_flatten.feature

@@ -0,0 +1,34 @@
+Feature: Flatten the HashModel
+  In order to customize looping over the HashModel records
+  As a programmer
+  I want to be able to flatten the HashModel to one field
+  Or flatten all fields
+
+Background:
+	Given we have a test table
+		 | switch                      | description                           |
+		 | :switch=>["-x","--xtended"] | :description=>"This is a description" |
+		 | :switch=>"-y"               | :description=>"Why not?"              |
+		 | :switch=>["-z","--zee"]     | :description=>"head for zee hills"    |
+
+Scenario: Create a HashModel
+	Given we have a HashModel instance
+	 When the HashModel is populated with the test table 
+   Then the flatten index should be :switch
+
+Scenario: Change the flatten index
+  Given we have a HashModel instance
+	 When the HashModel is populated with the test table 
+	  And the flatten index is set to :description
+	 Then the flatten index should be :description
+
+Scenario: Flatten input hashes to the default flatten index
+  Given we have a HashModel instance
+   When the HashModel is populated with the test table 
+   Then the HashModel recordset should look like
+	 | id        | group_id         | switch               | description                           |
+	 | :hm_id=>0 | :hm_group_id=> 0 | :switch=>"-x"        | :description=>"This is a description" |
+	 | :hm_id=>1 | :hm_group_id=> 0 | :switch=>"--xtended" | :description=>"This is a description" |
+	 | :hm_id=>2 | :hm_group_id=> 1 | :switch=>"-y"        | :description=>"Why not?"              |
+	 | :hm_id=>3 | :hm_group_id=> 2 | :switch=>"-z"        | :description=>"head for zee hills"    |
+	 | :hm_id=>4 | :hm_group_id=> 2 | :switch=>"--zee"     | :description=>"head for zee hills"    |

data/features/hash_model_grouping.feature

@@ -0,0 +1,18 @@
+Feature: Return the siblings of a flattened record
+  In order to identify all the records created from a single raw record
+  As a programmer
+  I want to easily retrieve any records within the same group as a flattened record.	
+
+
+Background:
+	Given we have a test table
+		 | switch                      | description                           |
+		 | :switch=>["-x","--xtended"] | :description=>"This is a description" |
+		 | :switch=>"-y"               | :description=>"Why not?"              |
+		 | :switch=>["-z","--zee"]     | :description=>"head for zee hills"    |
+  
+Scenario: Get siblings for a record
+Given we have a HashModel instance
+ When the HashModel is populated with the test table 
+  And the siblings are retrieved for a record with parameter "-y"
+ Then all the siblings should have the same group id 

data/features/hash_model_search.feature

@@ -0,0 +1,34 @@
+Feature: Search a HashModel using boolean logic
+  In order to find records of interest
+  As a programmer
+  I want to specify an SQL like query string using boolean logic like:
+  (something == "something" && something_else == 11) || more_stuff != String || extra_stuff.class == Potato
+
+Background:
+	Given we have a test table
+		 | switch                      | description                           |
+		 | :switch=>["-x","--xtended"] | :description=>"This is a description" |
+		 | :switch=>"-y"               | :description=>"Why not?"              |
+		 | :switch=>["-z","--zee"]     | :description=>"head for zee hills"    |
+
+Scenario: Search using a parameter
+  Given we have a HashModel instance
+	  And the HashModel is populated with the test table 
+   When we search with the single parameter "-x"
+   Then the search recordset should look like
+	 | id        | group_id         | switch        | description                           |
+	 | :hm_id=>0 | :hm_group_id=> 0 | :switch=>"-x" | :description=>"This is a description" |
+
+@active
+Scenario: Search using a block of boolean logic
+  Given we have a HashModel instance
+	  And the HashModel is populated with the test table 
+   When we search with the block {@switch == "-x"}
+   Then the search recordset should look like
+	 | id        | group_id         | switch        | description                           |
+	 | :hm_id=>0 | :hm_group_id=> 0 | :switch=>"-x" | :description=>"This is a description" |
+
+
+
+
+  

data/features/step_definitions/hash_model_steps.rb

@@ -0,0 +1,60 @@
+Given /^we have a test table$/ do |table|
+  @test_table = table
+end
+
+Given /^we have a HashModel instance$/ do
+  @hm = MikBe::HashModel.new
+end
+
+When /^the HashModel is populated with the test table$/ do
+  @test_table.rows.each do |record|
+    @hm.add(array_to_hash(record))
+  end
+end
+
+Then /^the flatten index should be :(.*)$/ do |index|
+  @hm.flatten_index.should == index.to_sym
+end
+
+When /^the flatten index is set to :(.*)$/ do |index|
+  @hm.flatten_index = index.to_sym
+end
+
+Then /^the flatten index should be nil$/ do
+  @hm.flatten_index.should == nil
+end
+
+Then /^the HashModel recordset should look like$/ do |example_table|
+  formatted_table = table_to_array(example_table)
+  @hm.should == formatted_table
+end
+
+When /^the siblings are retrieved for a record with parameter "([^"]*)"$/ do |parameter|
+  @siblings = @hm.group("#{parameter}")
+end
+
+Then /^all the siblings should have the same group id$/ do
+  group_ids = []
+  @siblings.each {|record| group_ids << record[:hm_group_id]}
+  group_ids.uniq.length.should == 1
+  group_ids.uniq[0].should_not == nil
+end
+
+When /^we search with the single parameter "([^"]*)"$/ do |parameter|
+  @hm_search = @hm.where(parameter)
+end
+
+When /^we search with the block \{@switch == \"-x\"\}$/ do
+  # I know, this is sloppy, I'm just trying to define the basic functionality
+  # Real tests are in the RSpecs
+  @hm_search = @hm.where{@switch == "-x"}
+end
+
+
+Then /^the search recordset should look like$/ do |table|
+  test_table = table_to_array(table)
+  @hm_search.each_with_index do |record, index|
+    record.should == test_table[index]
+  end
+   
+end

data/features/support/env.rb

@@ -0,0 +1,14 @@
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'hash_model'
+require 'rspec/expectations'
+
+# load helper functions

data/features/support/helper.rb

@@ -0,0 +1,18 @@
+module HashModelHelpers
+  # converts ugly arrays from Cucumber::AST::Tables into nice neat hashes
+  def array_to_hash(array)
+    hash = {}
+    array.each { |field| eval("hash.merge!({#{field}})") }
+    hash
+  end
+  
+  # wrapper for converting Cucumber::AST::Tables into an array of nice neat hashes 
+  def table_to_array(input_table)
+    table_of_hashes = []
+    input_table.rows.each do |record|
+      table_of_hashes << array_to_hash(record)
+    end
+    table_of_hashes
+  end
+end
+World(HashModelHelpers)

data/lib/hash_model.rb

@@ -0,0 +1,4 @@
+$: << '.'
+require 'hash_model/hash_model'
+require 'hash_model/exceptions'
+require 'hash_model/version'

data/lib/hash_model/exceptions.rb

@@ -0,0 +1,5 @@
+module MikBe
+  
+  class ReservedNameError < StandardError ; end
+  
+end

data/lib/hash_model/hash_model.rb

@@ -0,0 +1,411 @@
+# Pickle Pumpers namespace
+module MikBe
+  
+  # A simple MVC type model class for storing hashes as flattenable, searchable records
+  class HashModel
+    include Enumerable
+     
+    def initialize(parameters={})
+      # Initialize variables
+      clear
+
+      # Map Array methods
+      mimic_methods
+      
+      # Set values given as hashes
+      parameters.each { |key,value| instance_variable_set("@#{key}", value) }
+
+      check_field_names(@raw_data) if !@raw_data.empty?
+      
+      # Setup the flat data
+      flatten
+      
+    end
+ 
+    ## Properties
+
+    attr_accessor :flatten_index, :raw_data
+
+    # Sets field name used to flatten the recordset
+    def flatten_index=(value)
+      @flatten_index = value
+      flatten
+    end
+  
+    # Are the records being filtered?
+    def filtered?
+      !!@filter
+    end
+
+    # Trap changes to raw data so we can re-flatten the data
+    def raw_data=(value)
+      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
+    end
+
+
+    ## Public Methods 
+
+    # Freeze the raw data
+    def freeze
+      @raw_data.freeze
+      @modified_data.freeze
+      @flatten_index.freeze
+      @filter.freeze
+      super
+    end
+    
+    # Remove the where filter
+    def clear_filter
+      @filter = nil
+      flatten
+    end
+    alias :clear_where :clear_filter # in case this makes more sense to people
+    
+    # Reset the HashModel
+    def clear
+      @raw_data = []
+      @modified_data = []
+      @flatten_index = nil
+      @filter = nil
+    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.
+    def <<(value)
+      case value
+        when HashModel
+          @raw_data.concat(value.raw_data)
+        when Hash
+          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 }
+        else
+          raise SyntaxError, "You may only add a hash, another HashModel, or an array of either"
+      end
+      flatten
+    end
+    # I like the method name "add" for adding to recordsets seems more natural
+    alias :add :<<
+    alias :concat :<<
+    alias :push :<<
+    
+    # remap... no loops... you know the deal
+    alias :_equals_ :==
+    
+    # Compare values with the HashModel based on the type of values given
+    def ==(value)
+      flatten
+      case value
+        when HashModel
+          @raw_data       == value.raw_data &&
+          @flatten_index  == value.flatten_index &&
+          @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?(:hm_group_id)
+            @modified_data == value
+          else
+            @raw_data == value
+          end
+        else
+          false
+      end
+    end
+    alias :eql? :==
+
+
+    # Remap spaceship to stop infinite loops
+    alias :_spaceship_ :<=>
+    private :_spaceship_
+    
+    # Spaceship - Don't probe me bro'!
+    def <=>(value)
+      case value
+        when HashModel
+          _spaceship_(value)
+        when Array
+          # test for a flattened recordset or raw data
+          if !value.empty? && value[0].has_key?(:hm_group_id)
+            @modified_data <=> value
+          else
+            @raw_data <=> value
+          end
+        else
+          nil
+      end
+    end
+
+
+    ## Searching 
+
+    # Tests flat or raw data depending of if you use flat or raw data
+    def include?(value)
+      return false if value.class != Hash
+      @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 a 
+    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
+      if !value.nil?
+        # Make sure the field name is available to the proc
+        flatten_index = @flatten_index 
+        search = proc do
+          instance_variable_get("@#{flatten_index}") == value
+        end # search
+      end # !value.nil?
+      
+      # Set and process the filter
+      @filter = 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)
+      if !value.nil? || !search.nil?
+        sibling = where(value, &search)
+      else
+        sibling = where &@filter
+      end
+      
+      # Get all the unique group id's
+      group_ids = sibling.collect {|hash| hash[:hm_group_id]}.uniq
+      
+      # Find any records with matching group ids
+      where {group_ids.include? @hm_group_id}
+    end
+    
+    # Group the records in place based on the existing filter
+    # This is basically a short hand for filtering based on
+    # group ids of filtered records
+    def group!(value=nil, &search)
+      
+      if !value.nil? || !search.nil?
+        where!(value, &search)
+      end
+      
+      # Get all the unique group id's
+      group_ids = @modified_data.collect {|hash| hash[:hm_group_id]}.uniq
+
+      # Find any records with matching group ids
+      where! {group_ids.include? @hm_group_id}
+    end
+
+    # Find the raw data record for a given flat record
+    def parent(flat_record)
+      flatten
+      @raw_data[flat_record[:hm_group_id]]
+    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?
+      
+      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
+
+      # 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!( { :hm_id=>(id+=1), :hm_group_id=>group_id } ) )
+        end 
+        
+        # Add the records to modified data if they pass the filter
+        new_records.each do |new_record| 
+          @modified_data << new_record if @filter.nil? ? true : (create_object_from_flat_hash(new_record).instance_eval &@filter)
+        end
+      end # raw_data.each
+      set_dirty_hash
+      self
+    end # flatten
+    
+    # If the hash_model has been changed but not flattened
+    def dirty?
+      get_current_dirty_hash != @dirty_hash
+    end
+
+    # Return a string consisting of the flattened data
+    def to_s
+      @modified_data.to_s
+    end
+
+    # Return an array of the flattened data
+    def to_ary
+      @modified_data.to_ary
+    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
+      end
+    end
+    
+    private
+
+    # Checks hash keys for reserved field names
+    def check_field_names(input)
+      case input
+        when Hash
+          input.each do |key, value|
+            raise ReservedNameError, "use of reserved name :#{key} as a field name." if [:hm_id, :hm_group_id].include?(key)
+            check_field_names(value)
+          end  
+        when Array
+          input.clone.each { |record| check_field_names(record) }
+      end
+    end
+
+    # Save a hash for later evaluation
+    def set_dirty_hash
+      @dirty_hash = get_current_dirty_hash
+    end
+    
+    # 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
+    end
+    
+    # Recursively convert a single record into an array of new 
+    # records that are flattened based on the given flattened hash key
+    # e.g. {:x=>{:x1=>1}, :y=>{:y1=>{:y2=>2,:y3=>4}, y4:=>5}, :z=>6}
+    # if you wanted to flatten to :x1 you would set flatten_index to :x_x1
+    # To flatten to :y2 you would set flatten_index to :y_y1_y2
+    def flatten_hash(input, flatten_index, recordset=[], duplicate_data={}, parent_key=nil)
+      case input
+        when Hash
+          # Check to see if the found key is on this level - We need to add duplicate data differently if so
+          found_key = (input.select { |key, value| flatten_index == "#{parent_key}#{"_" if !parent_key.nil?}#{key}"} != {})
+          
+          # Add records for matching flatten fields and save duplicate record data for later addition to each record.
+          input.each do |key, value|
+            flat_key = "#{parent_key}#{"_" if !parent_key.nil?}#{key}"
+            flat_key_starts_with_flatten_index = flat_key.start_with?(flatten_index) 
+            flatten_index_starts_with_flat_key = flatten_index.start_with?(flat_key)
+            # figure out what we need to do based on where we're at in the record's value tree and man does it look ugly
+            if flat_key == flatten_index
+              # go deeper
+              recordset, duplicate_data = flatten_hash(value, flatten_index, recordset, duplicate_data, flat_key)
+            elsif flat_key_starts_with_flatten_index && !flatten_index_starts_with_flat_key
+              # new record
+              recordset << {parent_key.to_sym=>{key=>value}}
+            elsif !flat_key_starts_with_flatten_index && flatten_index_starts_with_flat_key
+              # go deeper
+              recordset, duplicate_data = flatten_hash(value, flatten_index, recordset, duplicate_data, flat_key)
+            elsif found_key
+              # add to dup data for same level as flatten index
+              duplicate_data.merge!(flat_key.to_sym=>value)
+            else
+              # add to dupe data
+              duplicate_data.merge!(key=>value)
+            end            
+          end # input.each
+        when Array
+          input.each do |value|
+            recordset, duplicate_data = flatten_hash(value, flatten_index, recordset, duplicate_data, parent_key)
+          end
+        else
+          recordset << {parent_key.to_sym=>input}
+      end # case
+       return recordset, duplicate_data
+    end # flatten_hash
+
+    # Creates an object with instance variables for each field at every level
+    # This allows using a block like {:field1==true && :field2_subfield21="potato"}
+    def create_object_from_flat_hash(record, hash_record=Class.new.new, parent_key=nil)
+    
+      # Iterate through the record creating the object recursively
+      case record
+        when Hash
+          record.each do |key, value|
+            flat_key = "#{parent_key}#{"_" if !parent_key.nil?}#{key}"
+            hash_record.instance_variable_set("@#{flat_key}", value)
+            hash_record = create_object_from_flat_hash(value, hash_record, flat_key)
+          end
+        when Array
+          record.each do |value|
+            hash_record = create_object_from_flat_hash(value, hash_record, parent_key)
+          end
+        else
+          hash_record.instance_variable_set("@#{parent_key}", record)
+      end # case
+      
+      hash_record
+    end # create_object_from_flat_hash
+
+    # Deal with the array methods allowing multiple functions to use the same code
+    # You couldn't do this with alias because you can't tell what alias is used.
+    #
+    # My rule for using this vs a seperate method is if I can use the
+    # same code for more than one method it goes in here, if the method
+    # only works for one method then it gets its own method.
+    def wrapper_method(method, *args, &block)
+      # grab the raw data if it's a hashmodel
+      case method
+        when :[], :each_index, :uniq, :last, :collect, :length, :at, :map, :combination, :count, :cycle, :empty?, :fetch, :index, :first, :permutation, :size, :values_at
+          flatten
+          @modified_data.send(method, *args, &block)
+        when :+, :*
+          case args[0]
+            when HashModel
+              args = [args[0].raw_data]
+            when Hash
+              args = [args]
+          end
+          clone = self.clone
+          clone.raw_data = clone.raw_data.send(method, *args, &block)
+          clone.flatten
+        else
+          raise NoMethodError, "undefined method `#{method}' for #{self}"
+      end
+    end
+  
+    # create methods like the given object so we can trap them
+    def mimic_methods
+      Array.new.public_methods(false).each do |method|
+        # Don't mimic methods we specifically declare or methods that don't make sense for the class
+        if !self.respond_to?(method)
+          self.class.class_eval do
+            define_method(method) { |*args, &block| wrapper_method(method, *args, &block) }
+          end
+        end
+      end
+    end
+
+  end # HashModel
+  
+end # MikBe