hashmodel 0.2.0 → 0.3.0.beta1

data/.gitignore

@@ -0,0 +1,11 @@
+coverage
+rdoc
+doc
+.yardoc
+.bundle
+pkg
+.DS_Store
+*.tmproj
+tmtags
+vendor
+vendor/**/*

data/Gemfile

@@ -1,9 +1,2 @@
 source "http://rubygems.org"
-
-group :development do
-  gem "rspec"
-  gem "cucumber"
-  gem "bundler"
-  gem "jeweler"
-  gem "rcov"
-end
+gemspec

data/Gemfile.lock

@@ -1,3 +1,10 @@
+PATH
+  remote: .
+  specs:
+    hashmodel (0.3.0.beta1)
+      file-tail
+      sourcify
+
 GEM
   remote: http://rubygems.org/
   specs:
@@ -9,16 +16,11 @@ GEM
       json (~> 1.4.6)
       term-ansicolor (~> 1.0.5)
     diff-lcs (1.1.2)
+    file-tail (1.0.5)
+      spruz (>= 0.1.0)
     gherkin (2.3.3)
       json (~> 1.4.6)
-    git (1.2.5)
-    jeweler (1.5.2)
-      bundler (~> 1.0.0)
-      git (>= 1.2.5)
-      rake
     json (1.4.6)
-    rake (0.8.7)
-    rcov (0.9.9)
     rspec (2.4.0)
       rspec-core (~> 2.4.0)
       rspec-expectations (~> 2.4.0)
@@ -27,14 +29,24 @@ GEM
     rspec-expectations (2.4.0)
       diff-lcs (~> 1.1.2)
     rspec-mocks (2.4.0)
+    ruby2ruby (1.2.5)
+      ruby_parser (~> 2.0)
+      sexp_processor (~> 3.0)
+    ruby_parser (2.0.5)
+      sexp_processor (~> 3.0)
+    sexp_processor (3.0.5)
+    sourcify (0.4.0)
+      ruby2ruby (>= 1.2.5)
+      sexp_processor (>= 3.0.5)
+    spruz (0.2.2)
     term-ansicolor (1.0.5)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler
   cucumber
-  jeweler
-  rcov
+  file-tail
+  hashmodel!
   rspec
+  sourcify

data/README.markdown

@@ -11,43 +11,243 @@ model class take a look at ActiveModel, it's probably more of what you're lookin
 ## 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.
+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.
 
-You can also search using boolean like logic e.g.  
+Searches are very simple and logical. You can search using just using the value of the default index 
+
+    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  
+
+
+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}  
+    hm = HashModel.new(:raw_data=>records)  
+    found = hm.where {:switch == "-x" && :parameter__type == String}  => Returns an array of flattened records  
 
-## Usage
 
