curly_mustache 0.1.0

data/lib/curly_mustache/adapters/cassandra.rb

@@ -0,0 +1,35 @@
+require 'cassandra'
+
+module CurlyMustache
+  module Adapters
+    class Cassandra < Abstract
+      
+      def initialize(options)
+        @client = ::Cassandra.new(options[:keyspace], options[:servers])
+        @column_family = options[:column_family]
+      end
+      
+      def column_family
+        @column_family || model_class.name.pluralize.to_sym
+      end
+      
+      def put(key, value)
+        @client.insert(column_family, key, value)
+      end
+      
+      def get(key)
+        result = @client.get(column_family, key)
+        result.empty? ? nil : result
+      end
+      
+      def delete(key)
+        @client.remove(column_family, key)
+      end
+      
+      def flush_db
+        @client.clear_keyspace!
+      end
+      
+    end
+  end
+end

data/lib/curly_mustache/adapters/memcached.rb

@@ -0,0 +1,56 @@
+require 'memcache'
+
+module CurlyMustache
+  module Adapters
+    # You can use this adapter with any data store that speaks Memcached.  The adapter uses
+    # {memcache-client}[http://github.com/mperham/memcache-client].  The <tt>:servers</tt> key in
+    # the hash passed to CurlyMustache::Base#establish_connection will be the first argument to
+    # <tt>MemCache.new</tt> and entire hash will be passed as the second argument.
+    class Memcached < Abstract
+      
+      # <tt>config[:servers]</tt> will be passed as the first argument to <tt>MemCache.new</tt> and
+      # <tt>config</tt> itself will be passed as the second argument.
+      def initialize(config)
+        config = config.reverse_merge :servers => "localhost:11211"
+        @cache = MemCache.new(config[:servers], config)
+      end
+      
+      def get(key)
+        @cache.get(key)
+      end
+      
+      def mget(keys)
+        keys = keys.collect(&:to_s)
+        results = @cache.get_multi(*keys)
+        results = results.collect{ |k, v| [k, v] }
+        results.sort.collect{ |result| result[1] }
+      end
+      
+      def put(key, value)
+        @cache.set(key, value)
+      end
+      
+      def delete(key)
+        @cache.delete(key)
+      end
+      
+      def flush_db
+        @cache.flush_all
+      end
+      
+      def lock(key, options = {})
+        expires_in = options[:expires_in] || 0
+        @cache.add(key, Time.now.to_s(:number), expires_in) == "STORED\r\n"
+      end
+      
+      def unlock(key)
+        delete(key) == "DELETED\r\n"
+      end
+      
+      def locked?(key)
+        !!@cache.get(key)
+      end
+      
+    end
+  end
+end

data/lib/curly_mustache/attributes.rb

@@ -0,0 +1,85 @@
+require "curly_mustache/attributes/manager"
+
+module CurlyMustache
+  
+  # It looks like typecasting happens at assignment for ActiveRecord, so we're just going to follow that.
+  #   user.account_id = "test"
+  #   user.account_id
+  #   => 0
+  module Attributes
+  
+    def self.included(mod)
+      mod.class_eval do
+        class_inheritable_accessor :attribute_manager
+        class_inheritable_accessor :allow_settable_id
+      end
+      mod.attribute_manager = Manager.new
+      mod.send(:extend,  ClassMethods)
+      mod.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      
+      def attribute(name, type, options = {})
+        attribute_manager.define(self, name, type, options)
+      end
+      
+      def attributes
+        attribute_manager.definitions
+      end
+      
+      def attribute_type(name)
+        attribute_manager[name].type
+      end
+      
+      def allow_settable_id!(settable = true)
+        self.allow_settable_id = settable
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      def attributes=(hash)
+        hash.stringify_keys.each{ |k, v| write_attribute(k, v) }
+      end
+      
+      def attributes
+        @attributes.dup
+      end
+      
+      def read_attribute(name)
+        @attributes[name.to_s]
+      end
+      
+      def write_attribute(name, value)
+        send("#{name}_will_change!") # ActiveModel::Dirty
+        @attributes[name.to_s] = value
+      end
+      
+      def write_attribute_with_typecast(name, value)
+        casted_value = attribute_manager[name].cast(value)
+        write_attribute_without_typecast(name, casted_value)
+      end
+      
+      alias_method_chain :write_attribute, :typecast
+      
+      def write_attribute_with_id_guard(name, value)
+        raise IdNotSettableError, "not allowed to set id" if name.to_s == "id" and !allow_settable_id
+        write_attribute_without_id_guard(name, value)
+      end
+      
+      alias_method_chain :write_attribute, :id_guard
+      
+    private
+      
+      # This is like #attributes= but allows for setting the id.  It's intended to be used
+      # internally by methods like #read.
+      def set_attributes(hash)
+        hash.stringify_keys.each{ |k, v| write_attribute_without_id_guard(k, v) }
+      end
+      
+    end
+  
+  end
+end

