curly_mustache 0.1.0

data/lib/curly_mustache/default_types.rb

@@ -0,0 +1,18 @@
+require "curly_mustache/attributes/types"
+
+types = CurlyMustache::Attributes::Types
+types.define(:integer){ |value| Integer(value) rescue 0 }
+types.define(:string){ |value| String(value) rescue "" }
+types.define(:float){ |value| Float(value) rescue 0.0 }
+types.define(:boolean){ |value| !!value }
+types.define(:time) do |value|
+  if value.kind_of?(Time)
+    value
+  elsif value.kind_of?(String)
+    Time.parse(value)
+  elsif value.kind_of?(Integer) or value.kind_of?(Float)
+    Time.at(value)
+  else
+    nil
+  end
+end

data/lib/curly_mustache/errors.rb

@@ -0,0 +1,14 @@
+module CurlyMustache
+  class NoKeyError < RuntimeError; end
+  class AttributeNotDefinedError < RuntimeError; end
+  class IdNotSettableError < RuntimeError; end
+  class InvaildAttributeType < ArgumentError; end
+  class InvalidAssociation < RuntimeError; end
+  class NotImplementedError < RuntimeError
+    def initialize
+      super("Not implemented!")
+    end
+  end
+  class RecordNotFound < RuntimeError; end
+  class RecordInvalid < RuntimeError; end
+end

data/lib/curly_mustache/locking.rb

@@ -0,0 +1,83 @@
+require "timeout"
+
+module CurlyMustache
+  module Locking
+    
+    def self.included(mod)
+      mod.send(:extend,  ClassMethods)
+      mod.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      
+      def lock(id, timeout = nil)
+        if timeout.nil?
+          connection.lock(lock_key(id))
+        else
+          lock_with_timeout(id, timeout)
+        end
+      end
+      
+      def lock_with_timeout(id, timeout)
+        start_time = Time.now
+        while (Time.now.to_f - start_time.to_f) < timeout
+          connection.lock(lock_key(id)) and return true
+          sleep(0.1)
+        end
+        raise Timeout::Error, "aquiring lock for #{id_to_key(id)}"
+      end
+      
+      def unlock(id)
+        connection.unlock(lock_key(id))
+      end
+      
+      def lock_and_find(id, timeout = nil, &block)
+        lock(id, timeout) or return false
+        unlock(id) and return if (record = find(id)).blank?
+        if block_given?
+          do_locked_block(id, record, &block)
+        else
+          record
+        end
+      end
+      
+      def do_locked_block(id, record, &block)
+        yield(record)
+      rescue Exception
+        raise
+      ensure
+        unlock(id)
+      end
+      
+      def lock_key(id)
+        "#{lock_prefix}:#{id_to_key(id)}"
+      end
+      
+      def lock_prefix
+        "lock"
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      def lock(timeout = nil, &block)
+        self.class.lock(self.id, timeout) or return false
+        if block_given?
+          self.class.do_locked_block(self.id, self.reload, &block)
+        else
+          true
+        end
+      end
+      
+      def unlock
+        self.class.unlock(self.id)
+      end
+      
+      def locked?
+        connection.locked?(self.class.lock_key(id))
+      end
+      
+    end
+  end
+end

data/test/abstract_adapter_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+
+class BadAdapter < CurlyMustache::Adapters::Abstract; end
+
+class AbstractAdapterTest < ActiveSupport::TestCase
+  
+  def test_not_implemented
+    assert_raise(CurlyMustache::NotImplementedError){ BadAdapter.new(nil) }
+    BadAdapter.class_eval do
+      def initialize(config); nil; end
+    end
+    adapter = BadAdapter.new(nil)
+    assert_raise(CurlyMustache::NotImplementedError){ adapter.get(1) }
+    assert_raise(CurlyMustache::NotImplementedError){ adapter.mget([1, 2]) }
+    assert_raise(CurlyMustache::NotImplementedError){ adapter.put(1, "one") }
+    assert_raise(CurlyMustache::NotImplementedError){ adapter.delete(1) }
+    assert_raise(CurlyMustache::NotImplementedError){ adapter.flush_db }
+    assert_raise(CurlyMustache::NotImplementedError){ adapter.lock(1) }
+    assert_raise(CurlyMustache::NotImplementedError){ adapter.unlock(1) }
+  end
+  
+end

data/test/adapters.yml