+## 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.
+
+## 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.
+
+### **Creating with an array of hashes**  
+    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"},  
+    ]  
+    hash_model = HashModel.new(:raw_data=>records)  
+
+    puts hash_model  
+    >> {: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=>"-y", :description=>"lucky what?", :_id=>2, :_group_id=>1}  
+    >> {:switch=>"--why", :description=>"lucky what?", :_id=>3, :_group_id=>1}  
+    >> {:switch=>"-z", :parameter=>{:type=>String}, :description=>"zee svitch zu moost calz", :_id=>4, :_group_id=>2}  
+
+### **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.
+
+### **Adding hashes after creation : <<, +, add, concat, push**  
+    hash_model = HashModel.new  
+    hash_model += records[0]
+    hash_model.concat records[1]
+    hash_model.push records[2]
+  
+  
+### **Adding another hash model**  
+    # You can also add another HashModel object to the existing one
+    # and it will add the raw records and reflatten.
+    records = [  
+      {:switch => ["-x", "--xtended"], :parameter => {:type => String, :require => true}, :description => "Xish stuff"},  
+      {:switch => ["-y", "--why"],  :description => "lucky what?"}
+    ]
+
+    records2 = {:switch => "-z",  :parameter => {:type => String}, :description => "zee svitch zu moost calz"}
+
+    hash_model = HashModel.new(:raw_data => records)
+    hash_model2 = HashModel.new(:raw_data => records2)
+
+    hash_model << hash_model2
+    # or
+    hash_model += hash_model2
+  
+    
+### **Accessing the raw data : raw\_data**  
+    # You can always edit and access the raw data via the raw_data property accessor
+    # When you make changes to the raw_data the HashModel will automatically be updated.
+    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) 
+    
+    puts hm.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"}  
+  	
+  
+### **Iterating over the HashModel : each**
+    # the HashModel acts a lot like an array so you can iterate over it
+    hash_model = HashModel.new(:raw_data=>records)  
+    hash_model.each do |record|
+      # record is a hash
+    end
+  
+  
+### **Flattening records : flatten_index**
+    # Flatten index is automatically set to the first field ever given
+    # but you can change it
+    hash_model = HashModel.new(:raw_data=>records)  
+		
+    puts hash_model.flatten_index
+    >> :switch
+    
+    # you can use flattened field names
+    hash_model.flatten_index = :parameter__type
+
+    puts hash_model.flatten_index
+    >> :parameter__type
+
+    puts hash_model
+    >> {:parameter__type=>String, :switch=>["-x", "--xtended"], :parameter__require=>true, :description=>"Xish stuff", :_id=>0, :_group_id=>0}
+    >> {:parameter__type=>nil, :switch=>["-y", "--why"], :description=>"lucky what?", :_id=>1, :_group_id=>1}
+    >> {:parameter__type=>String, :switch=>"-z", :description=>"zee svitch zu moost calz", :_id=>2, :_group_id=>2}
+
+    # Notice that records that don't have the flatten index field have that field added and the value is set to nil		
+		
+
+### **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")
+
+    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.
+    # 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)}
+
+    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}
+    >> {: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}}
+    
+    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.
+    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}
+    
+    puts group
+    >> {: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}
+    >> {:switch=>"-y", :description=>"lucky what?", :something=>7, :_id=>2, :_group_id=>1}
+    >> {:switch=>"--why", :description=>"lucky what?", :something=>7, :_id=>3, :_group_id=>1}
+
+
+### **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"}
+    
+    puts hm.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.)
+    deep_hash =  { 
+      :parameter__type=>String,
+      :switch__deep1__deep3 => "deepTwo",
+      :parameter__type__ruby=>true,
+      :parameter => "glorp",
+      :parameter__require=>true,
+      :switch__deep2 => "deepTwo",
+      :description=>"Xish stuff",
+      :switch => "--xtend",
+    }
+    unflat = HashModel.unflatten(deep_hash) 
+  
+    puts unflat
+    >> {:parameter=>[{:type=>String}, "glorp", {:require=>true}], :switch=>[{:deep1=>{:deep3=>"deepTwo"}}, {:deep2=>"deepTwo"}, "--xtend"], :description=>"Xish stuff"}
+  
 
 ## Version History
 
-0.2.0 
-* Fixed bug if first field name is shorter version of another field name, e.g. :short then :shorter would cause an error.
-* Added unflattening records and adding unflattened records.
-* Changed field separator to double underscores (to allow unflattening)
-* Removed namespace module, it was annoying. Now just instantiate it with HashModel.new instead of MikBe::HashModel.new
-* Now allows a single hash, instead of an array of hashes, when creating with HashModel.new(:raw_data => hash)
+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"}  
+* 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.
+* Added usage instructions.  
+* To do: Refactor some ugly code, more usage examples?
+
+0.2.0 - 2011.01.08  
+
+* Fixed bug if first field name is shorter version of another field name, e.g. :short then :shorter would cause an error.  
+* Added unflattening records and adding unflattened records.  
+* Changed field separator to double underscores (to allow unflattening)  
+* Removed namespace module, it was annoying. Now just instantiate it with HashModel.new instead of MikBe::HashModel.new  
+* Now allows a single hash, instead of an array of hashes, when creating with HashModel.new(:raw_data => hash)  
+
+0.1.1 - 2010.12.15   
+
+* Moved to proper RubyGems account  
+
+0.1.0 - 2010.12.15  
 
-0.1.1 Moved to new RubyGems account
+* Initial publish  
+* Released on wrong RubyGems account (yanked)
 
