speedmax-couch_potato 0.2.0

data/MIT-LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2007 Bryan Helmkamp, Seth Fitzsimmons
+
+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.md

@@ -0,0 +1,260 @@
+## Couch Potato
+
+... is a persistence layer written in ruby for CouchDB.
+
+### Mission
+
+The goal of Couch Potato is to create a minimal framework in order to store and retrieve Ruby objects to/from CouchDB and create and query views.
+
+It follows the document/view/querying semantics established by CouchDB and won't try to mimic ActiveRecord behavior in any way as that IS BAD.
+
+Code that uses Couch Potato should be easy to test.
+
+Lastly Couch Potato aims to provide a seamless integration with Ruby on Rails, e.g. routing, form helpers etc.
+
+### Core Features
+
+* persisting objects by including the CouchPotato::Persistence module
+* declarative views with either custom or generated map/reduce functions
+* extensive spec suite
+
+### Installation
+
+Couch Potato requires Ruby 1.9.
+
+Couch Potato is hosted as a gem on github which you can install like this:
+
+    sudo gem source --add http://gems.github.com # if you haven't already
+    sudo gem install langalex-couch_potato
+  
+#### Using with your ruby application:
+
+    require 'rubygems'
+    gem 'langalex-couch_potato'
+    require 'couch_potato'
+    CouchPotato::Config.database_name = 'name of the db'
+  
+Alternatively you can download or clone the source repository and then require lib/couch_potato.rb. 
+
+#### Using with Rails
+
+Add to your config/environment.rb:
+
+    config.gem 'langalex-couch_potato', :lib => 'couch_potato', :source => 'http://gems.github.com'
+
+Then create a config/couchdb.yml:
+
+    development: development_db_name
+    test: test_db_name
+    production: http://db.server/production_db_name
+
+Alternatively you can also install Couch Potato directly as a plugin. 
+
+### Introduction
+
+This is a basic tutorial on how to use Couch Potato. If you want to know all the details feel free to read the specs.
+
+#### Save, load objects
+
+First you need a class.
+
+    class User
+    end
+
+To make instances of this class persistent include the persistence module:
+
+    class User
+      include CouchPotato::Persistence
+    end
+
+If you want to store any properties you have to declare them:
+
+    class User
+      include CouchPotato::Persistence
+    
+      property :name
+    end
+  
+Properties can be of any type:
+
+    class User
+      include CouchPotato::Persistence
+    
+      property :address, :type => Address
+    end
+
+Now you can save your objects. All database operations are encapsulated in the CouchPotato::Database class. This separates your domain logic from the database access logic which makes it easier to write tests and also keeps you models smaller and cleaner.
+
+    user = User.new :name => 'joe'
+    CouchPotato.database.save_document user # or save_document!
+  
+You can of course also retrieve your instance:
+
+    CouchPotato.database.load_document "id_of_the_user_document" # => <#User 0x3075>
+
+
+#### Properties
+
+You can access the properties you declared above through normal attribute accessors.
+
+    user.name # => 'joe'
+    user.name = {:first => ['joe', 'joey'], :last => 'doe', :middle => 'J'} # you can set any ruby object that responds_to :to_json (includes all core objects)
+    user._id # => "02097f33a0046123f1ebc0ebb6937269"
+    user._rev # => "2769180384"
+    user.created_at # => Fri Oct 24 19:05:54 +0200 2008
+    user.updated_at # => Fri Oct 24 19:05:54 +0200 2008
+    user.new? # => false
+  
+If you want to have properties that don't map to any JSON type, i.e. other than String, Number, Boolean, Hash or Array you have to define the type like this:
+
+    class User
+      property :date_of_birth, :type => Date
+    end
+  
+The date_of_birth property is now automatically serialized to JSON and back when storing/retrieving objects.
+
+#### Dirty tracking
+
+CouchPotato tracks the dirty state of attributes in the same way ActiveRecord does:
+
+    user = User.create :name => 'joe'
+    user.name # => 'joe'
+    user.name_changed? # => false
+    user.name_was # => nil
+  
+You can also force a dirty state:
+  
+    user.name = 'jane'
+    user.name_changed? # => true
+    user.name_not_changed
+    user.name_changed? # => false
+    CouchPotato.database.save_document user # does nothing as no attributes are dirty
+  
+
+#### Object validations
+
+Couch Potato uses the validatable library for vaidation (http://validatable.rubyforge.org/)\
+
+    class User
+      property :name
+      validates_presence_of :name
+    end
+
+    user = User.new
+    user.valid? # => false
+    user.errors.on(:name) # => [:name, 'can't be blank']
+
+#### Finding stuff
+
+In order to find data in your CouchDB you have to create a view first. Couch Potato offers you to create and manage those views for you. All you have to do is declare them in your classes:
+
+    class User
+      include CouchPotato::Persistence
+      property :name
+    
+      view :all, :key => :created_at
+    end
+  
+This will create a view called "all" in the "user" design document with a map function that emits "created_at" for every user document.
+  
+    CouchPotato.database.view User.all
+
+This will load all user documents in your database sorted by created_at.
+
+    CouchPotato.database.view User.all(:key => (Time.now- 10)..(Time.now), :descending => true)
+
+Any options you pass in will be passed onto CouchDB.
+
+Composite keys are also possible:
+
+    class User
+      property :name
+    
+      view :all, :key => [:created_at, :name]
+    end
+  
+The creation of views is based on view specification classes (see the CouchPotato::View) module. The above code used the ModelViewSpec class which is used to the simple find model by property searches. For more sophisticated searches you can use other view specifications (either use the built-in or provide your own) by passing a type parameter:
+
+If you have larger structures and you only want to load some attributes you can customize the view you can use the PropertiesViewSpec (the full class name is automatically derived):
+
+    class User
+      property :name
+      property :bio
+    
+      view :all, :key => :created_at, :properties => [:name], :type => :properties
+    end
+  
+  CouchPotato.database.view(User.everyone).first.name # => "joe"
+  CouchPotato.database.view(User.everyone).first.bio # => nil
+  
+You can also pass in custom map/reduce functions with the custom view spec:
+
+    class User
+      view :all, :map => "function(doc) { emit(doc.created_at, null)}", :include_docs => true, :type => :custom
+    end
+  
+If you don't want the results to be converted into models the raw view is your friend:
+
+    class User
+      view :all, :map => "function(doc) { emit(doc.created_at, doc.name)}", :type => :raw
+    end
+  
+When querying this view you will get the raw data returned by CouchDB which looks something like this: {'total_entries': 2, 'rows': [{'value': 'alex', 'key': '2009-01-03 00:02:34 +000', 'id': '75976rgi7546gi02a'}]}
+
+To process this raw data you can also pass in a results filter:
+
+    class User
+      view :all, :map => "function(doc) { emit(doc.created_at, doc.name)}", :type => :raw, :results_filter => lambda {|results| results['rows'].map{|row| row['value']}}
+    end
+
+In this case querying the view would only return the emitted value for each row.
+
+#### Associations
+
+Not supported. Not sure if they ever will be. You can implement those yourself using views and custom methods on your models.
+
+#### Callbacks
+
+Couch Potato supports the usual lifecycle callbacks known from ActiveRecord:
+
+    class User
+      include CouchPotato::Persistence
+    
+      before_create :do_something_before_create
+      after_update :do_something_else
+    end
+
+This will call the method do_something_before_create before creating an object and do_something_else after updating one. Supported callbacks are: :before_validation_on_create, :before_validation_on_update, :before_validation_on_save, :before_create, :after_create, :before_update, :after_update, :before_save, :after_save, :before_destroy, :after_destroy. You can also pass a Proc instead of a method name.
+
+#### Testing  
+
+To make testing easier and faster database logic has been put into its own class, which you can replace and stub out in whatever way you want:
+
+    class User
+      include CouchPotato::Persistence
+    end
+  
+    # RSpec
+    describe 'save a user' do
+      it 'should save' do
+        couchrest_db = stub 'couchrest_db', 
+        database = CouchPotato::Database.new couchrest_db
+        user = User.new
+        couchrest_db.should_receive(:save_doc).with(...)
+        database.save_document user
+      end
+    end
+    
+By creating you own instances of CouchPotato::Database and passing them a fake CouchRest database instance you can completely disconnect your unit tests/spec from the database.
+
+### Helping out
+
+Please fix bugs, add more specs, implement new features by forking the github repo at http://github.com/langalex/couch_potato.
+
+You can run all the specs by calling 'rake spec_unit' and 'rake spec_functional' in the root folder of Couch Potato. The specs require a running CouchDB instance at http://localhost:5984
+
+I will only accept patches that are covered by specs - sorry.
+
+### Contact
+
+If you have any questions/suggestions etc. please contact me at alex at upstream-berlin.com or @langalex on twitter.

data/VERSION.yml

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

data/init.rb

@@ -0,0 +1,3 @@
+# this is for rails only
+
+require File.dirname(__FILE__) + '/rails/init'

data/lib/core_ext/date.rb

@@ -0,0 +1,10 @@
+class Date
+  def to_json(*a)
+    %("#{strftime("%Y/%m/%d")}")
+  end
+  
+  def self.json_create string
+    return nil if string.nil?
+    Date.parse(string)
+  end
+end

data/lib/core_ext/object.rb

@@ -0,0 +1,5 @@
+Object.class_eval do
+  def try(method, *args)
+    self.send method, *args if self.respond_to?(method)
+  end
+end

data/lib/core_ext/string.rb

@@ -0,0 +1,15 @@
+module ActiveSupportMethods
+  def camelize
+    sub(/^([a-z])/) {$1.upcase}.gsub(/_([a-z])/) do
+      $1.upcase
+    end
+  end
+  
+  def underscore
+    gsub(/([A-Z])/) do
+      '_' + $1.downcase
+    end.sub(/^_/, '')
+  end
+end
+
+String.send :include, ActiveSupportMethods #unless String.new.respond_to?(:camelize)

data/lib/core_ext/time.rb

@@ -0,0 +1,11 @@
+class Time
+  def to_json(*a)
+    %("#{strftime("%Y/%m/%d %H:%M:%S +0000")}")
+  end
+  
+  def self.json_create string
+    return nil if string.nil?
+    d = DateTime.parse(string).new_offset
+    self.utc(d.year, d.month, d.day, d.hour, d.min, d.sec)
+  end
+end

data/lib/couch_potato/database.rb

@@ -0,0 +1,90 @@
+module CouchPotato
+  class Database
+    
+    class ValidationsFailedError < ::Exception; end
+  
+    def initialize(couchrest_database)
+      @database = couchrest_database
+    end
+    
+    def view(spec)
+      results = CouchPotato::View::ViewQuery.new(database,
+        spec.design_document, spec.view_name, spec.map_function,
+        spec.reduce_function).query_view!(spec.view_parameters)
+      spec.process_results results
+    end
+  
+    def save_document(document)
+      return unless document.dirty?
+      if document.new?
+        create_document document
+      else
+        update_document document
+      end
+    end
+    alias_method :save, :save_document
+  
+    def save_document!(document)
+      save_document(document) || raise(ValidationsFailedError.new(document.errors.full_messages))
+    end
+    alias_method :save!, :save_document!
+  
+    def destroy_document(document)
+      document.run_callbacks(:before_destroy)
+      document._deleted = true
+      database.delete_doc document.to_hash
+      document.run_callbacks(:after_destroy)
+      document._id = nil
+      document._rev = nil
+    end
+    alias_method :destroy, :destroy_document
+  
+    def load_document(id)
+      begin
+        json = database.get(id)
+        Class.const_get(json['ruby_class']).json_create json
+      rescue(RestClient::ResourceNotFound)
+        nil
+      end
+    end
+    alias_method :load, :load_document
+  
+    def inspect
+      "#<CouchPotato::Database>"
+    end
+  
+    private
+  
+    def create_document(document)
+      document.run_callbacks :before_validation_on_save
+      document.run_callbacks :before_validation_on_create
+      return unless document.valid?
+      document.run_callbacks :before_save
+      document.run_callbacks :before_create
+      res = database.save_doc document.to_hash
+      document._rev = res['rev']
+      document._id = res['id']
+      document.run_callbacks :after_save
+      document.run_callbacks :after_create
+      true
+    end
+  
+    def update_document(document)
+      document.run_callbacks(:before_validation_on_save)
+      document.run_callbacks(:before_validation_on_update)
+      return unless document.valid?
+      document.run_callbacks :before_save
+      document.run_callbacks :before_update
+      res = database.save_doc document.to_hash
+      document._rev = res['rev']
+      document.run_callbacks :after_save
+      document.run_callbacks :after_update
+      true
+    end
+  
+    def database
+      @database
+    end
+  
+  end
+end

data/lib/couch_potato/persistence/belongs_to_property.rb

@@ -0,0 +1,58 @@
+module CouchPotato
+  module Persistence
+    class BelongsToProperty
+      attr_accessor :name
+      
+      def initialize(owner_clazz, name, options = {})
+        self.name = name
+        accessors =  <<-ACCESSORS
+          def #{name}
+            return @#{name} if instance_variable_defined?(:@#{name})
+            @#{name} = @#{name}_id ? #{item_class_name}.find(@#{name}_id) : nil
+          end
+          
+          def #{name}=(value)
+            @#{name} = value
+            if value.nil?
+              @#{name}_id = nil
+            else
+              @#{name}_id = value.id
+            end
+          end
+          
+          def #{name}_id=(id)
+            remove_instance_variable(:@#{name}) if instance_variable_defined?(:@#{name})
+            @#{name}_id = id
+          end
+        ACCESSORS
+        owner_clazz.class_eval accessors
+        owner_clazz.send :attr_reader, "#{name}_id"
+      end
+      
+      def save(object)
+        
+      end
+      
+      def dirty?(object)
+        false
+      end
+      
+      def destroy(object)
+        
+      end
+      
+      def build(object, json)
+        object.send "#{name}_id=", json["#{name}_id"]
+      end
+      
+      def serialize(json, object)
+        json["#{name}_id"] = object.send("#{name}_id") if object.send("#{name}_id")
+      end
+      
+      def item_class_name
+        @name.to_s.camelize
+      end
+      
+    end
+  end
+end

data/lib/couch_potato/persistence/callbacks.rb

@@ -0,0 +1,108 @@
+module CouchPotato
+  module Persistence
+    module Callbacks
+      def self.included(base)
+        base.extend ClassMethods
+        
+        base.class_eval do
+          attr_accessor :skip_callbacks
+          def self.callbacks
+            @callbacks ||= {}
+            @callbacks[self.name] ||= {:before_validation_on_create => [], 
+              :before_validation_on_update => [], :before_validation_on_save => [], :before_create => [], 
+              :after_create => [], :before_update => [], :after_update => [],
+              :before_save => [], :after_save => [],
+              :before_destroy => [], :after_destroy => []}
+          end
+        end
+      end
+      
+      def run_callbacks(name)
+        return if skip_callbacks
+        self.class.callbacks[name].uniq.each do |callback|
+          run_callback callback
+        end
+      end
+      
+      private
+      
+      def run_callback(name)
+        if name.is_a?(Symbol)
+          self.send name
+        elsif name.is_a?(Proc)
+          name.call self
+        else
+          raise "Don't know how to handle callback of type #{name.class.name}"
+        end
+      end
+      
+      module ClassMethods
+        def before_validation_on_create(*names)
+          names.each do |name|
+            callbacks[:before_validation_on_create] << name
+          end
+        end
+        
+        def before_validation_on_update(*names)
+          names.each do |name|
+            callbacks[:before_validation_on_update] << name
+          end
+        end
+        
+        def before_validation_on_save(*names)
+          names.each do |name|
+            callbacks[:before_validation_on_save] << name
+          end
+        end
+        
+        def before_create(*names)
+          names.each do |name|
+            callbacks[:before_create] << name
+          end
+        end
+        
+        def before_save(*names)
+          names.each do |name|
+            callbacks[:before_save] << name
+          end
+        end
+        
+        def before_update(*names)
+          names.each do |name|
+            callbacks[:before_update] << name
+          end
+        end
+        
+        def before_destroy(*names)
+          names.each do |name|
+            callbacks[:before_destroy] << name
+          end
+        end
+
+        def after_update(*names)
+          names.each do |name|
+            callbacks[:after_update] << name
+          end
+        end
+        
+        def after_save(*names)
+          names.each do |name|
+            callbacks[:after_save] << name
+          end
+        end
+        
+        def after_create(*names)
+          names.each do |name|
+            callbacks[:after_create] << name
+          end
+        end
+
+        def after_destroy(*names)
+          names.each do |name|
+            callbacks[:after_destroy] << name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/dirty_attributes.rb

@@ -0,0 +1,26 @@
+module CouchPotato
+  module Persistence
+    module DirtyAttributes
+      
+      def self.included(base)
+        base.class_eval do
+          after_save :reset_dirty_attributes
+        end
+      end
+      
+      def dirty?
+        new? || self.class.properties.inject(false) do |res, property|
+          res || property.dirty?(self)
+        end
+      end
+      
+      private
+      
+      def reset_dirty_attributes
+        self.class.properties.each do |property|
+          instance_variable_set("@#{property.name}_was", send(property.name))
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/inline_collection.rb

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/collection'
+
+module CouchPotato
+  module Persistence
+    class InlineCollection < Collection
+      
+      def to_json(*args)
+        @items.to_json(*args)
+      end
+      
+    end
+  end
+end
+

data/lib/couch_potato/persistence/json.rb

@@ -0,0 +1,41 @@
+module CouchPotato
+  module Persistence
+    module Json
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      
+      def to_json(*args)
+        to_hash.to_json(*args)
+      end
+      
+      def to_hash
+        (self.class.properties).inject({}) do |props, property|
+          property.serialize(props, self)
+          props
+        end.merge('ruby_class' => self.class.name).merge(id_and_rev_json)
+      end
+      
+      private
+      
+      def id_and_rev_json
+        ['_id', '_rev', '_deleted'].inject({}) do |hash, key|
+          hash[key] = self.send(key) unless self.send(key).nil?
+          hash
+        end
+      end
+      
+      module ClassMethods
+        def json_create(json)
+          instance = self.new
+          instance._id = json[:_id] || json['_id']
+          instance._rev = json[:_rev] || json['_rev']
+          properties.each do |property|
+            property.build(instance, json)
+          end
+          instance
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/magic_timestamps.rb

@@ -0,0 +1,13 @@
+module CouchPotato
+  module MagicTimestamps
+    def self.included(base)
+      base.instance_eval do
+        property :created_at, :type => Time
+        property :updated_at, :type => Time
+        
+        before_create lambda {|model| model.created_at = Time.now; model.created_at_not_changed}
+        before_save lambda {|model| model.updated_at = Time.now; model.updated_at_not_changed}
+      end
+    end
+  end
+end