doeskeyvalue 0.1.0

data/.document

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

data/Gemfile

@@ -0,0 +1,13 @@
+# AWEXOME LABS
+# Gemfile
+
+source "http://rubygems.org"
+
+# Runtime dependencies:
+
+
+# Development dependencies:
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+end

data/Gemfile.lock

@@ -0,0 +1,16 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Awexome Labs, LLC
+
+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.rdoc

@@ -0,0 +1,98 @@
+= DoesKeyValue
+
+Bring the fun of NoSQL into your SQL-backed Active Record objects in a compartmentalized way. Turns 
+any text field on your objects into a schema-less key value store.
+
+
+== Installation
+
+Do the usual, of course:
+
+  gem install doeskeyvalue
+
+And add a gem dependency to your Gemfile:
+
+  gem "doeskeyvalue", ">=0.0.1"
+
+
+== Example (TODO: Update this with new API)
+
+To add document_fields to your ActiveRecord object, first add a text column to your class' backing table that will hold your document content. By default, do_document_fields will expect this column to be named "document", but you can override that easily.
+
+Once you've migrated that change into your model, here's a sample of hold to add document-style blob fields to your object:
+
+  class ObjectWithBlob < ActiveRecord::Base
+
+    # Declare that we are using document blobs in a particular column of this object:
+    do_document_fields
+
+    # Declare the columns we are adding to our document:
+    document_field :name, String
+    document_field :phone, String
+    document_field :age, Integer
+
+    # Declare the document fields you'd like to track with indexes:
+    document_index :name
+
+
+    # If we wanted to change the name of the column in which we store the document, we'd do this:
+    # do_document_fields :something_other_than_document. Like so:
+    
+    do_document_fields :settings
+    
+    # Changing the name of the column gives you a specifically-formatted field-definition method:
+    
+    settings_field :age
+    settings_field :sex
+    settings_field :location
+    
+    # This also provides a customized way to index:
+    
+    settings_index :location
+
+  end
+
+
+Now, you can add and remove new fields to this object within the document as simply as adding or removing declarations of "document_field".
+
+
+Once you've added any indices to your model's fields, you'll want to be sure to build your supporting index tables. We use separate tables with database-level indexing to support indexed lookups of data in your document_field attributes. Build these tables by running this rake task:
+
+  rake db:migrate:document_indexes
+
+
+Now, you can use strictly-provided finders to find your objects by their document field attributes. Considering the model we described above, you can lookup by any *indexed* field like so:
+
+  obj = ObjectWithBlob.find_by_name("Charlie")
+  => [#<ObjectWithBlob id: 412, document: {:name=>"Charlie", :phone=>"212-555-1234", :age=>34}, created_at: "2010-03-22 20:49:03", updated_at: "2010-03-22 20:49:03">]
+
+Finders are only added to document fields that are indexed. Finders also are all "find_all" lookups on equality.
+
+If you'd like to use special sub-searching within any of your document-formatted fields, you can use the hash-based search conditions. Given the "settings" document declared in the example above, we can now also do this:
+
+  obj = ObjectWithBlob.find_with_settings(:location=>"San Francisco, CA")
+  => [#<ObjectWithBlob id: 412, settings: {:age=>32, :sex=>"Female", :location=>"San Francisco, CA"}, created_at: "2010-03-22 20:49:03", updated_at: "2010-03-22 20:49:03">]
+
+It's simple.
+
+
+== Prior Versions
+
+DoesKeyValue is a much newer and cleaner version of the old "do_document_fields" plugin for prior versions
+of Rails. Check that out at http://github.com/mccolin/do_document_fields
+
+
+== Contributions
+ 
+* 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) 2011 Awexome Labs, LLC. http://awexomelabs.com/
+

data/Rakefile

@@ -0,0 +1,40 @@
+# AWEXOME LABS
+# Rakefile
+
+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 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "doeskeyvalue"
+  gem.homepage = "http://github.com/awexome/doeskeyvalue"
+  gem.license = "MIT"
+  gem.summary = %Q{Add schema-less NoSQL-like key values to any ActiveRecord class}
+  gem.description = %Q{Bring the fun of NoSQL into your SQL-backed Active Record objects in a compartmentalized way. Turns any text field on your objects into a schema-less key value store.}
+  gem.email = "gems@awexomelabs.com"
+  gem.authors = ["Awexome Labs"]
+  
+  # Internal Gem Dependencies:
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "doeskeyvalue #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/doeskeyvalue.gemspec

@@ -0,0 +1,56 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{doeskeyvalue}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Awexome Labs"]
+  s.date = %q{2011-02-15}
+  s.description = %q{Bring the fun of NoSQL into your SQL-backed Active Record objects in a compartmentalized way. Turns any text field on your objects into a schema-less key value store.}
+  s.email = %q{gems@awexomelabs.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "doeskeyvalue.gemspec",
+    "lib/doeskeyvalue.rb",
+    "lib/doeskeyvalue/indexes.rb",
+    "lib/doeskeyvalue/keys.rb",
+    "lib/doeskeyvalue/util.rb",
+    "lib/generators/doeskeyvalue/doeskeyvalue_generator.rb",
+    "lib/generators/doeskeyvalue/templates/create_key_value_index.rb"
+  ]
+  s.homepage = %q{http://github.com/awexome/doeskeyvalue}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.2}
+  s.summary = %q{Add schema-less NoSQL-like key values to any ActiveRecord class}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+    else
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    end
+  else
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+  end
+end
+

data/lib/doeskeyvalue/indexes.rb

@@ -0,0 +1,84 @@
+# AWEXOME LABS
+# DoesKeyValue
+#
+# Indexes -- ActiveRecord::Base methods for settings and retrieval of values based
+#   on key indexes
+
+module DoesKeyValue
+  module Indexes
+    
+    def declare_index(key_value_column, key_name, opts={})
+      puts "DOES_KEY_VALUE: Index declared: #{key_value_column}, #{key_name}, #{opts.inspect}"
+      raise DoesKeyValue::NoColumnNameSpecified unless key_value_column
+      raise DoesKeyValue::NoKeyNameSpecified unless key_name
+      raise DoesKeyValue::KeyAndIndexOptionsMustBeHash unless opts.is_a?(Hash)
+      
+      search_key = "#{key_value_column}.#{key_name}"
+      raise DoesKeyValue::NoKeyForThatIndex if !self.respond_to?(key_name) || !self.respond_to?("#{key_name}=")
+      
+      class_name = self.name.underscore
+      class_table_name = self.table_name
+      index_table_name = "key_value_index"
+      
+      # INDEX TABLE: key_value_index
+      #  id:int
+      #  key_name:string
+      #  value:string
+      #  obj_type:string
+      #  obj_id:int
+      
+      # Define finders that leverage the custom index table:
+      instance_eval <<-EOS
+        def find_all_by_#{key_value_column}_#{key_name}(value)
+          find(
+            :all, 
+            :select=>"*",
+            :from=>"#{index_table_name}",
+            :conditions=>["`#{index_table_name}`.obj_type = ? AND `#{index_table_name}`.key_name = ? AND `#{index_table_name}`.value = ?", self.to_s, "#{search_key}", value], 
+            :joins => "LEFT JOIN `#{class_table_name}` ON `#{class_table_name}`.id = `#{index_table_name}`.obj_id"          
+          )
+        end
+        
+        def find_all_by_#{key_name}(value)
+          find_all_by_#{key_value_column}_#{key_name}(value)
+        end
+        
+        def find_all_with_#{key_value_column}(opts={})
+          conds = Array.new
+          opts.each do |k, v|
+            conds.add_condition(["`#{index_table_name}`.obj_type = ? AND `#{index_table_name}`.key_name = ? AND `#{index_table_name}`.value = ?", self.to_s, "#{search_key}", v])
+          end
+          find(
+            :all,
+            :select=>"*",
+            :from=>"#{index_table_name}",
+            :conditions=>conds,
+            :joins=>"LEFT JOIN `#{class_table_name}` ON `#{class_table_name}`.id = `#{index_table_name}`.obj_id"
+          )
+        end
+      EOS
+      
+      # Provide a callback after save which updates the index
+      define_method("update_index_#{key_value_column}_#{key_name}_after_save") do
+        class_name = self.class.name.underscore
+        class_table_name = self.class.table_name
+        index_table_name = "key_value_indexes"
+        # TODO: Restrict value to 255 characters, the table-enforced limit
+        idx_id = ActiveRecord::Base.connection.insert("INSERT INTO `#{index_table_name}` (`obj_type`,`obj_id`,`key_name`,`value`) VALUES (\""+self.class.to_s+"\","+self.id.to_s+", \""+search_key.to_s+"\", \"#{self.send(key_name).to_s}\")")
+      end
+      after_save "update_index_#{key_value_column}_#{key_name}_after_save"
+      
+      # Provide a callback after destroy to likewise update the index
+      define_method("update_index_#{key_value_column}_#{key_name}_after_destroy") do
+        class_name = self.class.name.underscore
+        class_table_name = self.class.table_name
+        index_table_name = "key_value_indexes"
+        num_del = ActiveRecord::Base.connection.delete("DELETE FROM `#{index_table_name}` WHERE `obj_type` = \"#{self.class}\" AND `obj_id` = #{self.id}")
+      end
+      after_destroy "update_index_#{key_value_column}_#{key_name}_after_destroy"
+      
+    end
+        
+    
+  end # Index
+end # DoesKeyValue

data/lib/doeskeyvalue/keys.rb

@@ -0,0 +1,40 @@
+# AWEXOME LABS
+# DoesKeyValue
+#
+# Keys -- ActiveRecord::Base methods for setting schemaless keys
+
+module DoesKeyValue
+  module Keys
+    
+    def declare_key(key_value_column, key_name, opts={})
+      puts "DOES_KEY_VALUE: Key declared: #{key_value_column}, #{key_name}, #{opts.inspect}"
+      raise DoesKeyValue::NoColumnNameSpecified unless key_value_column
+      raise DoesKeyValue::NoKeyNameSpecified unless key_name
+      raise DoesKeyValue::KeyAndIndexOptionsMustBeHash unless opts.is_a?(Hash)
+    
+      # Define accessors for the key column in the AR class:
+      class_eval <<-EOS
+        def #{key_name}
+          puts "DOES_KEY_VALUE: Accessor for `#{key_name}` invoked"
+          return (self.send(:#{key_value_column}) || Hash.new)[:#{key_name}]
+        end
+        puts "DOES_KEY_VALUE: Key accessor `#{key_name}` declared"
+      
+        def #{key_name}=(value)
+          puts "DOES_KEY_VALUE: Setter for `#{key_name}` invoked"
+          key_set = self.send(:#{key_value_column}) || Hash.new
+          key_set[:#{key_name}] = value
+          self.send("#{key_value_column}=", key_set)
+        end
+        puts "DOES_KEY_VALUE: Key manipulator `#{key_name}=` declared"
+      EOS
+    
+      # Check for opts[:index=>true] and if present, call declare_index
+      if opts[:index] == true
+        declare_index(key_value_column, key_name)   # TODO: Provide mechanism for passing index options
+      end
+    
+    end
+        
+  end # Keys
+end # DoesKeyValue

data/lib/doeskeyvalue/util.rb

@@ -0,0 +1,27 @@
+# AWEXOME LABS
+# DoesKeyValue
+
+
+module DoesKeyValue
+  module Util
+  
+    module CondArray
+      def add_condition(cond, conj="AND")
+        if cond.is_a?(Array)
+          if self.empty?
+            (self << cond).flatten!
+          else
+            self[0] += " #{conj} #{cond.shift}"
+            (self << cond).flatten!
+          end
+        elsif cond.is_a?(String)
+          self[0] += " #{conj} #{cond}"
+        else
+          raise "Condition must be an Array or String"
+        end
+        self
+      end
+    end
+  
+  end
+end # DoesKeyValue

data/lib/doeskeyvalue.rb

@@ -0,0 +1,83 @@
+# AWEXOME LABS
+# DoesKeyValue
+
+require 'doeskeyvalue'
+require 'rails'
+require 'active_record'
+
+require 'doeskeyvalue/keys'
+require 'doeskeyvalue/indexes'
+require 'doeskeyvalue/util'
+
+
+module DoesKeyValue
+
+  # Create a Rails Engine
+  class Engine < Rails::Engine
+  end
+  
+  # Return the current working version from VERSION file:
+  def self.version
+    @@version ||= File.open(File.join(File.dirname(__FILE__), "..", "VERSION"), "r").read
+  end
+  
+  # Exception Types for DoesKeyValue
+  class NoColumnNameSpecified < Exception
+    def initialize(msg="A class column name must be provided for storing key values in blob"); super(msg); end
+  end
+  class NoKeyNameSpecified < Exception
+    def initialize(msg="A key name must be provided to build a DoesKeyValue key"); super(msg); end
+  end
+  class NoKeyForThatIndex < Exception
+    def initialize(msg="A key must exist before an index can be applied to it"); super(msg); end
+  end
+  class KeyAndIndexOptionsMustBeHash < Exception
+    def initialize(msg="Options passed to declarations of keys and indexes must of class Hash"); super(msg); end
+  end
+  class KeyValueIndexTableDoesNotExist < Exception
+    def initialize(msg="DoesKeyValue requires an index table be generated to use key indexes. Use generator to generate migration"); super(msg); end
+  end
+  
+end # DoesKeyValue
+
+
+module ActiveRecord
+  class Base
+    
+    # Call this method within your class to establish key-value behavior and prep
+    # the internal structure that will hold the blob
+    def self.doeskeyvalue(column, opts={})
+      puts "DOES_KEY_VALUE: Turned on for AR Column:#{column}"
+      self.instance_eval do
+        extend DoesKeyValue::Keys
+        extend DoesKeyValue::Indexes
+        
+        # Identify the AR text column holding our data and serialize it:
+        @@key_value_column = column.to_sym
+        cattr_accessor :key_value_column
+        serialize @@key_value_column, Hash
+      end
+      
+      Array.class_eval do
+        include DoesKeyValue::Util::CondArray
+      end
+      
+      instance_eval <<-EOS
+        def #{@@key_value_column}_key(key_name, opts={})
+          puts "DOES_KEY_VALUE: Inside defined method #{@@key_value_column}_key"
+          key_name = key_name.to_sym
+          declare_key(@@key_value_column, key_name, opts)
+        end
+        
+        def #{@@key_value_column}_index(key_name, opts={})
+          puts "DOES_KEY_VALUE: Inside defined method #{@@key_value_column}_index"
+          key_name = key_name.to_sym
+          declare_index(@@key_value_column, key_name, opts)
+        end
+      EOS
+      puts "DOES_KEY_VALUE: key and index methods declared"
+    end
+    
+    
+  end # ActiveRecord::Base
+end # ActiveRecord

data/lib/generators/doeskeyvalue/doeskeyvalue_generator.rb

@@ -0,0 +1,25 @@
+# AWEXOME LABS
+# DoesKeyValue
+#
+# IndexTableGenerator -- generator for the Index database table
+
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class DoeskeyvalueGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  source_root File.expand_path('../templates', __FILE__)
+  
+  def self.next_migration_number(path)
+    if ActiveRecord::Base.timestamped_migrations
+      Time.now.utc.strftime("%Y%m%d%H%M%S")
+    else
+      "%.3d" % (current_migration_number(path) + 1)
+    end
+  end
+  
+  def create_migration_file
+    migration_template 'create_key_value_index.rb', 'db/migrate/create_key_value_index.rb'
+  end
+  
+end

data/lib/generators/doeskeyvalue/templates/create_key_value_index.rb

@@ -0,0 +1,30 @@
+# AWEXOME LABS
+# DoesKeyValue
+#
+# CreateKeyValueIndex -- generated migration template for key/value index table
+
+class CreateKeyValueIndex < ActiveRecord::Migration
+  def self.up
+    create_table :key_value_index do |t|
+      # The key is a composite of the grouping and key name (e.g., "settings.user_id")
+      t.string :key_name
+      
+      # The stored value is saved as varchar(255), which limits indexability slightly:
+      t.string :value
+      
+      # Store details about the target object:
+      t.string :obj_type
+      t.integer :obj_id
+      
+      # Track all touches:
+      t.timestamps
+    end
+    
+    # Index is important here:
+    add_index :key_value_index, [:obj_type, :key_name, :value]
+  end
+
+  def self.down
+    drop_table :key_value_index
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: doeskeyvalue
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Awexome Labs
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-15 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.5.2
+  type: :development
+  prerelease: false
+  version_requirements: *id002
+description: Bring the fun of NoSQL into your SQL-backed Active Record objects in a compartmentalized way. Turns any text field on your objects into a schema-less key value store.
+email: gems@awexomelabs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- doeskeyvalue.gemspec
+- lib/doeskeyvalue.rb
+- lib/doeskeyvalue/indexes.rb
+- lib/doeskeyvalue/keys.rb
+- lib/doeskeyvalue/util.rb
+- lib/generators/doeskeyvalue/doeskeyvalue_generator.rb
+- lib/generators/doeskeyvalue/templates/create_key_value_index.rb
+has_rdoc: true
+homepage: http://github.com/awexome/doeskeyvalue
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -2545379118669446342
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Add schema-less NoSQL-like key values to any ActiveRecord class
+test_files: []
+