-0.1.0 Initial publish
 
-== Contributing to hash\_model
+##Contributing to HashModel
 
-* Please feel free to correct any mistakes I make by correcting the code and sending me a pull request. Pull requests are handled ASAP.
+* 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.
+* 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.
+* 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.
 

data/Rakefile

@@ -1,44 +1,2 @@
-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 = 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(:rspec) do |spec|
-  spec.pattern = FileList['spec/**/*_spec.rb']
-end
-
-require 'cucumber/rake/task'
-Cucumber::Rake::Task.new(:features)
-
-task :default => :rspec
-
-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
+Bundler::GemHelper.install_tasks

data/_brainstorm/block_wheres.rb

@@ -0,0 +1,80 @@
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+require 'hash_model'
+=begin
+
+  # 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
+
+
+
+records = [
+  {:switch => ["-x", "--xtended"], :parameter => {:type => String, :required => true}, :description => "Xish stuff", :something => 4},
+  {:switch => ["-y", "--why"],  :description => "lucky what?"},
+  {:switch => "-z",  :parameter => {:type => String, :required => true}, :description => "zee svitch zu moost calz", :something => 4},
+]
+hm = HashModel.new(:raw_data=>records)
+where = hm.where {:something == 4 && :parameter__type == String && :parameter__required == true}
+puts "\nWhere:"
+puts where
+
+
+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)
+where = hm.where {:parameter == {:type => String, :required => true}}
+puts "\nWhere:"
+puts where
+
+
+puts "\nflat object"
+flat = create_object_from_flat_hash(hm[0]) 
+puts flat.inspect
+=end
+
+puts "\nproc"
+xproc = proc {:parameter == {:type => String, :required => true} && :switch == ["-x", "--xtended"]}
+xproc_source = xproc.to_source
+puts "xproc: #{xproc_source}"
+
+matches = xproc_source.scan(/(\:\S+) ==/)
+
+puts "matches: #{matches}"
+puts "\nshow items"
+matches.each do |item|
+  puts "item: #{item}"
+end
+puts 'done'
+#"proc { #{@filter} }.call".gsub(":", "@")
+
+#x = "{:parameter == {:type => String, :required => true}, "
+#x.match
+
+puts "\nMatch test"
+text = "The future Ruby is Ruby"
+m1 = text.scan(/(Ruby)/)
+puts "m1: #{m1}"
+
+puts "\n\ndone"

data/_brainstorm/clone.rb

@@ -0,0 +1,19 @@
+x = ["x", "y", "z"]
+
+class Foo
+
+  attr_accessor :array
+  
+  def initialize(input)
+    @array = input
+  end
+  
+end
+
+
+
+f = Foo.new(x)
+
+x[0] = "change"
+
+puts f.array

data/_brainstorm/hash_model_examples.rb

@@ -0,0 +1,57 @@
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+require 'hash_model'
+require 'sourcify'
+
+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"},
+]
+
+=begin
+hash_model = HashModel.new(:raw_data=>records)
+
+records = [  
+  {:switch => ["-x", "--xtended"], :parameter => {:type => String, :require => true}, :description => "Xish stuff"},  
+  {:switch => ["-y", "--why"],  :description => "lucky what?"}
+]
+
+records2 = {:switch => "-z",  :parameter => {:type => String}, :description => "zee svitch zu moost calz"}
+
+hash_model = HashModel.new(:raw_data => records)
+hash_model2 = HashModel.new(:raw_data => records2)
+
+hash_model << hash_model2
+# or
+    hash_model += hash_model2
+
+
+		# Flatten index is automatically set to the first field ever given
+		# but you can change it
+    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"},  
+    ]  
+    hash_model = HashModel.new(:raw_data=>records)  
+		
+		puts hash_model.flatten_index
+		# you can use flattened field names
+		hash_model.flatten_index = :parameter__type
+		puts hash_model
+		
+		>> {:parameter__type=>String, :switch=>["-x", "--xtended"], :parameter__require=>true, :description=>"Xish stuff", :_id=>0, :_group_id=>0}
+    >> {:parameter__type=>nil, :switch=>["-y", "--why"], :description=>"lucky what?", :_id=>1, :_group_id=>1}
+    >> {:parameter__type=>String, :switch=>"-z", :description=>"zee svitch zu moost calz", :_id=>2, :_group_id=>2}
+
+    # Notice that records that don't have the flatten index have their value set to nil
+=end    
+    # The real strength of the class is its ability to search flattened fields
+    hash_model = HashModel.new(:raw_data=>records)  
+
+    # default is to use the flatten index
+    puts hash_model.where("-z")
+    
+    # but you can also use a block with boolean search parameters
+    # You must write the field names as @variables instead of symbols
+    puts hash_model.where {@parameter_type}