@@ -0,0 +1,6 @@
+memcached:
+  servers: localhost:11211
+
+cassandra:
+  servers: 127.0.0.1:9160
+  keyspace: CurlyMustache

data/test/attributes_test.rb

@@ -0,0 +1,96 @@
+require "test_helper"
+
+class AttributesTest < ActiveSupport::TestCase
+  
+  def teardown
+    Account.allow_settable_id!(false) # Leave pristine.
+  end
+  
+  def test_attribute_type
+    assert_equal :string, Account.attribute_type(:name)
+  end
+  
+  def test_allow_settable_id
+    assert_equal false, Account.allow_settable_id
+    assert_raise(CurlyMustache::IdNotSettableError){ Account.create(:id => "123abc") }
+    Account.allow_settable_id!
+    assert_equal "123abc", Account.create(:id => "123abc").id
+  end
+  
+  def test_attributes
+    time = Time.now
+    attributes = { :name => "test", :created_at => time, :updated_at => time }.stringify_keys
+    account = Account.new
+    account.attributes = attributes
+    assert_equal attributes, account.attributes
+  end
+  
+  def test_class_attributes
+    assert_equal %w[id name phone_number balance is_admin created_at updated_at].sort, User.attributes.keys.sort
+    assert_equal %w[id name created_at updated_at].sort, Account.attributes.keys.sort
+    assert_equal :integer, User.attribute_type(:id)
+    assert_equal :string, Account.attribute_type(:id)
+  end
+  
+  def test_set_attributes
+    assert_equal false, Account.allow_settable_id
+    account = Account.new
+    account.send(:set_attributes, :id => "123abc")
+    assert_equal "123abc", account.id
+  end
+  
+  def test_time_type
+    time = Time.now
+    account = Account.new
+    
+    account.created_at = time.to_s(:number)
+    assert_equal Time.parse(time.to_s(:number)), account.created_at
+    
+    account.created_at = time.to_i
+    assert_equal Time.at(time.to_i), account.created_at
+    
+    account.created_at = Object.new
+    assert_equal nil, account.created_at
+  end
+  
+  def test_set_to_nil
+    user = User.new(:phone_number => 5123334444)
+    assert_equal 5123334444, user.phone_number
+    user.phone_number = nil
+    assert_nil user.phone_number
+    
+    account = Account.new(:name => "blah")
+    assert_equal "blah", account.name
+    account.name = nil
+    assert_equal "", account.name
+  end
+  
+  def test_dirty
+    user = User.create(:name => "chris")
+    assert_equal false, user.changed?
+    assert_equal false, user.name_changed?
+    
+    user.name = "callie"
+    assert_equal true, user.changed?
+    assert_equal true, user.name_changed?
+    assert_equal({ "name" => ["chris", "callie"] }, user.changes)
+    
+    user.reset_name!
+    assert_equal false, user.changed?
+    assert_equal false, user.name_changed?
+    assert_equal({}, user.changes)
+    
+    user.name = "callie"
+    user.phone_number = 5123334444
+    assert_equal true, user.changed?
+    assert_equal true, user.name_changed?
+    assert_equal true, user.phone_number_changed?
+    assert_equal({ "name" => ["chris", "callie"], "phone_number" => [nil, 5123334444] }, user.changes)
+    user.reset_phone_number!
+    assert_equal true, user.changed?
+    assert_equal true, user.name_changed?
+    assert_equal false, user.phone_number_changed?
+    assert_equal({ "name" => ["chris", "callie"] }, user.changes)
+  end
+  
+end

data/test/callbacks_test.rb

@@ -0,0 +1,22 @@
+require "test_helper"
+
+class CallbacksTest < ActiveSupport::TestCase
+  
+  def test_callbacks
+    account = Account.create(:name => "blah")
+    assert_equal [:before_validation_on_create, :before_validation, :after_validation, :after_validation_on_create, :before_create, :before_save, :after_save, :after_create], account.callbacks_made
+    
+    account.callbacks_made = []
+    account.save
+    assert_equal [:before_validation_on_update, :before_validation, :after_validation, :after_validation_on_update, :before_update, :before_save, :after_save, :after_update], account.callbacks_made
+    
+    account.callbacks_made = []
+    account = Account.find(account.id)
+    assert_equal [:after_find], account.callbacks_made
+    
+    account.callbacks_made = []
+    account.destroy
+    assert_equal [:before_destroy, :after_destroy], account.callbacks_made
+  end
+  
+end

