entity_storage 1.0.4

data/History.txt

@@ -0,0 +1,17 @@
+=== 1.0.4 2009-09-23
+* Fixed edge case bug with defaults and accessors with underscores
+
+=== 1.0.3 2009-09-23
+* updated tests and example docs
+
+=== 1.0.2 2009-09-21
+* changed method of table discovery for auto table creation
+
+=== 1.0.1 2009-09-20
+* documentation update
+
+=== 1.0.0 2009-09-19
+
+* 1 major enhancement:
+  * Initial release
+ 

data/Manifest.txt

@@ -0,0 +1,11 @@
+History.txt
+Manifest.txt
+README.rdoc
+Rakefile
+lib/entity_storage.rb
+script/console
+script/destroy
+script/generate
+config/database.yml
+test/test_entity_storage.rb
+test/test_helper.rb

data/README.rdoc

@@ -0,0 +1,98 @@
+= entity_storage
+
+http://github.com/eatenbyagrue/entity_storage
+
+== DESCRIPTION:
+
+An easy to use Key/Value store for any Ruby on Rails project. Like Memcache, only persistent. Stores config values & application wide state in the database in order to survive server restarts.
+
+Designed to allow you to add persistent value storage to any Rails project in about 5 minutes.
+
+Additionally, allows users to set a list of default keys that auto-initializes baseline key/value pairs in the database for easy initialization.
+
+== SYNOPSIS:
+
+You can use the entity store like so:
+     
+    # Get key value. 
+    e = EntityStore["testkey"]
+    e = EntityStore.testkey
+    e = EntityStore[:testkey]
+    
+    # sets key named 'happened' to a Time object of now
+    EntityStore[:happened] = Time.now
+    EntityStore["happened"] = Time.now
+    EntityStore.happened = Time.now
+    
+    # find out it's default, even if it's been changed
+    e = EntityStore.default(:testkey)
+    
+    # or
+    e = EntityStore.defaults[:testkey]
+   
+    # set it back to default
+    EntityStore.default!(:testkey)
+    
+    # delete an item
+    EntityStore.delete(key)
+
+All EntityStorage operations sync immediately with the database, so a server shutdown will not impact stored values.
+
+If you access a key that doesn't exist, and is specified in default list, will be initialized and returned. If not in default list, will return nil.
+
+Keys can be up to 512 characters in length. Values can be practically any size, and consist of any object. Objects are marshalled back and forth between database.
+
+== REQUIREMENTS:
+
+Requires ActiveRecord 2.2.3 or above (probably works with earlier versions, but has not been tested.)
+
+== INSTALL:
+To install from github:
+
+    Run the following if you haven't already:
+    
+    gem sources -a http://gems.github.com
+    
+    Install the gem(s):
+    
+    sudo gem install eatenbyagrue-entity_storage
+
+Or download the souce above and run, customized for version and environment:
+
+    sudo gem install PATH/entity_storage.#.#.#.gem 
+
+Put the following at the bottom of your environment.rb file, or in an initializer.
+
+    require 'entity_storage'
+    DEFAULT_KEYS = { "testkey" => DateTime.parse("1-1-900"), "also test" => 2, "long ass key that I probably wouldn't use" => false }
+    EntityStore = EntityStorage::Storage.new(DEFAULT_KEYS) 
+
+On initialization, if the table "entity_storage" doesn't exist, it will be created. If you already have a table with that name, it must be in the correct format (previously created by this gem.)
+
+You can pass a hash full of default key/value pairs. If the application accesses one of the keys, and it doesn't already exist, it will initiliaze that key with the default value. Good for getting your app to an intial starting state.
+
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Joshua Siler
+
+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/Rakefile

@@ -0,0 +1,25 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/entity_storage'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'entity_storage' do
+  self.developer 'Joshua Siler', 'joshua.siler@gmail.com'
+#  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  self.extra_deps         = [['activerecord','>= 2.2.2']]
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/config/database.yml

@@ -0,0 +1,8 @@
+
+    adapter: mysql
+    database: careers
+    username: root
+    password: bnjstyle
+    host: localhost
+
+

data/lib/entity_storage.rb