data/_brainstorm/proc_tests.rb

@@ -0,0 +1,14 @@
+require 'sourcify'
+@x = "x"
+@y = "y"
+
+search = proc{:x == "x" && :y == "y"}
+
+@filter = search.to_source.match(/^proc { \((.*)\) }$/)[1]
+puts "new_search: \"#{@filter}\""
+puts "\nRun Eval"
+puts instance_eval("proc { (#{@filter}) }.call".gsub(":", "@"))
+
+
+
+

data/_brainstorm/regex_captures.rb

@@ -0,0 +1,18 @@
+string = "My phone number is (123) 555-1234."  
+phone_re = /\((\d{3})\)\s+(\d{3})-(\d{4})/  
+m = phone_re.match(string)  
+unless m  
+  puts "There was no match..."  
+  exit  
+end  
+print "The whole string we started with: "  
+puts m.string  
+print "The entire part of the string that matched: "  
+puts m[0]  
+puts "The three captures: "  
+m.captures.each do |cap|  
+  puts "Capture ##{cap}"  
+end  
+puts "Here's another way to get at the first capture:"  
+print "Capture #1: "  
+puts m[1]  

data/_brainstorm/unflat.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path(File.join(File.dirname(__FILE__), "/../lib"))
+require 'hash_model'
+
+  deep_hash =  { 
+    :parameter__type=>String,
+    :switch__deep1__deep3 => "deepTwo",
+    :parameter__type__ruby=>true,
+    :parameter => "glorp",
+    :parameter__require=>true,
+    :switch__deep2 => "deepTwo",
+    :description=>"Xish stuff",
+    :switch => "--xtend",
+  }
+  unflat = HashModel.unflatten(deep_hash) 
+  
+  puts unflat

data/autotest/discover.rb

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

data/features/README

@@ -6,4 +6,4 @@ The Cucumber methodologies don't seem to be necessary most of the time since
 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.
+Oh, plus my feature specs suck... I'm still learning.

data/hashmodel.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "hash_model/version"
+
+Gem::Specification.new do |s|
+  s.name        = "hashmodel"
+  s.version     = HashModel::VERSION::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Mike Bethany"]
+  s.email       = ["mikbe.tk@gmail.com"]
+  s.homepage    = "http://github.com/mikbe/hashmodel"
+  s.summary     = %q{Store small amounts of dynamic data and easily search fields (even nested ones)}
+  s.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.}
+
+  s.add_dependency "sourcify"
+  s.add_dependency "file-tail"
+  
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "cucumber"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/hash_model.rb

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

data/lib/hash_model/hash_model.rb

@@ -1,3 +1,4 @@
+require 'sourcify'
 # A simple MVC type model class for storing hashes as flattenable, searchable records
 class HashModel
   include Enumerable
@@ -14,7 +15,7 @@ class HashModel
 
     # 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?
     
     # Setup the flat data
@@ -24,7 +25,7 @@ class HashModel
 
   ## Properties
 
-  attr_accessor :flatten_index, :raw_data
+  attr_accessor :flatten_index, :raw_data, :filter
 
   # Sets field name used to flatten the recordset
   def flatten_index=(value)
@@ -37,6 +38,11 @@ class HashModel
     !!@filter
   end
 
+  def filter=(filter)
+    @filter = filter
+    flatten
+  end
+
   # Trap changes to raw data so we can re-flatten the data
   def raw_data=(value)
     value = [] if value.nil?
@@ -72,6 +78,13 @@ class HashModel
     @filter = nil
   end
 