data/lib/curly_mustache/attributes/definition.rb

@@ -0,0 +1,24 @@
+module CurlyMustache
+  module Attributes
+    class Definition
+      attr_reader :name, :type
+      
+      def initialize(name, type, options = {})
+        @options = options.symbolize_keys.reverse_merge :default => nil,
+                                                        :allow_nil => true
+        @name = name.to_sym
+        @type = type.to_sym
+        @caster = Types[type].caster
+      end
+      
+      def cast(value)
+        if value.nil? and @options[:allow_nil]
+          nil
+        else
+          @caster.call(value)
+        end
+      end
+      
+    end
+  end
+end

data/lib/curly_mustache/attributes/manager.rb

@@ -0,0 +1,41 @@
+require "curly_mustache/attributes/types"
+require "curly_mustache/attributes/definition"
+
+module CurlyMustache
+  module Attributes
+    class Manager
+      attr_reader :definitions
+      
+      def initialize
+        @definitions = {}
+      end
+      
+      def define(klass, name, type, options = {})
+        @definitions[name.to_s] = Definition.new(name, type, options)
+        
+        klass.class_eval <<-eval
+          def #{name}; read_attribute(:#{name}); end
+          def #{name}=(value); write_attribute(:#{name}, value); end
+        eval
+        
+        # This is so ghetto, but these are the hoops we have to jump through
+        # to get ActiveModel::Dirty working with inheritance.
+        klass.undefine_attribute_methods
+        klass.define_attribute_methods(@definitions.keys.collect(&:to_sym))
+      end
+      
+      def [](name)
+        name = name.to_s
+        raise AttributeNotDefinedError, "#{name} is not defined" unless @definitions.has_key?(name)
+        @definitions[name]
+      end
+      
+      def dup
+        returning(self.class.new) do |new_manager|
+          new_manager.instance_variable_set("@definitions", @definitions.dup)
+        end
+      end
+      
+    end
+  end
+end

data/lib/curly_mustache/attributes/types.rb

@@ -0,0 +1,49 @@
+module CurlyMustache
+  module Attributes
+    # <tt>CurlyMustache</tt> comes with 5 types predefined:  string, integer, float, time, boolean.
+    # You can redefine any of them or add new type defintions.  To define a type is simply to define
+    # how a value gets typecasted.
+    #  CurlyMustache::Attributes::Types.define(:capitalized_string) do |value|
+    #    value.capitalize
+    #  end
+    # Now if you have a user class...
+    #  class User < CurlyMustache::Base
+    #    attribute :name, :string
+    #    attribute :title, :capitalized_string
+    #  end
+    # And you can see the new type in action...
+    #  user = User.new
+    #  user.name = "chris"
+    #  user.title = "mr"
+    #  user.name                  # => "chris"
+    #  user.title                 # => "Mr"
+    #  user.title = 123           # NoMethodError: undefined method `capitalize' for 123:Fixnum
+    module Types
+      
+      # Gets a hash of all type defintions.  The keys will be the type names and they will always be strings.
+      def self.definitions
+        @definitions ||= {}
+      end
+      
+      # Clear all type defintions (including the defaults).
+      def self.clear
+        @definitions = {}
+      end
+      
+      # Define a type.  The block takes a single argument which is the raw value and should return
+      # the typecasted value.
+      def self.define(name, &block)
+        definitions[name.to_s] = OpenStruct.new(:name => name, :caster => block)
+      end
+      
+      # Similar to <tt>CurlyMustache::Attributes::Types.defintions[name]</tt> but is indifferent to
+      # whether +name+ is a string or symbol and will raise an exception if +name+ is not a defined.
+      def self.[](name)
+        name = name.to_s
+        raise TypeError, "type #{name} is not defined" unless definitions.has_key?(name)
+        definitions[name]
+      end
+      
+    end
+  end
+end

data/lib/curly_mustache/base.rb

