cjbottaro-curly_mustache 0.0.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 cjbottaro
+
+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,47 @@
+= CurlyMustache
+
+Like ActiveRecord, but uses key-value stores (Memcached, Redis, Tokyo Cabinet, etc) instead of relational databases.
+
+This is experimental and not used in any production environments yet.
+
+http://github.com/cjbottaro/curly_mustache
+
+== Installation
+
+ sudo gem install --source http://gems.github.com cjbottaro-curly_mustache
+
+== Features
+
+* Basic ActiveRecord-like CRUD operations (create, destroy, find, save).
+* Simple associations.
+* Validations (TODO)
+* Callbacks (TODO)
+
+== Connecting
+
+  CurlyMustache::Base.establish_connection :adapter => :memcache,
+                                           :servers => %w[one.example.com:11211 two.example.com:11211],
+
+The +memcache+ adapter uses memcache-client[http://github.com/mperham/memcache-client].  Whatever other options you pass to +establish_connection+ will be passed to the constructor for it.
+
+== Usage
+
+  class User < CurlyMustache::Base
+    attribute :name,          :string
+    attribute :birthday_on,   :date
+    attribute :login_count,   :integer
+    attribute :last_login_at, :time
+  end
+  
+  user = User.create :name => "chris"
+  user.id                             # => "676cef021584904876af7c4b3e42afb5"
+  user.name                           # => "chris"
+  user.birthday_on = "03/11/1980"
+  user.save
+  
+  user = User.find(user.id)
+  puts user.birthday_on               # => "Tue, 11 Mar 1980"
+  user.birthday_on.class              # => Date
+  
+  user.destroy
+  User.find(user.id)                  # => exception CurlyMustache::RecordNotFound

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "curly_mustache"
+    gem.summary = %Q{Like ActiveRecord, but uses key-value stores (Tokyo Cabinet, Redis, MemcacheDB, etc) instead of relational databases.}
+    gem.email = "cjbottaro@alumni.cs.utexas.edu"
+    gem.homepage = "http://github.com/cjbottaro/curly_mustache"
+    gem.authors = ["Christopher J Bottaro"]
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION.yml')
+    config = YAML.load(File.read('VERSION.yml'))
+    version = "#{config[:major]}.#{config[:minor]}.#{config[:patch]}"
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "curly_mustache #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 0
+:patch: 0

data/lib/adapters/abstract.rb

@@ -0,0 +1,32 @@
+module CurlyMustache
+  module Adapters
+    class Abstract
+      
+      def initialize(config)
+        raise RuntimeError, "Not implemented!"
+      end
+      
+      def get(key)
+        raise RuntimeError, "Not implemented!"
+      end
+      
+      def mget(keys)
+        keys.collect{ |key| get(key) }.compact
+      end
+      
+      def put(key, value)
+        raise RuntimeError, "Not implemented!"
+      end
+      
+      def delete(key)
+        raise RuntimeError, "Not implemented!"
+      end
+      
+      # Needed for tests.
+      def flush_db
+        raise RuntimeError, "Not implemented!"
+      end
+      
+    end
+  end
+end

data/lib/adapters/memcache.rb

@@ -0,0 +1,37 @@
+require 'memcache'
+
+module CurlyMustache
+  module Adapters
+    class Memcache < Abstract
+      
+      def initialize(config)
+        config = config.reverse_merge :servers => "localhost:11211"
+        @cache = MemCache.new(config[:servers], config)
+      end
+      
+      def get(key)
+        (data = @cache.get(key)) and Marshal.load(data)
+      end
+      
+      def mget(keys)
+        keys = keys.collect(&:to_s)
+        results = @cache.get_multi(*keys)
+        results = results.collect{ |k, v| [k, Marshal.load(v)] }
+        results.sort.collect{ |result| result[1] }
+      end
+      
+      def put(key, value)
+        @cache.set(key, Marshal.dump(value))
+      end
+      
+      def delete(key)
+        @cache.delete(key)
+      end
+      
+      def flush_db
+        @cache.flush_all
+      end
+      
+    end
+  end
+end

data/lib/adapters/redis.rb

@@ -0,0 +1,34 @@
+require 'redis'
+
+module CurlyMustache
+  module Adapters
+    class Redis < Abstract
+      
+      def initialize(config)
+        @redis = ::Redis.new(config)
+      end
+      
+      def get(key)
+        (data = @redis.get(key)) and Marshal.load(data)
+      end
+      
+      def mget(keys)
+        keys = keys.collect(&:to_s)
+        @redis.mget(*keys).compact.collect{ |value| Marshal.load(value) }
+      end
+      
+      def put(key, value)
+        @redis.set(key, Marshal.dump(value))
+      end
+      
+      def delete(key)
+        @redis.delete(key)
+      end
+      
+      def raw
+        @redis
+      end
+      
+    end
+  end
+end

data/lib/adapters/tokyo_tyrant.rb

@@ -0,0 +1,44 @@
+require 'rufus/tokyo/tyrant'
+
+module CurlyMustache
+  module Adapters
+    class TokyoTyrant < Abstract
+      
+      def initialize(config)
+        config = config.reverse_merge :server => "localhost", :port => 1978
+        @db = Rufus::Tokyo::Tyrant.new(config[:server], config[:port])
+      end
+      
+      def get(key)
+        (data = @db[key]) and Marshal.load(data)
+      end
+      
+      def mget(keys)
+        keys = keys.collect(&:to_s)
+        results = @db.lget(keys)
+        keys.inject([]) do |memo, key|
+          data = results[key]
+          memo << Marshal.load(data) if data
+          memo
+        end
+      end
+      
+      def put(key, value)
+        @db[key] = Marshal.dump(value)
+      end
+      
+      def delete(key)
+        @db.delete(key) ? true : false
+      end
+      
+      def flush_db
+        @db.clear
+      end
+      
+      def raw
+        @db
+      end
+      
+    end
+  end
+end

data/lib/association_collection.rb

@@ -0,0 +1,57 @@
+module CurlyMustache
+  class AssociationCollection
+    
+    delegate :[], :inspect, :length, :to => :implementation
+    
+    def initialize(owner, reflection)
+      @owner, @reflection = owner, reflection
+      reload
+    end
+    
+    def reload
+      klass = @reflection[:class_name].constantize
+      @array = klass.find(get_ids)
+    end
+    
+    def to_a
+      @array.dup
+    end
+    
+    def <<(value)
+      raise InvalidAssociation unless value.kind_of?(CurlyMustache::Base)
+      @array << value
+      ids = get_ids
+      ids << value.id
+      set_ids(ids)
+    end
+    
+  private
+    
+    def implementation
+      @array
+    end
+    
+    def get_ids
+      ids = @owner.send(foreign_key)
+      if fkey_type == :string
+        ids.split(',')
+      else
+        ids
+      end
+    end
+    
+    def set_ids(ids)
+      ids = ids.join(',') if fkey_type == :string
+      @owner.send("#{foreign_key}=", ids)
+    end
+    
+    def foreign_key
+      @reflection[:foreign_key]
+    end
+    
+    def fkey_type
+      @owner.send(:attribute_type, foreign_key)
+    end
+    
+  end
+end

data/lib/association_manager.rb

@@ -0,0 +1,88 @@
+module CurlyMustache
+  class AssociationManager
+    
+    def initialize(owner)
+      @owner = owner
+      @cache = {}
+    end
+    
+    def get(name, reload = false)
+      return cache_get(name) if cache_hit?(name) and !reload
+      reflection = reflection(name)
+      if reflection.arity == :one
+        get_one(reflection)
+      else
+        get_many(reflection)
+      end
+    end
+    
+    def get_one(reflection)
+      klass  = reflection.class_name.constantize
+      fkey   = @owner.send(reflection.foreign_key)
+      object = klass.find(fkey)
+      cache_set(reflection.name, object)
+    end
+    
+    def get_many(reflection)
+      object = AssociationCollection.new(@owner, reflection)
+      cache_set(reflection.name, object)
+    end
+    
+    def set(name, object)
+      reflection = reflection(name)
+      if reflection.arity == :one
+        set_one(reflection, object)
+      else
+        set_many(reflection, object)
+      end
+    end
+    
+    def set_one(reflection, object)
+      if object.nil?
+        object_id = nil
+      elsif object.kind_of?(CurlyMustache::Base)
+        object_id = object.id
+      else
+        raise InvalidAssociation
+      end
+      @owner.send("#{reflection.foreign_key}=", object_id)
+      cache_set(reflection.name, object)
+    end
+    
+    def set_many(reflection, objects)
+      objects = [] if objects.blank?
+      raise InvalidAssociation unless objects.all?{ |object| object.kind_of?(CurlyMustache::Base) }
+      if objects.blank?
+        object_ids = []
+      else
+        object_ids = objects.collect{ |object| object.id }
+      end
+      object_ids = object_ids.join(',') if attribute_type(reflection.foreign_key) == :string
+      @owner.send("#{reflection.foreign_key}=", object_ids)
+      cache_set(reflection.name, objects)
+    end
+  
+  private
+    
+    def cache_hit?(name)
+      @cache.has_key?(name.to_s)
+    end
+    
+    def cache_get(name)
+      @cache[name.to_s]
+    end
+    
+    def cache_set(name, object)
+      @cache[name.to_s] = object
+    end
+    
+    def reflection(name)
+      @owner.class.associations[name.to_sym]
+    end
+    
+    def attribute_type(name)
+      @owner.send(:attribute_type, name)
+    end
+    
+  end
+end

data/lib/associations.rb

@@ -0,0 +1,59 @@
+require 'association_manager'
+
+module CurlyMustache
+  module Associations
+    
+    def self.included(mod)
+      mod.class_eval{ class_inheritable_accessor :associations }
+      mod.associations = {}
+      mod.send(:extend,  ClassMethods)
+      mod.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      
+      def association(name, options = {})
+        # Sanitize arguments.
+        name = name.to_s
+        
+        # Default options.
+        options = options.reverse_merge :arity => :many,
+                                        :name => name
+        
+        # More default options (based off previous default options).
+        if options[:arity] == :many
+          options = options.reverse_merge :class_name => name.singularize.camelize,
+                                          :foreign_key => name.singularize.foreign_key.pluralize
+        else
+          options = options.reverse_merge :class_name => name.camelize,
+                                          :foreign_key => name.foreign_key
+        end
+        
+        # Save the association reflection info.
+        self.associations[name.to_sym] = options.to_struct
+        
+        # Create associations accessors.
+        class_eval <<-END
+          def #{name}(reload = false)
+            association_manager.get(:#{name}, reload)
+          end
+          def #{name}=(value)
+            association_manager.set(:#{name}, value)
+          end
+        END
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+    private
+    
+      def association_manager
+        @associations_manager ||= AssociationManager.new(self)
+      end
+      
+    end
+    
+  end # module Crud
+end # module CurlyMustache

data/lib/attributes/definer.rb

@@ -0,0 +1,26 @@
+module CurlyMustache
+  module Attributes
+    class Definer
+    
+      def initialize(klass)
+        @class = klass
+      end
+    
+      def define(name, type, options = {})
+        @class.check_attribute_type(type)
+        definition = { :type => type }
+        @class.attribute_definitions[name.to_sym] = definition
+        @class.class_eval <<-END
+          def #{name}
+            read_attribute('#{name}')
+          end
+        
+          def #{name}=(value)
+            write_attribute('#{name}', value)
+          end
+        END
+      end
+    
+    end
+  end
+end

data/lib/attributes/definitions.rb

@@ -0,0 +1,11 @@
+module CurlyMustache
+  module Attributes
+    class Definitions < Hash
+      def [](key)
+        key = key.to_sym
+        raise AttributeNotDefinedError, "unexpected attribute: #{key}" unless has_key?(key)
+        super(key)
+      end
+    end
+  end
+end

data/lib/attributes/typecaster.rb

@@ -0,0 +1,71 @@
+module CurlyMustache
+  module Attributes
+    class Typecaster
+      
+      SCOPES = %w[read write load store]
+      
+      def initialize
+      end
+      
+      def cast(scope, type, value)
+        method_name = "to_#{scope}_#{type}"
+        return nil if value.nil?
+        respond_to?(method_name) ? send(method_name, value) : value
+      end
+      
+      SCOPES.each do |scope|
+        class_eval <<-END
+          def cast_for_#{scope}(type, value)
+            cast('#{scope}', type, value)
+          end
+        END
+      end
+      
+      def to_write_array(value)
+        value.to_a
+      end
+      
+      def to_write_integer(value)
+        value.to_i
+      end
+      
+      def to_write_string(value)
+        value.to_s
+      end
+      
+      def to_write_date(value)
+        value.to_date
+      end
+      
+      def to_write_time(value)
+        value.to_time.utc
+      end
+      
+      def to_write_datetime(value)
+        value.to_datetime.utc
+      end
+      
+      def to_write_boolean(value)
+        case value
+        when String
+          %w[t true 1 y yes].include?(value.downcase)
+        else
+          [true, 1].include?(value)
+        end
+      end
+      
+      def to_write_float(value)
+        value.to_f
+      end
+      
+      def to_read_time(value)
+        value.time_in_zone
+      end
+      
+      def to_read_datetime(value)
+        value.time_in_zone
+      end
+      
+    end
+  end
+end

data/lib/attributes/types.rb

@@ -0,0 +1,39 @@
+module CurlyMustache
+  module Attributes
+    module Types
+      
+      DEFAULT_ATTRIBUTE_TYPES = %w[array integer string date time datetime boolean float].freeze
+      
+      def self.included(mod)
+        mod.class_eval{ class_inheritable_accessor :attribute_types }
+        mod.attribute_types = DEFAULT_ATTRIBUTE_TYPES.dup
+        mod.extend(ClassMethods)
+        mod.send(:include, InstanceMethods)
+      end
+      
+      module InstanceMethods
+        
+      private
+        
+        def attribute_type(name)
+          self.class.attribute_definitions[name.to_sym][:type]
+        end
+        
+      end # end module InstanceMethods
+      
+      module ClassMethods
+        
+        def valid_attribute_type?(type)
+          self.attribute_types.include?(type.to_s)
+        end
+        
+        def check_attribute_type(type)
+          raise InvaildAttributeType, "unexpected attribute type: #{type}" unless valid_attribute_type?(type)
+        end
+        
+      end # end module ClassMethods
+      
+    end # end module Types
+  end # end module Attributes
+end # end module CurlyMustache
+      

data/lib/base.rb

@@ -0,0 +1,93 @@
+module CurlyMustache
+  class Base
+    include Attributes::Types
+    include Crud
+    include Associations
+    
+    class_inheritable_accessor :connection
+    class_inheritable_accessor :connection_config
+    class_inheritable_accessor :attribute_definitions
+    class_inheritable_accessor :typecaster
+    
+    self.attribute_definitions = Attributes::Definitions.new
+    Attributes::Definer.new(self).define(:id, :integer)
+    
+    self.typecaster = Attributes::Typecaster.new
+    
+    def self.establish_connection(config)
+      adapter_name = config[:adapter]
+      require "adapters/#{adapter_name}"
+      self.connection_config = config
+      self.connection = "CurlyMustache::Adapters::#{adapter_name.camelize}".constantize.new(config)
+    end
+  
+    def self.define_attributes(&block)
+      yield(Attributes::Definer.new(self))
+    end
+    
+    def id
+      @attributes[:id]
+    end
+    
+    def new_record?
+      !!@new_record
+    end
+    
+    def attributes
+      @attributes
+    end
+  
+    def read_attribute(name)
+      self.class.check_attribute_defined(name)
+      @attributes[name.to_sym]
+    end
+  
+    def write_attribute(name, value)
+      self.class.check_attribute_defined(name)
+      type = self.class.attribute_definitions[name][:type]
+      @attributes[name.to_sym] = typecast(:write, type, value)
+    end
+    
+    def ==(other)
+      self.attributes  == other.attributes and
+      self.new_record? == other.new_record?
+    end
+  
+  private
+
+    def self.id_to_key(id)
+      "#{self.name.underscore}_#{id}"
+    end
+  
+    def self.ids_to_keys(ids)
+      [ids].flatten.collect{ |id| id_to_key(id) }
+    end
+  
+    def self.key_to_id(key)
+      key.split("_").last
+    end
+  
+    def self.keys_to_ids(keys)
+      keys.collect{ |key| key_to_id(key) }
+    end
+  
+    def self.attribute_defined?(name)
+      self.attribute_definitions.has_key?(name.to_sym)
+    end
+  
+    def self.check_attribute_defined(name)
+      raise AttributeNotDefinedError, "unexpected attribute: #{name}" unless attribute_defined?(name)
+    end
+    
+    def key
+      raise NoKeyError unless id
+      self.class.id_to_key(id)
+    end
+    
+    def typecast(scope, type, value)
+      self.class.typecaster.cast(scope, type, value)
+    end
+  
+  end
+  
+end

data/lib/crud.rb

@@ -0,0 +1,122 @@
+module CurlyMustache
+  
+  module Crud
+    
+    def self.included(mod)
+      mod.send(:extend,  ClassMethods)
+      mod.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      
+      def generate_id
+        Digest::MD5.hexdigest(rand.to_s + Time.now.to_s)
+      end
+      
+      def create(attributes = {})
+        returning(new(attributes)){ |record| record.save }
+      end
+      
+      def create!(attributes = {})
+        new(attributes).save!
+      end
+      
+      def find(*ids)
+        ids = [ids].flatten
+        if ids.length == 1
+          find_one(ids.first)
+        else
+          find_many(ids)
+        end
+      end
+      
+      def delete_all(*ids)
+        ids_to_keys(ids).each{ |key| connection.delete(key) }
+      end
+      
+      def destroy_all(*ids)
+        find(ids).each{ |record| record.destroy }
+      end
+    
+    private
+      
+      def find_one(id)
+        raise RecordNotFound, "Couldn't find #{self} without an ID" if id.blank?
+        raise RecordNotFound, "Couldn't find #{self} with ID=#{id}" if (data = connection.get(id_to_key(id))).blank?
+        returning(new){ |record| record.send(:load, data) }
+      end
+      
+      def find_many(ids)
+        keys = ids_to_keys(ids)
+        datas = connection.mget(keys)
+        if keys.length != datas.length
+          raise RecordNotFound, "Couldn't find all #{self.name} with IDs (#{ids.join(',')}) (found #{datas.length} results, but was looking for #{ids.length})"
+        else
+          datas.collect{ |data| returning(new){ |record| record.send(:load, data) } }
+        end
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      def initialize(attributes = {})
+        @attributes = {}
+        @new_record = true
+        attributes.each{ |k, v| write_attribute(k, v) }
+      end
+      
+      def reload
+        returning(self){ @attributes = self.class.find(id).attributes }
+      end
+      
+      def save
+        save!
+        true
+      rescue ValidationError => e
+        false
+      end
+      
+      def save!
+        new_record? ? create : update
+        self
+      end
+      
+      def destroy
+        self.class.delete_all(id)
+        self.freeze
+      end
+      
+    private
+    
+      def set_id
+        if id.blank?
+          @attributes[:id] = self.class.generate_id
+        else
+          true
+        end
+      end
+      
+      def create
+        set_id and store
+      end
+      
+      def update
+        store
+      end
+      
+      def load(data)
+        @attributes = data
+        @new_record = false
+      end
+      
+      def store
+        connection.put(key, @attributes)
+        @new_record = false
+      end
+      
+    end # end module InstanceMethods
+    
+  end
+  
+end

data/lib/curly_mustache.rb

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'activesupport'
+require 'digest'
+
+require 'adapters/abstract'
+require 'errors'
+require 'helpers'
+require 'attributes/definer'
+require 'attributes/definitions'
+require 'attributes/types'
+require 'attributes/typecaster'
+require 'crud'
+require 'associations'
+require 'association_collection'
+require 'base'

data/lib/errors.rb

@@ -0,0 +1,8 @@
+module CurlyMustache
+  class NoKeyError < RuntimeError; end
+  class AttributeNotDefinedError < RuntimeError; end
+  class InvaildAttributeType < ArgumentError; end
+  class InvalidAssociation < RuntimeError; end
+  class RecordNotFound < RuntimeError; end
+  class ValidationError < RuntimeError; end
+end

data/lib/helpers.rb

@@ -0,0 +1,16 @@
+class Hash
+  def to_struct(name = nil)
+    name = "Hash" if name.blank?
+    struct = Struct.new(name.to_s, *(keys.collect{ |key| key.to_sym }))
+    returning(struct.new){ |struct| each{ |k, v| struct.send("#{k}=", v) }}
+  end
+end
+
+class Object
+  def meta_eval(&block)
+    (class << self; self; end).instance_eval(&block)
+  end
+  def full?
+    !blank?
+  end
+end

data/test/associations_test.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Account < CurlyMustache::Base
+  define_attributes do |attribute|
+    attribute.define :name,       :string
+    attribute.define :user_ids,   :array
+  end
+  
+  association :users
+end
+
+class User < CurlyMustache::Base
+  define_attributes do |attribute|
+    attribute.define :account_id,   :integer
+    attribute.define :name,         :string
+  end
+  
+  association :account, :arity => :one
+end
+
+class AssociationsTest < Test::Unit::TestCase
+  
+  def test_one
+    # set up some records
+    Account.create! :id => 1, :name => "account"
+    user = User.create! :id => 1, :account_id => 1, :name => "user"
+    
+    # test that the association loads
+    assert(user.account)
+    assert_equal("account", user.account.name)
+    
+    # test that we can set the association's attributes
+    user.account.name = "tnuocca"
+    assert_equal("tnuocca", user.account.name)
+    
+    # reload association
+    assert_equal("account", user.account(true).name)
+    
+    # Assigning to the association should change our "foreign key" attribute.
+    account2 = Account.create :id => 2, :name => "account2"
+    user.account = account2
+    assert_equal(account2, user.account)
+    assert_equal(account2.id, user.account_id)
+    
+    # Assigning nil to the association should blank out our "foreign key" attribute.
+    user.account = nil
+    assert_equal(nil, user.account)
+    assert_equal(nil, user.account_id)
+  end
+  
+  def test_many
+    # Set up some records.
+    1.upto(5){ |i| User.create! :id => i }
+    account = Account.create! :id => 1, :user_ids => [1, 2, 3]
+    
+    # Load the association, make sure it looks ok.
+    assert(account.users.instance_of?(CurlyMustache::AssociationCollection))
+    assert_equal 3, account.users.length
+    assert_equal User.find(1, 2, 3), account.users.to_a
+    
+    # Add an item to the association.
+    account.users << User.find(4)
+    assert_equal 4, account.users.length
+    assert_equal User.find(1, 2, 3, 4), account.users.to_a
+    assert_equal [1, 2, 3, 4], account.user_ids
+    
+    # Make sure reloading works.
+    old_name = account.users[0].name
+    account.users[0].name = old_name.to_s + "blah"
+    assert_equal(old_name, account.users(true)[0].name)
+    
+    # Set the association.
+    account.users = User.find(1, 2, 3, 4)
+    assert_equal 4, account.users.length
+    assert_equal User.find(1, 2, 3, 4), account.users
+    assert_equal [1, 2, 3, 4], account.user_ids
+  end
+  
+end

data/test/crud_test.rb

@@ -0,0 +1,165 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class User < CurlyMustache::Base
+  define_attributes do |attribute|
+    attribute.define :name,         :string
+    attribute.define :phone_number, :integer
+    attribute.define :balance,      :float
+    attribute.define :is_admin,     :boolean
+    attribute.define :created_at,   :datetime
+    attribute.define :updated_at,   :time
+  end
+end
+
+class CrudTest < Test::Unit::TestCase
+  
+  def setup
+    CurlyMustache::Base.connection.flush_db
+  end
+  
+  def attributes_hash
+    { :id           => 123,
+      :name         => "chris",
+      :phone_number => 5128258325,
+      :balance      => 1.01,
+      :is_admin     => true,
+      :created_at   => DateTime.parse("2009-04-23 22:09:50.936751 -05:00"),
+      :updated_at   =>     Time.parse("2009-04-23 22:09:50.936751 -05:00") }.dup
+  end
+  
+  def assert_attributes(record, attributes = nil)
+    (attributes or attributes_hash).each do |k, v|
+      assert_equal v, record.send(k), "for attribute '#{k}'"
+    end
+  end
+  
+  def test_create
+    user = User.create(attributes_hash)
+    assert(user)
+    assert(!user.new_record?)
+    user = User.find(attributes_hash[:id])
+    assert_attributes(user)
+  end
+  
+  def test_create!
+    user = User.create!(attributes_hash)
+    assert(user)
+    assert(!user.new_record?)
+    user = User.find(attributes_hash[:id])
+    assert_attributes(user)
+  end
+  
+  def test_create_autogen_id
+    id = "1341adb122d8190872c2928dbcc08b9d"
+    User.expects(:generate_id).returns(id)
+    user = User.create :name => "christopher"
+    assert_equal id, user.id
+  end
+  
+  def test_find
+    attributes1 = attributes_hash
+    attributes1[:id] = 1
+    User.create(attributes1)
+    
+    attributes2 = attributes_hash
+    attributes2[:id] = 2
+    User.create(attributes2)
+    
+    assert_equal User.find(1), User.find(1)
+    
+    user1 = User.find(1)
+    assert_attributes(user1, attributes1)
+    
+    user2 = User.find(2)
+    assert_attributes(user2, attributes2)
+    
+    assert_equal [user1, user2], User.find(1, 2)
+    assert_raise(CurlyMustache::RecordNotFound){ User.find(3) }
+    assert_raise(CurlyMustache::RecordNotFound){ User.find(1, 2, 3) }
+  end
+  
+  def test_delete_all
+    1.upto(3) do |i|
+      attributes = attributes_hash
+      attributes[:id] = i
+      User.create(attributes)
+    end
+    
+    User.delete_all(1, 2)
+    assert_raise(CurlyMustache::RecordNotFound){ User.find(1) }
+    assert_raise(CurlyMustache::RecordNotFound){ User.find(2) }
+    assert(User.find(3))
+  end
+  
+  def test_destroy_all
+    1.upto(3) do |i|
+      attributes = attributes_hash
+      attributes[:id] = i
+      User.create(attributes)
+    end
+    
+    User.destroy_all(1, 2)
+    assert_raise(CurlyMustache::RecordNotFound){ User.find(1) }
+    assert_raise(CurlyMustache::RecordNotFound){ User.find(2) }
+    assert(User.find(3))
+  end
+  
+  def test_new
+    user = User.new(attributes_hash)
+    assert_attributes(user)
+    assert(user.new_record?)
+  end
+  
+  def test_reload
+    user = User.new(attributes_hash)
+    assert_raise(CurlyMustache::RecordNotFound){ user.reload }
+    
+    assert(user = User.create(attributes_hash))
+    User.delete_all(user.id)
+    assert_raise(CurlyMustache::RecordNotFound){ user.reload }
+    
+    assert(user = User.create(attributes_hash))
+    user.name = "callie"
+    assert_equal(user.read_attribute(:name), "callie")
+    user.reload
+    assert_equal(user.read_attribute(:name), attributes_hash[:name])
+  end
+  
+  def test_save_by_expectations
+    user = User.new(attributes_hash)
+    user.expects(:create).once
+    user.save
+    
+    user = User.create!(attributes_hash)
+    user.expects(:update).once
+    user.save
+  end
+  
+  def test_save
+    do_test_save(:save)
+  end
+  
+  def test_save!
+    do_test_save(:save!)
+  end
+  
+  def test_destroy
+    user = User.create!(attributes_hash)
+    user.destroy
+    assert(user.frozen?)
+    assert_raise(CurlyMustache::RecordNotFound){ user.reload }
+  end
+  
+  def do_test_save(method_name)
+    user = User.new(attributes_hash)
+    user.send(method_name)
+    assert_attributes(user.reload)
+    
+    user = User.create!(attributes_hash)
+    user.name = "callie"
+    user.send(method_name)
+    user.reload
+    assert_equal("callie", user.name)
+  end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'curly_mustache'
+
+class Test::Unit::TestCase
+end
+
+adapter = ENV["ADAPTER"] || :memcache
+CurlyMustache::Base.establish_connection(:adapter => adapter)

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification 
+name: cjbottaro-curly_mustache
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Christopher J Bottaro
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-12 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: cjbottaro@alumni.cs.utexas.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- lib/adapters/abstract.rb
+- lib/adapters/memcache.rb
+- lib/adapters/redis.rb
+- lib/adapters/tokyo_tyrant.rb
+- lib/association_collection.rb
+- lib/association_manager.rb
+- lib/associations.rb
+- lib/attributes/definer.rb
+- lib/attributes/definitions.rb
+- lib/attributes/typecaster.rb
+- lib/attributes/types.rb
+- lib/base.rb
+- lib/crud.rb
+- lib/curly_mustache.rb
+- lib/errors.rb
+- lib/helpers.rb
+- test/associations_test.rb
+- test/crud_test.rb
+- test/test_helper.rb
+has_rdoc: true
+homepage: http://github.com/cjbottaro/curly_mustache
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 3
+summary: Like ActiveRecord, but uses key-value stores (Tokyo Cabinet, Redis, MemcacheDB, etc) instead of relational databases.
+test_files: 
+- test/associations_test.rb
+- test/crud_test.rb
+- test/test_helper.rb