+  # Force arrays to be cloned
+  def clone
+    hm = HashModel.new(:raw_data=>@raw_data.clone)
+    hm.flatten_index = @flatten_index
+    hm.filter = @filter
+    hm
+  end
 
   ## Operators
   
@@ -159,7 +172,7 @@ class HashModel
     self.clone.where!(value, &search)
   end
 
-  # Search the flattened records using a 
+  # 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?
@@ -171,48 +184,45 @@ class HashModel
     end
 
     # If given a parameter make our own search based on the flatten index
-    if !value.nil?
+    unless 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
+      if value.class == String
+        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
+      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 = search
+    @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)
-    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[:_group_id]}.uniq
-    
-    # Find any records with matching group ids
-    where {group_ids.include? @_group_id}
+    self.clone.group!(value, &search)
   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
+  # 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
-
-    # Find any records with matching group ids
-    where! {group_ids.include? @_group_id}
+    self.filter = "#{group_ids.to_s}.include? :_group_id"
+    flatten
   end
 
   # Find the raw data record for a given flat record
@@ -244,10 +254,23 @@ class HashModel
         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| 
-        @modified_data << new_record if @filter.nil? ? true : (create_object_from_flat_hash(new_record).instance_eval &@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
+        else
+          @modified_data << new_record
+        end
       end
+
     end # raw_data.each
     set_dirty_hash
     self
@@ -340,7 +363,6 @@ class HashModel
   
   private
 
-
   # Convert a hash of multiple key/value pairs to an array of single hashes.
   # {:field1 => "value1", :field2 => "value2"}
   # becomes

data/lib/hash_model/version.rb

@@ -1,9 +1,9 @@
 class HashModel
   module VERSION # :nodoc:
     MAJOR  = 0
-    MINOR  = 2
+    MINOR  = 3
     TINY   = 0
-    PRE    = nil
+    PRE    = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join('.')
 

data/spec/hash_model/hash_model_spec.rb

@@ -632,6 +632,61 @@ describe "HashModel" do
     
     end # not in place
 
+    context "using blocks" do
+      
+      it "should search using a single value boolean block" do
+        @hm.where {:switch == "-x"}.should == [@flat_records[0]]
+      end
+
+      it "should search using a complex boolean block" do
+        records = [
+          {:switch => ["-x", "--xtended"], :parameter => {:type => String, :required => true}, :description => "Xish stuff", :something => 4},
+          {:switch => ["-y", "--why"],  :description => "lucky what?"},
+          {:switch => "-z",  :parameter => {:type => String, :required => true}, :description => "zee svitch zu moost calz", :something => 4},
+        ]
+        @hm = HashModel.new(:raw_data=>records)
+        @hm.where {:something == 4 && :parameter__required == true}.should == [
+          {: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},
+          {:switch=>"-z", :parameter=>{:type=>String, :required=>true}, :description=>"zee svitch zu moost calz", :something=>4, :_id=>4, :_group_id=>2}
+        ]
+        @hm.where {:parameter__type == String && :parameter__required == true && :something == 4}.should == [
+          {: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},
+          {:switch=>"-z", :parameter=>{:type=>String, :required=>true}, :description=>"zee svitch zu moost calz", :something=>4, :_id=>4, :_group_id=>2}
+        ]
+      end
+
+      it "should search using a complex, multi-line boolean block" do
+        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)
+        @hm.where {(:parameter__type == String && :parameter__required == true && :something == 4) || :something == 7}.should == [
+          {: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}, 
+          {:switch=>"-y", :description=>"lucky what?", :something=>7, :_id=>2, :_group_id=>1}, 
+          {:switch=>"--why", :description=>"lucky what?", :something=>7, :_id=>3, :_group_id=>1}
+        ]
+      end
+    
+      it "should search with nested hashes in a block" do
+        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)
+        @hm.where {:parameter == {:type => String, :required => true}}.should == [
+          {: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}
+        ]
+      end
+      
+    end
+
     it "should return false if tested for inclusion of anything other than a hash" do
       @hm.include?([:switch=>"-x"]).should == false
     end
@@ -691,17 +746,45 @@ describe "HashModel" do
       end 
     
       it "should return the records in the same raw data record when using a block" do