@@ -0,0 +1,147 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+  
+require 'rubygems'
+require 'activerecord'
+
+module EntityStorage
+  VERSION = '1.0.4'
+  
+  class Storage
+    attr_accessor :defaults
+    
+    # Checks for the existence of the necessary Entities table... if not here, creates it.
+    def initialize(defaults={})
+      unless ActiveRecord::Base.connection.table_exists?('entity_storage')
+				AddEntitiesTable.up
+      end
+
+      self.defaults = defaults
+    end
+    
+    # Read a value.
+    def [](index)
+      Entity.get_value(index,@defaults[index.to_s])
+    end
+    
+    # Write a value.
+    def []=(index,value)
+      Entity.set_value(index,value)
+    end
+    
+    # Deletes a key and associated data from store.
+    def delete(index)
+      Entity.remove_item(index)
+    end
+    
+    # Returns the default value of a key contained in DEFAULT_KEYS global constant.
+    # Does not change the stored value. Use default! to reset the value.
+    def default(index)
+      @defaults[index.to_s]
+    end
+  
+    # Resets the default value of a key contained in DEFAULT_KEYS global constant and returns the value.
+    def default!(index)
+      Entity.reset_value(index,@defaults[index.to_s])
+    end
+    
+    # Allows EntityStorage[:whatever] to be accessed via EntityStorage.whatever.
+    def method_missing(*args)
+      if args.length == 1
+				self[args[0]]
+			elsif args.length == 2 and args[0].to_s =~ /^(.*)=$/
+				self[$1.intern] = args[1]
+			else
+			 super
+			end
+    end
+  end
+  
+  # This migration is required for EntityStorage to work correctly
+  class AddEntitiesTable < ActiveRecord::Migration
+    def self.up
+      create_table "entity_storage", :force => true do |t|
+	t.string   "key",        :limit => 512, :null => false
+	t.text     "value"
+	t.datetime "created_at"
+	t.datetime "updated_at"
+      end
+    
+      add_index "entity_storage", ["created_at"], :name => "created_at"
+      add_index "entity_storage", ["key"], :name => "key"
+      add_index "entity_storage", ["updated_at"], :name => "updated_at"
+    end
+    
+    def self.down
+      drop_table :entities
+    end
+  end
+  
+  
+  class Entity < ActiveRecord::Base
+    set_table_name "entity_storage"
+    
+    # Entities should be used via class methods and not instantiated directly.
+    private_class_method :new
+    
+    # Gets value based on specific key.
+    # If not found, will initialize according to defaults set in DEFAULT_KEYS global constant.
+    def self.get_value(search_key,default_value)
+      e = Entity.find_by_key(search_key.to_s)
+      if e.nil? || e.value.nil?
+				e = initialize_value(search_key,default_value)
+      end
+      e.value rescue nil
+    end
+    
+    # Sets value for a specific key. If key doesn't exist, creates with value. 
+    def self.set_value(search_key, new_value)
+      e = Entity.find_by_key(search_key.to_s)
+      if e.nil?
+				e = new
+      end
+      e.key = search_key
+      e.value = new_value
+      e.save
+    end
+    
+    # Resets a key contained in DEFAULT_KEYS global constant to it's default value
+    def self.reset_value(search_key,default_value)
+      Entity.remove_item(search_key)
+      initialize_value(search_key,default_value).value   
+    end
+    
+    # Deletes a record from key store.
+    def self.remove_item(search_key)
+      e = Entity.find_by_key(search_key.to_s)
+      e.destroy rescue 0
+    end
+    
+    def value=(data)
+      write_attribute(:value,Marshal.dump(data))
+    end
+    
+    def value
+      Marshal.load(read_attribute(:value))
+    end
+    
+    def key=(newkey)
+      write_attribute(:key,newkey.to_s)
+    end
+    
+    private
+    
+    # Checks provided key against internal defaults list and initializes to default value.
+    # Defaults defined in DEFAULT_KEYS global constant.
+    def self.initialize_value(search_key,default_value)
+      en = new
+      en.key = search_key
+      en.value = default_value
+      en.save
+      en
+    end
+    
+  end
+
+end
+

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/entity_storage.rb'}"
+puts "Loading entity_storage gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/test/test_entity_storage.rb