@@ -0,0 +1,36 @@
+require "curly_mustache/default_types"
+
+module CurlyMustache
+  class Base
+    
+    include Connection
+    include Attributes
+    include Crud
+    
+    extend ActiveModel::Callbacks
+    include ActiveModel::Validations
+    include ActiveModel::Dirty
+    
+    define_model_callbacks :create, :destroy, :save, :update, :validation, :validation_on_create, :validation_on_update, :only => [:before, :after]
+    define_model_callbacks :find, :only => :after
+    
+    # Set this to true if you want to set your own ids as opposed to having CurlyMustache
+    # automatically generate them for you.  Ex:
+    #   class User
+    #     self.allow_settable_id = true
+    #     attribute :name, :string
+    #   end
+    #   User.create(:id => 123, :name => "blah")
+    #   User.find(123)
+    allow_settable_id!(false)
+    
+    attribute :id, :string
+    
+    def ==(other)
+      self.attributes  == other.attributes and
+      self.new_record? == other.new_record?
+    end
+    
+  end
+  
+end

data/lib/curly_mustache/connection.rb

@@ -0,0 +1,65 @@
+module CurlyMustache
+  # NOTE: The way this is implemented makes CurlyMustache not thread safe!
+  # 
+  # You are probably looking for {establish_connection}[link:/classes/CurlyMustache/Connection/ClassMethods.html#M000084].
+  module Connection
+    
+    def self.included(mod) # :nodoc:
+      mod.class_eval do
+        class_inheritable_accessor :_connection
+      end
+      mod.send(:extend,  ClassMethods)
+      mod.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      
+      # Establishes a connection using the adapter specified in <tt>config[:adapter]</tt>.
+      # If you call +establish_connection+ on CurlyMustache::Base, then all models will
+      # use that connection unless +establish_connection+ is called directly on a model class.
+      # Note that +config+ itself is passed to the adapter's constructor.
+      # 
+      # Ex:
+      #   CurlyMustache::Base.establish_connection(:adapter => :memcached, :servers => "localhost:11211")
+      def establish_connection(config)
+        config = config.symbolize_keys
+        self._connection = Adapters.get(config[:adapter]).new(config)
+      end
+      
+      def connection # :nodoc:
+        _connection.model_class = self
+        _connection
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      # Override this method if you want to massage the data that is sent to the adapter.
+      #
+      # +attributes+ is the same as <tt>self.attributes</tt>.
+      #
+      # Return value will be sent to the adapter's +put+ method.
+      def send_attributes(attributes)
+        attributes
+      end
+      
+      # Override this method if you want to massage the data that is received from the adapter.
+      #
+      # +attributes+ is what is returned from the adapter's +get+ method.
+      #
+      # Return value will be assigned to <tt>self.attributes</tt>.
+      def recv_attributes(attributes)
+        attributes
+      end
+      
+    private
+      
+      def connection # :nodoc:
+        self.class.connection
+      end
+      
+    end
+    
+  end
+end

data/lib/curly_mustache/crud.rb