-        @hm.group{@switch == "-y"}.should == [@flat_records[2], @flat_records[3]]
+        @hm.group{:switch == "-y"}.should == [@flat_records[2], @flat_records[3]]
       end
     
-      it "should work across group_id's if searching for something that returns records from multiple groups" do
-        @hm.group{@parameter__type == String}.should == [
+      it "should group across group_id's if searching for something that returns records from multiple groups" do
+        @hm.group{:parameter__type == String}.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 => "-z",  :parameter => {:type => String}, :description => "zee svitch zu moost calz", :_id=>4, :_group_id=>2}
         ]
       end
     
+      it "should group with a complex block" do
+        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)
+        @hm.group {(:parameter__type == String && :parameter__required == true && :something == 4) || :something == 7}.should == [
+          {: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}, 
+          {:switch=>"-y", :description=>"lucky what?", :something=>7, :_id=>2, :_group_id=>1}, 
+          {:switch=>"--why", :description=>"lucky what?", :something=>7, :_id=>3, :_group_id=>1}
+        ]
+      end
+    
+      it "should group with nested hashes block" do
+        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)
+        @hm.group {:parameter == {:type => String, :required => true}}.should == [
+          {: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}
+        ]
+      end
+    
     end # not in place
     
     context "in place" do

data/spec/spec_helper.rb

@@ -21,3 +21,15 @@ def create_proc_tester(property_value_hash)
 
   proc_test
 end
+
+
+# Debug print
+module Kernel
+  def dp(value)
+    puts ""
+    puts "*" * 40
+    puts "value: #{value}"
+    puts "&" * 40
+    puts ""
+  end
+end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hashmodel
 version: !ruby/object:Gem::Version 
-  prerelease: false
+  prerelease: true
   segments: 
   - 0
-  - 2
+  - 3
   - 0
-  version: 0.2.0
+  - beta1
+  version: 0.3.0.beta1
 platform: ruby
 authors: 
 - Mike Bethany
@@ -14,11 +15,12 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-08 00:00:00 -05:00
+date: 2011-01-09 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: sourcify
+  prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -27,11 +29,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
-  prerelease: false
+  type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: cucumber
+  name: file-tail
+  prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -40,11 +42,11 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  type: :development
-  prerelease: false
+  type: :runtime
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: bundler
+  name: rspec
+  prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -54,10 +56,10 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: jeweler
+  name: cucumber
+  prerelease: false
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -67,43 +69,36 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  prerelease: false
   version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: rcov
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        version: "0"
-  type: :development
-  prerelease: false
-  version_requirements: *id005
 description: 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.
-email: mikbe.tk@gmail.com
+email: 
+- mikbe.tk@gmail.com
 executables: []
 
 extensions: []
 
-extra_rdoc_files: 
-- LICENSE.txt
-- README.markdown
+extra_rdoc_files: []
+
 files: 
 - .document
+- .gitignore
 - .rspec
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.markdown
 - Rakefile
+- _brainstorm/block_wheres.rb
+- _brainstorm/clone.rb
+- _brainstorm/hash_model_examples.rb
 - _brainstorm/hash_test.rb
 - _brainstorm/instance_vars.rb
+- _brainstorm/proc_tests.rb
 - _brainstorm/ref_val.rb
+- _brainstorm/regex_captures.rb
 - _brainstorm/spliting.rb
 - _brainstorm/test.rb
+- _brainstorm/unflat.rb
 - autotest/discover.rb
 - features/README
 - features/hash_model_flatten.feature
@@ -112,6 +107,7 @@ files:
 - features/step_definitions/hash_model_steps.rb
 - 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
@@ -132,18 +128,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -189604924885672181
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: 
@@ -152,5 +149,12 @@ signing_key:
 specification_version: 3
 summary: Store small amounts of dynamic data and easily search fields (even nested ones)
 test_files: 
+- features/README
+- features/hash_model_flatten.feature
+- features/hash_model_grouping.feature
+- features/hash_model_search.feature
+- features/step_definitions/hash_model_steps.rb
+- features/support/env.rb
+- features/support/helper.rb
 - spec/hash_model/hash_model_spec.rb
 - spec/spec_helper.rb