@@ -0,0 +1,107 @@
+require File.dirname(__FILE__) + '/test_helper.rb'
+ActiveRecord::Base.establish_connection(YAML::load(File.read(File.dirname(__FILE__) + '/../config/database.yml')))
+
+class TestEntityStorage < Test::Unit::TestCase
+  DEFAULT_KEYS = { "test" => DateTime.parse("1-1-900"), "also test" => 2, "long ass key that I probably wouldn't use" => false,
+	# last time the hiring manager notifications have been run 
+  "new_applicant_last_run" => DateTime.parse("1-1-1900"),
+  # last time the new job notifications have been run 
+  "new_jobs_last_run" => DateTime.parse("1-1-1900"),
+  "email_test_address" => "joshuas@bnj.com" }
+  
+  attr_accessor :EntityStore
+	EntityStore = EntityStorage::Storage.new(DEFAULT_KEYS)
+	
+  def setup
+    ActiveRecord::Base.connection.execute("delete from entity_storage")
+  end
+  
+  def test_instantiation
+		# test nasty weird bug with underscore characters
+		entityStore2 = EntityStorage::Storage.new(DEFAULT_KEYS)
+		assert_equal entityStore2.email_test_address, 'joshuas@bnj.com'
+  end
+  
+  # tests value setting and getting functionality, along with default creation  
+  def test_defaultkeys
+    DEFAULT_KEYS.each { |key,value| 
+      EntityStore.delete(key)
+      
+      # set key when it doesn't exist, should go to default
+      e = EntityStore[key]
+      assert_equal e, value
+      
+      EntityStore.delete(key)
+      
+      # set and try method missing access
+      if key[/\w/] == key
+				eval("e = EntityStore."+key)
+				assert_equal e, value
+			end
+      
+      # change it to something else
+      EntityStore[key] = Time.now.to_s
+      e = EntityStore[key]
+      assert_not_equal e, value
+      
+      # find out it's default
+      e = EntityStore.default(key)
+      assert_equal e, value
+      
+      e = EntityStore.defaults[key]
+      assert_equal e, value
+      
+      # set it back to default
+      EntityStore.default!(key)
+      e = EntityStore[key]
+      assert_equal e, value
+      
+      # set it to something else using method missing
+      if key[/\w/] == key
+				eval("e = EntityStore."+key +" = Time.now.to_s")
+				assert_equal e, value
+      end 
+    }
+  end
+  
+  # tests setting values when no DEFAULT_KEY exists
+  def test_settingvalues
+    EntityStore.delete('test')
+    
+    # key that can't be accessed via method missing
+    # set value and check it
+    EntityStore['big long key that cannot be accessed via method missing'] = 'what up'
+    e = EntityStore['big long key that cannot be accessed via method missing']
+    assert_equal e, 'what up'
+    
+    # set another value and check it
+    EntityStore['big long key that cannot be accessed via method missing'] = 'another value'
+    e = EntityStore['big long key that cannot be accessed via method missing']
+    assert_equal e, 'another value'
+    
+    EntityStore['test'] = 'what up'
+    e = EntityStore['test']
+    assert_equal e, 'what up'
+    
+    EntityStore['test'] = 'another value'
+    e = EntityStore['test']
+    assert_equal e, 'another value'
+    
+    # try the method missing version of the tests
+    e = EntityStore.test = 'what up'
+    e = EntityStore.test
+    assert_equal e, 'what up'
+    
+    e = EntityStore.test = 'another value'
+    e = EntityStore.test
+    assert_equal e, 'another value'
+    
+  end
+  
+  def test_getunknownvalue
+    EntityStore.delete('does not exist')
+    e = EntityStore['does not exist']
+    assert_nil e
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,6 @@
+require 'stringio'
+require 'test/unit'
+require 'rubygems'
+require 'active_record'
+require 'active_support'
+require File.dirname(__FILE__) + '/../lib/entity_storage'

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: entity_storage
+version: !ruby/object:Gem::Version 
+  version: 1.0.4
+platform: ruby
+authors: 
+- Joshua Siler
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-23 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.2
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: |-
+  An easy to use Key/Value store for any Ruby on Rails project. Like Memcache, only persistent. Stores config values & application wide state in the database in order to survive server restarts.
+  
+  Designed to allow you to add persistent value storage to any Rails project in about 5 minutes.
+  
+  Additionally, allows users to set a list of default keys that auto-initializes baseline key/value pairs in the database for easy initialization.
+email: 
+- joshua.siler@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+files: 
+- History.txt
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- lib/entity_storage.rb
+- script/console
+- script/destroy
+- script/generate
+- config/database.yml
+- test/test_entity_storage.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/eatenbyagrue/entity_storage
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: entity_storage
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An easy to use Key/Value store for any Ruby on Rails project
+test_files: 
+- test/test_entity_storage.rb
+- test/test_helper.rb