curly_mustache 0.1.0

data/.document

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

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

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,106 @@
+= CurlyMustache
+
+ActiveModel implementation for various data stores.  In other words, it provides an ActiveRecord like library for data stores other than relational databases.  Out of the box, it works with Memcached, Redis, Tokyo Tyrant, Cassandra and Amazon SDB.
+
+http://github.com/cjbottaro/curly_mustache
+
+== Installation
+
+ sudo gem install curly_mustache
+
+CurlyMustache depends on activemodel-3.0.0beta1 and activesupport-3.0.0beta1 which are unfortunately in a state of great flux and are thus very buggy.  I'm hosting patched versions that are known to work with CurlyMustache here:
+
+{activesupport-3.0.0beta1}[http://dl.dropbox.com/u/167916/stochasticbytes/activesupport-3.0.0.beta1.gem]
+
+{activemodel-3.0.0beta1}[http://dl.dropbox.com/u/167916/stochasticbytes/activemodel-3.0.0.beta1.gem]
+
+== Features
+
+* Basic ActiveRecord-like CRUD operations (new, create, destroy, find, save).
+* Validations (via ActiveModel).
+* Callbacks (via ActiveModel).
+* Attribute change tracking (via ActiveModel::Dirty).
+* Easy creation of new types.
+* Easy creation of new adapters (to connect to different data stores).
+* 100% rcov(erage)!
+
+== Quickstart
+
+If your data store speaks Memcached, then you just need to use the <tt>:memcached</tt> adapter.
+
+  CurlyMustache::Base.establish_connection :adapter => :memcached,
+                                           :servers => %w[one.example.com:11211 two.example.com:11211]
+                                           
+  class User < CurlyMustache::Base
+    attribute :name,          :string
+    attribute :login_count,   :integer
+    attribute :birthday,      :time
+    
+    validates_presence_of :name
+    after_validation :capitalize_name
+    
+    def capitalize_name
+      self.name = name.capitalize
+    end
+  end
+  
+  user = User.new :name => "chris"
+  user.new_record?                      # => true
+  user.id                               # => nil
+  user.name                             # => "chris"
+  user.birthday                         # => nil
+  user.birthday = "03/11/1980"
+  user.birthday_changed?                # => true
+  user.birthday.class                   # => Time
+  user.birthday                         # => "Tue Mar 11 00:00:00 -0600 1980"
+  user.save!
+  user.id                               # => "676cef021584904876af7c4b3e42afb5"
+  
+  user = User.find(user.id)
+  user.name                             # => "Chris"
+  
+  user.destroy
+  User.find(user.id)                    # => CurlyMustache::RecordNotFound
+end
+
+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.
+
+== Types
+
+Five types are defined for you:  <tt>string</tt>, <tt>integer</tt>, <tt>float</tt>, <tt>time</tt>, <tt>boolean</tt>.  It is easy to define new types or modify existing ones.  See {Read more}[link:/classes/CurlyMustache/Attributes/Types.html]
+
+== Callbacks
+
+The following callbacks are available:
+ before_validation_on_create    after_validation_on_create
+ before_validation_on_update    after_validation_on_update
+ before_validation              after_validation
+ before_create                  after_create
+ before_update                  after_update
+ before_save                    after_save
+ before_destroy                 after_destroy
+                                after_find
+
+== Adapters
+
+You can use the {Memcached adapter}[link:/classes/CurlyMustache/Adapters/Memcached.html] with any data stores that speak memcached.  There is also the {Cassandra adapter}[link:/classes/CurlyMustache/Adapters/Cassandra.html] and soon to be SDB adapter and Tokyo Tyrant table type adapter.
+
+You can create your own adapters by subclassing CurlyMustache::Adapters::Abstract and implementing a few methods.
+
+== Serializing
+
+If you need to serialize your model's attributes before sending them to the adapter, it's done by overriding {send_attributes}[link:/classes/CurlyMustache/Connection/InstanceMethods.html#M000078].  For deserialization, override {recv_attributes}[/classes/CurlyMustache/Connection/InstanceMethods.html#M000079].
+
+This is how data flows in and out of the data store...
+
+ ---------------------     --------------------------     ---------------      --------------
+ | record.attributes | ==> | record.send_attributes | ==> | adapter.put |  ==> | data store |
+ ---------------------     --------------------------     ---------------      --------------
+
+ ---------------------     --------------------------     ---------------      --------------
+ | record.attributes | <== | record.recv_attributes | <== | adapter.get |  <== | data store |
+ ---------------------     --------------------------     ---------------      --------------
+
+
+== Author
+Christopher J. Bottaro - {cjbottaro}[http://github.com/cjbottaro]

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{ActiveRecord-like interface to various data stores, using ActiveModel.}
+    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 << 'lib' << '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: 1
+:patch: 0

data/curly_mustache.gemspec

@@ -0,0 +1,89 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{curly_mustache}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Christopher J Bottaro"]
+  s.date = %q{2010-02-24}
+  s.email = %q{cjbottaro@alumni.cs.utexas.edu}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc",
+     "TODO"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "TODO",
+     "VERSION.yml",
+     "curly_mustache.gemspec",
+     "lib/curly_mustache.rb",
+     "lib/curly_mustache/adapters.rb",
+     "lib/curly_mustache/adapters/abstract.rb",
+     "lib/curly_mustache/adapters/cassandra.rb",
+     "lib/curly_mustache/adapters/memcached.rb",
+     "lib/curly_mustache/attributes.rb",
+     "lib/curly_mustache/attributes/definition.rb",
+     "lib/curly_mustache/attributes/manager.rb",
+     "lib/curly_mustache/attributes/types.rb",
+     "lib/curly_mustache/base.rb",
+     "lib/curly_mustache/connection.rb",
+     "lib/curly_mustache/crud.rb",
+     "lib/curly_mustache/default_types.rb",
+     "lib/curly_mustache/errors.rb",
+     "lib/curly_mustache/locking.rb",
+     "test/abstract_adapter_test.rb",
+     "test/adapters.yml",
+     "test/attributes_test.rb",
+     "test/callbacks_test.rb",
+     "test/crud_test.rb",
+     "test/locking_test.rb",
+     "test/models/account.rb",
+     "test/models/feed.rb",
+     "test/models/page.rb",
+     "test/models/user.rb",
+     "test/serialization_test.rb",
+     "test/test_helper.rb",
+     "test/types_test.rb",
+     "test/validations_test.rb"
+  ]
+  s.homepage = %q{http://github.com/cjbottaro/curly_mustache}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{ActiveRecord-like interface to various data stores, using ActiveModel.}
+  s.test_files = [
+    "test/abstract_adapter_test.rb",
+     "test/attributes_test.rb",
+     "test/callbacks_test.rb",
+     "test/crud_test.rb",
+     "test/locking_test.rb",
+     "test/models/account.rb",
+     "test/models/feed.rb",
+     "test/models/page.rb",
+     "test/models/user.rb",
+     "test/serialization_test.rb",
+     "test/test_helper.rb",
+     "test/types_test.rb",
+     "test/validations_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/curly_mustache.rb

@@ -0,0 +1,23 @@
+require 'rubygems'
+
+gem "activemodel", "3.0.0.beta1"
+
+require "active_support"
+require "active_support/core_ext"
+require "active_model"
+
+require "digest"
+require "ostruct"
+
+require "curly_mustache/adapters"
+require "curly_mustache/errors"
+require "curly_mustache/connection"
+require "curly_mustache/attributes"
+require "curly_mustache/crud"
+require "curly_mustache/base"
+
+# Load all the default adapters
+require "curly_mustache/adapters/memcached"
+CurlyMustache::Adapters.register(CurlyMustache::Adapters::Memcached)
+require "curly_mustache/adapters/cassandra"
+CurlyMustache::Adapters.register(CurlyMustache::Adapters::Cassandra)

data/lib/curly_mustache/adapters.rb

@@ -0,0 +1,61 @@
+require "curly_mustache/adapters/abstract"
+
+module CurlyMustache
+  # Adapters are how CurlyMustache talks to various data stores.
+  #
+  # You define new adapters by subclassing CurlyMustache::Adapters::Abstract and then calling <tt>CurlyMustache::Adapters.register</tt>.
+  # At a bare minimum, you need to implement +initialize+, +get+, +put+, +delete+.
+  # 
+  # Ex:
+  #  class MyFunkyAdapter < CurlyMustache::Adapters::Abstract
+  #  
+  #    # config is the same hash that is passed to #establish_connection.
+  #    def initialize(config)
+  #      @client = FunkyDataStoreClient.new(config)
+  #    end
+  #  
+  #    def get(key)
+  #      @client.retrieve(key)
+  #    end
+  #  
+  #    def put(key, value)
+  #      @client.store(key, value)
+  #    end
+  #  
+  #    def delete(key)
+  #      @client.destroy(key)
+  #    end
+  #  end
+  #  
+  #  # Now we register the adapter so we can use it in #establish_connection.
+  #  CurlyMustache::Adapters.register(MyFunkyAdapter)
+  #  
+  #  # We can see a list of registered adapters.
+  #  CurlyMustache::Adapters.list # => { :my_funky_adapter => MyFunkyAdapter }
+  #  
+  #  # The hash passed to #establish_connection is passed as config to #initialize.
+  #  CurlyMustache::Base.establish_connection :adapter => :my_funky_adapter, :server => "localhost", :option1 => "blah"
+  module Adapters
+    
+    # Register an adapter class so it can be referenced by name by +establish_connection+.
+    # If the class you are registering is <tt>MyModule::MyClass</tt> then the name it will be registered
+    # under will simply be <tt>:my_class</tt>.
+    def self.register(klass)
+      @registered_adapters ||= {}
+      @registered_adapters[klass.name.split("::").last.underscore.to_sym] = klass
+    end
+    
+    # Returns of hash of all registered adapters where the keys are the registered names.
+    def self.list
+      @registered_adapters.dup
+    end
+    
+    # Get an adapter by registered name.
+    def self.get(name)
+      name = name.to_sym
+      raise ArgumentError, "adapter #{name} is not registered" unless @registered_adapters.has_key?(name)
+      @registered_adapters[name]
+    end
+    
+  end
+end

data/lib/curly_mustache/adapters/abstract.rb

@@ -0,0 +1,86 @@
+module CurlyMustache
+  module Adapters
+    # Subclass this class to make new adapters.
+    #
+    # The required methods for basic functionality are: +new+, +get+, +put+ and +delete+.
+    #
+    # If you want to include CurlyMustache::Locking, then you must implement +lock+ and +unlock+ and <tt>locked?</tt>.
+    #
+    # If you want unit tests to run using your adapter, you must implement +flush_db+.
+    class Abstract
+      # Holds a reference to the class that is currently using this adapter.
+      attr_accessor :model_class
+      
+      ############
+      # REQUIRED #
+      ############
+      
+      # Implementing this is required for basic functionality.
+      # +config+ is passed directly from {#establish_connection}[link:/classes/CurlyMustache/Connection/ClassMethods.html#M000089].
+      def initialize(config)
+        raise NotImplementedError
+      end
+      
+      # Implementing this is required for basic functionality.
+      # The output should be a hash of attributes that will be used to instantiate a model,
+      # or the input of an "in" serializer if one is being used.
+      def get(key)
+        raise NotImplementedError
+      end
+      
+      # Implementing this is required for basic functionality.
+      # +value+ is the model's attributes hash, or the output of an "out" serializer if one is being used.
+      def put(key, value)
+        raise NotImplementedError
+      end
+      
+      # Implementing this is required for basic functionality.
+      def delete(key)
+        raise NotImplementedError
+      end
+      
+      ############
+      # OPTIONAL #
+      ############
+      
+      # Implement this if you want unit tests to run for your adapter.
+      def flush_db
+        raise NotImplementedError
+      end
+      
+      # Implement this if you want to include the <tt>CurlyMustache::Locking<tt> module into your model class.
+      def lock(key)
+        raise NotImplementedError
+      end
+      
+      # Implement this if you want to include the <tt>CurlyMustache::Locking<tt> module into your model class.
+      def unlock(key)
+        raise NotImplementedError
+      end
+      
+      # Implement this if you want to include the <tt>CurlyMustache::Locking<tt> module into your model class.
+      def locked?(key)
+        raise NotImplementedError
+      end
+      
+      ############
+      # PROVIDED #
+      ############
+      
+      # The default implementation of this just iterates over keys calling +get+ on them.  Override this
+      # implementation if your data store has a more efficient way of retrieving multiple keys.  The
+      # return value should be an array of values where each value follow the same rules for the output
+      # of +get+.  Also the order of the values in the array should match the order of the +keys+ argument.
+      def mget(keys)
+        keys.collect{ |key| get(key) }.compact
+      end
+      
+      # This returns the name of the adapter which can be used in {#establish_connection}[link:/classes/CurlyMustache/Connection/ClassMethods.html#M000089].
+      # If your adapter class's name is "MyFunkyAdapter", then this method will return <tt>:my_funky_adapter</tt>.
+      def adapter_name
+        @adapter_name ||= self.class.name.split("::").last.underscore.to_sym
+      end
+      
+    end
+  end
+end