data/test/crud_test.rb

@@ -0,0 +1,169 @@
+require "test_helper"
+
+class CrudTest < ActiveSupport::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   => Time.parse("2009-04-23 22:09:50 -05:00"),
+      :updated_at   => Time.parse("2009-04-23 22:09:50 -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(user.id)
+    assert_attributes(user)
+  end
+  
+  def test_create_with_autogenerated_id
+    user = User.create(attributes_hash.reject{ |k, v| k == :id })
+    assert user.id != attributes_hash[:id]
+    assert_attributes(user, attributes_hash.merge(:id => user.id))
+  end
+  
+  def test_create_autogenerated_id_by_expectation
+    id = "1341adb122d8190872c2928dbcc08b9d"
+    User.any_instance.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_find_by_id
+    assert_nil User.find_by_id(attributes_hash[:id])
+    User.create(attributes_hash)
+    assert_attributes(User.find_by_id(attributes_hash[:id]))
+  end
+  
+  def test_find_all_by_id
+    1.upto(3) do |i|
+      attributes = attributes_hash
+      attributes[:id] = i
+      User.create(attributes)
+    end
+    user1, user2, user3 = User.find_all_by_id(1, 2, 3)
+    assert_attributes(user1, attributes_hash.merge(:id => 1))
+    assert_attributes(user2, attributes_hash.merge(:id => 2))
+    assert_attributes(user3, attributes_hash.merge(:id => 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])
+    
+    # Strange reload bug where it sets the id to 0.
+    # Ahh, this was happening because attributes_manager wasn't inheriting properly.
+    account = Account.create(:name => "blah")
+    assert_equal 32, (account_id = account.id).length
+    account.reload
+    assert_equal account_id, account.id
+  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
+    user = User.new(attributes_hash)
+    user.save
+    assert_attributes(user.reload)
+    
+    user = User.create(attributes_hash)
+    user.name = "callie"
+    user.save
+    user.reload
+    assert_equal("callie", user.name)
+  end
+  
+  def test_destroy
+    user = User.create(attributes_hash)
+    user.destroy
+    assert(user.frozen?)
+    assert_raise(CurlyMustache::RecordNotFound){ user.reload }
+  end
+  
+end

data/test/locking_test.rb

@@ -0,0 +1,57 @@
+require "test_helper"
+
+unless [:cassandra].include?(CurlyMustache::Base.connection.adapter_name)
+  require "curly_mustache/locking"
+  CurlyMustache::Base.send(:include, CurlyMustache::Locking)
+end
+
+class LockingTest < ActiveSupport::TestCase
+  
+  def setup
+    if CurlyMustache::Base.method_defined?(:lock)
+      CurlyMustache::Base.connection.flush_db
+      @account = Account.create :name => "chris"
+    else
+      disable_tests
+    end
+  end
+  
+  def test_lock_unlock
+    assert !@account.unlock
+    assert  @account.lock
+    assert !@account.lock
+    assert  @account.unlock
+  end
+  
+  def test_lock_with_block
+    assert_equal "chris", @account.lock{ |user| user.name }
+    assert_equal false, @account.locked?
+    assert_equal true, @account.lock
+    assert_equal false, @account.lock{ |user| user.name }
+    assert_equal true, @account.locked?
+    assert_equal true, @account.unlock
+    assert_equal false, @account.locked?
+    @account.lock{ raise "blah" } rescue nil
+    assert_equal false, @account.locked?
+  end
+  
+  def test_lock_with_timeout
+    assert_equal true, @account.lock
+    assert_raise(Timeout::Error){ @account.lock(0.1) }
+    assert_equal true, @account.unlock
+    assert_equal "chris", @account.lock(0.1){ |user| user.name }
+    assert_equal false, @account.unlock
+  end
+  
+  def test_lock_and_find
+    assert_equal true, @account.lock
+    assert_equal false, Account.lock_and_find(@account.id)
+    assert_raise(Timeout::Error){ Account.lock_and_find(@account.id, 0.1) }
+    assert_equal true, @account.unlock
+    assert_equal "chris", Account.lock_and_find(@account.id).name
+    assert_equal true, @account.unlock
+    assert_equal "chris", Account.lock_and_find(@account.id){ |user| user.name }
+    assert_equal false, @account.unlock
+  end
+  
+end