@@ -0,0 +1,244 @@
+module CurlyMustache
+  
+  module Crud
+    
+    def self.included(mod) # :nodoc:
+      mod.send(:extend,  ClassMethods)
+      mod.send(:include, InstanceMethods)
+    end
+    
+    module ClassMethods
+      
+      # Create a record and save it to the data store.  Returns a record with errors if validation fails.
+      def create(attributes = {})
+        returning(new) do |record|
+          record.attributes = attributes
+          record.save
+        end
+      end
+      
+      # Create a record and save it to the data store.  Raises RecordInvalid if validation fails.
+      def create!(attributes = {})
+        returning(create(attributes)) do |record|
+          record.errors.count > 0 and raise(RecordInvalid, "Validation failed: #{record.errors.full_messages.join(', ')}")
+        end
+      end
+      
+      # Find by id.  Can take multiple ids.  Raise RecordNotFound if not all ids are found.
+      def find(*ids)
+        ids = [ids].flatten
+        if ids.length == 1
+          find_one(ids.first)
+        else
+          find_many(ids, :raise)
+        end
+      end
+      
+      # Find multiple records by ids.  May return an array with less records
+      # than ids asked for or an empty array.
+      def find_all_by_id(*ids)
+        ids = [ids].flatten
+        find_many(ids)
+      end
+      
+      # Find a single record by id.  Returns nil if record is not found.
+      def find_by_id(id)
+        find_one(id)
+      rescue RecordNotFound
+        nil
+      end
+      
+      # Deletes records by ids without instantiating them first, thus the
+      # *_destroy callbacks won't be invoked.
+      def delete_all(*ids)
+        ids_to_keys(ids).each{ |key| connection.delete(key) }
+      end
+      
+      # Instantiate records then calls destroy on them.
+      def destroy_all(*ids)
+        find(ids).each{ |record| record.destroy }
+      end
+    
+    private
+      
+      def id_to_key(id)
+        raise NoKeyError if id.blank?
+        "#{self}:#{id}"
+      end
+      
+      def ids_to_keys(ids)
+        [ids].flatten.collect{ |id| id_to_key(id) }
+      end
+      
+      def find_one(id)
+        raise RecordNotFound, "Couldn't find #{name} without an ID" if id.blank?
+        new.send(:read, :id => id)
+      end
+      
+      def find_many(ids, should_raise = false)
+        hashes = connection.mget(ids_to_keys(ids))
+        if should_raise and ids.length != hashes.length
+          raise RecordNotFound, find_many_error_message(ids, hashes)
+        else
+          ids.zip(hashes).collect do |id, attributes|
+            record = new
+            record.send(:read, :attributes => record.send(:recv_attributes, attributes))
+            record
+          end
+        end
+      end
+      
+      def find_many_error_message(ids, hashes)
+        ids_string = ids.join(",")
+        models_name = name.pluralize
+        found, wanted = hashes.length, ids.length
+        "Couldn't find all #{models_name} with IDs (#{ids_string}) (found #{found} results, but was looking for #{wanted})"
+      end
+      
+    end
+    
+    module InstanceMethods
+      
+      # Make a new record in memory with supplied attributes.
+      def initialize(attributes = {})
+        @attributes = {}
+        @new_record = true
+        self.attributes = attributes
+      end
+      
+      # Returns true if the record has been saved yet.
+      def new_record?
+        !!@new_record
+      end
+      
+      # Reload the record from the data store, overwriting any attribute changes.
+      def reload
+        returning(self){ read }
+      end
+      
+      # Save the record to the data store.  Returns false if validation fails.
+      def save
+        new_record? ? create : update
+        (errors.count > 0) ? false : self
+      end
+      
+      # Save the record to the data store.  Raises RecordInvalid if validation fails.
+      def save!
+        returning(save) do
+          errors.count > 0 and raise(RecordInvalid, "Validation failed: #{errors.full_messages.join(', ')}")
+        end
+      end
+      
+      # Delete a record from the data store, invoking the *_destroy callbacks.
+      def destroy
+        delete
+      end
+      
+    private
+      
+      def generate_id
+        Digest::MD5.hexdigest(rand.to_s + Time.now.to_s)
+      end
+      
+      def id_to_key(id)
+        self.class.send(:id_to_key, id)
+      end
+      
+      def key
+        id_to_key(id)
+      end
+      
+      def create
+        @attributes["id"] = generate_id if id.blank?
+        update_without_callbacks
+      end
+      
+      def create_with_callbacks
+        _run_validation_on_create_callbacks do
+          _run_validation_callbacks do
+            valid? or return
+          end
+        end
+          
+        _run_create_callbacks do
+          _run_save_callbacks do
+            create_without_callbacks
+          end
+        end
+      end
+      
+      alias_method_chain :create, :callbacks
+      
+      def read(options = {})
+        options = options.reverse_merge :id => nil,
+                                        :attributes => nil,
+                                        :keep_new => false
+        
+        if options[:attributes]
+          set_attributes(options[:attributes])
+        else
+          if options[:id]
+            _id, _key = options[:id], id_to_key(options[:id])
+          else
+            _id, _key = id, key
+          end
+          attributes = recv_attributes(connection.get(_key)) || raise(RecordNotFound, "Couldn't find #{self.class.name} with ID=#{_id}")
+          set_attributes(attributes)
+        end
+        
+        @new_record = options[:keep_new]
+        
+        self
+      end
+      
+      def read_with_callbacks(*args)
+        _run_find_callbacks do
+          read_without_callbacks(*args)
+        end
+      end
+      
+      alias_method_chain :read, :callbacks
+      
+      def update
+        connection.put(key, send_attributes(attributes))
+        @new_record = false
+        
+        # ActiveModel::Dirty
+        previously_changed_attributes.replace(changes)
+        changed_attributes.clear
+      end
+      
+      def update_with_callbacks
+        _run_validation_on_update_callbacks do
+          _run_validation_callbacks do
+            valid? or return
+          end
+        end
+        
+        _run_update_callbacks do
+          _run_save_callbacks do
+            update_without_callbacks
+          end
+        end
+      end
+      
+      alias_method_chain :update, :callbacks
+      
+      def delete
+        connection.delete(key)
+        freeze
+      end
+      
+      def delete_with_callbacks
+        _run_destroy_callbacks do
+          delete_without_callbacks
+        end
+      end
+      
+      alias_method_chain :delete, :callbacks
+      
+    end # end module InstanceMethods
+    
+  end
+  
+end