couch_tomato 0.1.0

data/lib/couch_tomato/persistence.rb

@@ -0,0 +1,85 @@
+require 'digest/md5'
+require File.dirname(__FILE__) + '/database'
+require File.dirname(__FILE__) + '/persistence/properties'
+require File.dirname(__FILE__) + '/persistence/base'
+require File.dirname(__FILE__) + '/persistence/magic_timestamps'
+require File.dirname(__FILE__) + '/persistence/callbacks'
+require File.dirname(__FILE__) + '/persistence/json'
+require File.dirname(__FILE__) + '/persistence/dirty_attributes'
+require File.dirname(__FILE__) + '/persistence/validation'
+
+
+
+module CouchTomato
+  module Persistence
+    module Nested
+      include CouchTomato::Persistence::Base
+
+      def self.included(base)
+        base.send :include, Properties, Callbacks, Validation#, Json#, CouchTomato::View::CustomViews
+        # base.send :include, DirtyAttributes
+        # base.send :include, MagicTimestamps
+
+        base.extend ClassMethods
+      end
+
+      def to_json(*args)
+        to_hash.to_json(*args)
+        # to_json(*args)
+      end
+
+      # returns all the attributes, the ruby class and the _id and _rev of a model as a Hash
+      def to_hash
+        (self.class.properties).inject({}) do |props, property|
+          property.serialize(props, self)
+          props
+        end
+      end
+
+      private
+
+      module ClassMethods
+        # creates a model instance from JSON
+        def json_create(json, meta={})
+          return if json.nil?
+          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
+
+    include CouchTomato::Persistence::Base
+
+    def self.included(base)
+      base.send :include, Properties, Callbacks, Validation, Json#, CouchTomato::View::CustomViews
+      # base.send :include, DirtyAttributes
+      base.send :include, MagicTimestamps
+      base.class_eval do
+        attr_accessor :_id, :_rev, :_attachments, :_deleted
+        attr_accessor :metadata
+        alias_method :id, :_id
+      end
+    end
+
+    # returns true if a  model hasn't been saved yet, false otherwise
+    def new?
+      _rev.nil?
+    end
+    alias_method :new_record?, :new?
+
+    # returns the document id
+    # this is used by rails to construct URLs
+    # can be overridden to for example use slugs for URLs instead if ids
+    def to_param
+      _id
+    end
+
+  end
+
+end

data/lib/couch_tomato/replicator.rb

@@ -0,0 +1,50 @@
+module CouchTomato
+  class Replicator
+    # Timeout for a single database replication.
+    READ_TIMEOUT = 24 * 60 * 60 # 24 hours in seconds
+
+    def initialize(src_server, dst_server = nil)
+      @src_server = CouchRest::Server.new(src_server)
+      @dst_server = dst_server ? CouchRest::Server.new(dst_server) : @src_server
+
+      @db_names = @src_server.databases
+    end
+
+    def replicate(src_db_name, dst_db_name)
+      raise "Source database '#{src_db_name}' does not exist" unless @db_names.include?(src_db_name)
+
+      @dst_server.database!(dst_db_name)
+
+      src_uri = URI.parse(@src_server.uri)
+      dst_uri = URI.parse(@dst_server.uri)
+
+      http = Net::HTTP.new(dst_uri.host, dst_uri.port)
+      http.read_timeout = READ_TIMEOUT
+      http.post('/_replicate', "{\"source\": \"#{src_uri}/#{src_db_name}\", \"target\": \"#{dst_uri}/#{dst_db_name}\"}")
+    end
+
+    def replicate_all(suffix = nil)
+      @db_names.each do |db_name|
+        replicate(db_name, "#{db_name}#{suffix}")
+      end
+    end
+
+    def replicate_env!(from_env, to_env, prefix=nil)
+      source_dbs = @db_names.select do |e|
+        if prefix
+          e =~ /^#{prefix}_/ && e =~ /_#{from_env}$/
+        else
+          e =~ /_#{from_env}$/
+        end
+      end
+
+      source_dbs.each do |source_db|
+        target_db = source_db.gsub(/_#{from_env}$/, "_#{to_env}")
+        
+        puts "Recreating #{target_db}"
+        CouchRest::Database.new(@dst_server, target_db).recreate!
+        replicate(source_db, target_db)
+      end
+    end
+  end
+end

data/lib/couch_tomato.rb

@@ -0,0 +1,46 @@
+require 'couchrest'
+require 'json'
+require 'json/add/core'
+require 'json/add/rails'
+
+# require 'ostruct'
+
+
+module CouchTomato
+  # Config = OpenStruct.new
+
+  # Returns a database instance which you can then use to create objects and query views. 
+  # You have to set the CouchTomato::Config.database_name before this works.
+
+  # def self.database
+  #   @@__database ||= Database.new(self.couchrest_database)
+  # end
+
+  # Returns the underlying CouchRest database object if you want low level access to your CouchDB. 
+  # You have to set the CouchTomato::Config.database_name before this works.
+  # def self.couchrest_database
+  #   @@__couchrest_database ||= CouchRest.database(full_url_to_database)
+  # end
+
+  # private
+
+  # def self.full_url_to_database
+  #   raise('No Database configured. Set CouchTomato::Config.database_name') unless CouchTomato::Config.database_name
+  #   if CouchTomato::Config.database_server
+  #     return "#{CouchTomato::Config.database_server}#{CouchTomato::Config.database_name}"
+  #   else
+  #     return "http://127.0.0.1:5984/#{CouchTomato::Config.database_name}"
+  #   end
+  # end
+end
+
+require File.dirname(__FILE__) + '/core_ext/object'
+require File.dirname(__FILE__) + '/core_ext/time'
+require File.dirname(__FILE__) + '/core_ext/date'
+require File.dirname(__FILE__) + '/core_ext/string'
+require File.dirname(__FILE__) + '/core_ext/symbol'
+require File.dirname(__FILE__) + '/core_ext/extract_options'
+require File.dirname(__FILE__) + '/core_ext/duplicable'
+require File.dirname(__FILE__) + '/core_ext/inheritable_attributes'
+require File.dirname(__FILE__) + '/couch_tomato/persistence'
+require File.dirname(__FILE__) + '/couch_tomato/js_view_source'

data/lib/tasks/couch_tomato.rake

@@ -0,0 +1,128 @@
+namespace :couch_tomato do
+  desc 'Inserts the views into CouchDB'
+  task :push => :environment do
+    CouchTomato::JsViewSource.push
+  end
+
+  desc 'Compares views in DB and the File System'
+  task :diff => :environment do
+    CouchTomato::JsViewSource.diff
+  end
+
+  desc 'Drops databases for the current RAILS_ENV'
+  task :drop => :environment do
+    databases do |db, dir|
+      db.delete!
+    end
+  end
+
+  desc 'Runs migrations'
+  task :migrate => :environment do
+    databases do |db, dir|
+      CouchTomato::Migrator.migrate(db, dir, ENV['VERSION'] ? ENV['VERSION'].to_i : nil)
+    end
+  end
+
+  namespace :migrate do
+    desc 'Rollbacks the database one migration and re migrate up. If you want to rollback more than one step, define STEP=x. Target specific version with VERSION=x.'
+    task :redo => :environment do
+      if ENV['VERSION']
+        Rake::Task['couch_tomato:migrate:down'].invoke
+        Rake::Task['couch_tomato:migrate:up'].invoke
+      else
+        Rake::Task['couch_tomato:rollback'].invoke
+        Rake::Task['couch_tomato:migrate'].invoke
+      end
+    end
+
+    desc 'Resets your database using your migrations for the current environment'
+    task :reset => ['couch_tomato:drop', 'couch_tomato:push', 'couch_tomato:migrate']
+
+    desc 'Runs the "up" for a given migration VERSION.'
+    task :up => :environment do
+      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+      raise 'VERSION is required' unless version
+
+      databases do |db, dir|
+        CouchTomato::Migrator.run(:up, db, dir, version)
+      end
+    end
+
+    desc 'Runs the "down" for a given migration VERSION.'
+    task :down => :environment do
+      version = ENV['VERSION'] ? ENV['VERSION'].to_i : nil
+      raise 'VERSION is required' unless version
+
+      databases do |db, dir|
+        CouchTomato::Migrator.run(:down, db, dir, version)
+      end
+    end
+  end
+
+  desc 'Rolls back to the previous version. Specify the number of steps with STEP=n'
+  task :rollback => :environment do
+    databases do |db, dir|
+      CouchTomato::Migrator.rollback(db, dir, ENV['STEP'] ? ENV['STEP'].to_i : 1)
+    end
+  end
+
+  desc 'Rolls forward to the next version. Specify the number of steps with STEP=n'
+  task :forward => :environment do
+    databases do |db, dir|
+      CouchTomato::Migrator.forward(db, dir, ENV['STEP'] ? ENV['STEP'].to_i : 1)
+    end
+  end
+
+  desc 'Replicates couch databases'
+  task :replicate => :environment do
+    src_server, dst_server = servers
+
+    src_db = ENV['DB']
+    dst_db = ENV['DST_DB'] || (src_server == dst_server ? "#{src_db}_bak" : src_db)
+
+    replicator = CouchTomato::Replicator.new(src_server, dst_server)
+
+    if src_db
+      puts "== Replicating '#{src_server}/#{src_db}' to '#{dst_server}/#{dst_db}'"
+      replicator.replicate(src_db, dst_db)
+    elsif src_server == dst_server
+      puts "== Replicating all databases at '#{src_server}' using '_bak' suffix for replicated database names"
+      replicator.replicate_all('_bak')
+    else
+      puts "== Replicating all databases from '#{src_server}' to '#{dst_server}'"
+      replicator.replicate_all
+    end
+  end
+
+  namespace :replicate do
+    desc 'Replicate databases between app environments'
+    task :env => :environment do
+      src_server, dst_server = servers
+
+      src_env = ENV['SRC_ENV'] || 'production'
+      dst_env = ENV['DST_ENV'] || 'development'
+
+      replicator = CouchTomato::Replicator.new(src_server, dst_server)
+      replicator.replicate_env(src_env, dst_env, ENV['PREFIX'])
+    end
+  end
+
+  private
+
+  def servers
+    local_server = "http://#{APP_CONFIG['couchdb_address']}:#{APP_CONFIG['couchdb_port']}"
+    src_server = (ENV['SRC_SERVER'] || local_server).gsub(/\s*\/\s*$/, '')
+    dst_server = (ENV['DST_SERVER'] || local_server).gsub(/\s*\/\s*$/, '')
+
+    return src_server, dst_server
+  end
+
+  def databases
+    dirs = ENV['DB'] ? ["couchdb/migrate/#{ENV['DB']}"] : Dir['couchdb/migrate/*']
+    dirs.each do |dir|
+      db_name = File.basename(dir)
+      db = CouchTomato::JsViewSource.database!(db_name)
+      yield db, dir
+    end
+  end
+end

data/rails/init.rb

@@ -0,0 +1,7 @@
+# this is for rails only
+
+require File.dirname(__FILE__) + '/../lib/couch_tomato'
+
+# CouchTomato::Config.database_name = YAML::load(File.read(Rails.root.to_s + '/config/couchdb.yml'))[RAILS_ENV]
+
+RAILS_DEFAULT_LOGGER.info "** couch_tomato: initialized from #{__FILE__}"

data/spec/callbacks_spec.rb

@@ -0,0 +1,271 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+class CallbackRecorder
+  include CouchTomato::Persistence
+  
+  property :required_property
+  
+  validates_presence_of :required_property
+  
+  [:before_validation, :before_validation_on_create,
+    :before_validation_on_save, :before_validation_on_update, 
+    :before_save, :before_create, :before_create,
+    :after_save, :after_create, :after_create,
+    :before_update, :after_update,
+    :before_destroy, :after_destroy
+  ].each do |callback|
+    define_method callback do
+      callbacks << callback
+    end
+    self.send callback, callback
+  end
+  
+  view :all, :key  => :required_property
+  
+  attr_accessor :lambda_works
+  before_create lambda {|model| model.lambda_works = true }
+  
+  def callbacks
+    @callbacks ||= []
+  end
+  
+  private
+  
+  def method_callback_with_argument(db)
+    db.view CallbackRecorder.all
+  end
+  
+end
+
+describe "multiple callbacks at once" do
+
+  class Monkey
+    include CouchTomato::Persistence
+    attr_accessor :eaten_banana, :eaten_apple
+    
+    before_create :eat_apple, :eat_banana
+    
+    private
+    
+    def eat_banana
+      self.eaten_banana = true
+    end
+    
+    def eat_apple
+      self.eaten_apple = true
+    end
+  end
+  it "should run all callback methods given to the callback method call" do
+    monkey = Monkey.new
+    CouchTomato.database.save_document! monkey
+    monkey.eaten_banana.should be_true
+    monkey.eaten_apple.should be_true
+  end
+end
+
+describe 'create callbacks' do
+  
+  before(:each) do
+    @recorder = CallbackRecorder.new
+    couchrest_database = stub 'couchrest_database', :save_doc => {'id' => '1', 'rev' => '2'}, :view => {'rows' => []}, :info => nil
+    @db = CouchTomato::Database.new(couchrest_database)
+  end
+  
+  describe "successful create" do
+    before(:each) do
+       @recorder.required_property = 1
+    end
+    
+    it "should call before_validation" do
+      @recorder.valid?
+      @recorder.callbacks.should include(:before_validation)
+    end
+        
+    it "should call before_validation_on_create" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:before_validation_on_create)
+    end
+    
+    it "should call before_validation_on_save" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should call before_save" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:before_save)
+    end
+    
+    it "should call after_save" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:after_save)
+    end
+    
+    it "should call before_create" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:before_create)
+    end
+    
+    it "should call after_create" do
+      @db.save_document! @recorder
+      @recorder.callbacks.should include(:after_create)
+    end
+    
+  end
+  
+  describe "failed create" do
+    
+    it "should call before_validation" do
+      @recorder.valid?
+      @recorder.callbacks.should include(:before_validation)
+    end
+    
+    it "should call before_validation_on_create" do
+      @db.save_document @recorder
+      @recorder.callbacks.should include(:before_validation_on_create)
+    end
+    
+    it "should call before_validation_on_save" do
+      @db.save_document @recorder
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should not call before_save" do
+      @db.save_document @recorder
+      @recorder.callbacks.should_not include(:before_save)
+    end
+    
+    it "should not call after_save" do
+      @db.save_document @recorder
+      @recorder.callbacks.should_not include(:after_save)
+    end
+    
+    it "should not call before_create" do
+      @db.save_document @recorder
+      @recorder.callbacks.should_not include(:before_create)
+    end
+    
+    it "should not call after_create" do
+      @db.save_document @recorder
+      @recorder.callbacks.should_not include(:after_create)
+    end
+  end
+end
+
+describe "update callbacks" do
+  
+  before(:each) do
+    @recorder = CallbackRecorder.new :required_property => 1
+    
+    couchrest_database = stub 'couchrest_database', :save_doc => {'id' => '1', 'rev' => '2'}, :view => {'rows' => []}, :info => nil
+    @db = CouchTomato::Database.new(couchrest_database)
+    @db.save_document! @recorder
+    
+    @recorder.required_property = 2
+    @recorder.callbacks.clear
+  end
+  
+  describe "successful update" do
+    
+    before(:each) do
+      @db.save_document! @recorder
+    end
+    
+    it "should call before_validation" do
+      @recorder.callbacks.should include(:before_validation)
+    end
+    
+    it "should call before_validation_on_update" do
+      @recorder.callbacks.should include(:before_validation_on_update)
+    end
+    
+    it "should call before_validation_on_save" do
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should call before_save" do
+      @recorder.callbacks.should include(:before_save)
+    end
+    
+    it "should call after_save" do
+      @recorder.callbacks.should include(:after_save)
+    end
+    
+    it "should call before_update" do
+      @recorder.callbacks.should include(:before_update)
+    end
+    
+    it "should call after_update" do
+      @recorder.callbacks.should include(:after_update)
+    end
+    
+  end
+  
+  describe "failed update" do
+    
+    before(:each) do
+       @recorder.required_property = nil
+       @db.save_document @recorder
+    end
+    
+    it "should call before_validation" do
+      @recorder.callbacks.should include(:before_validation)
+    end
+    
+    it "should call before_validation_on_update" do
+      @recorder.callbacks.should include(:before_validation_on_update)
+    end
+    
+    it "should call before_validation_on_save" do
+      @recorder.callbacks.should include(:before_validation_on_save)
+    end
+    
+    it "should not call before_save" do
+      @recorder.callbacks.should_not include(:before_save)
+    end
+    
+    it "should not call after_save" do
+      @recorder.callbacks.should_not include(:after_save)
+    end
+    
+    it "should not call before_update" do
+      @recorder.callbacks.should_not include(:before_update)
+    end
+    
+    it "should not call after_update" do
+      @recorder.callbacks.should_not include(:after_update)
+    end
+    
+  end
+  
+end
+
+describe "destroy callbacks" do
+  
+  before(:each) do
+    @recorder = CallbackRecorder.new :required_property => 1
+    couchrest_database = stub 'couchrest_database', :save_doc => {'id' => '1', 'rev' => '2'}, :delete_doc => nil, :view => {'rows' => []}, :info => nil
+    @db = CouchTomato::Database.new(couchrest_database)
+    @db.save_document! @recorder
+    
+    @recorder.callbacks.clear
+  end
+  
+  it "should call before_destroy" do
+    @db.destroy_document @recorder
+    @recorder.callbacks.should include(:before_destroy)
+  end
+  
+  it "should call after_destroy" do
+    @db.destroy_document @recorder
+    @recorder.callbacks.should include(:after_destroy)
+  end
+end
+
+describe "lambda callbacks" do
+  it "should run the lambda" do
+    recorder = CallbackRecorder.new
+    recorder.run_callbacks :before_create
+    recorder.lambda_works.should be_true
+  end
+end

data/spec/comment.rb

@@ -0,0 +1,8 @@
+class Comment
+  include CouchTomato::Persistence
+
+  validates_presence_of :title
+
+  property :title
+  belongs_to :commenter
+end

data/spec/create_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "create" do
+  before(:all) do
+    recreate_db
+  end
+  describe "succeeds" do
+    it "should store the class" do
+      @comment = Comment.new :title => 'my_title'
+      CouchTomato.database.save_document! @comment
+      CouchTomato.couchrest_database.get(@comment.id)['ruby_class'].should == 'Comment'
+    end
+  end
+  describe "fails" do
+    it "should not store anything" do
+      @comment = Comment.new
+      CouchTomato.database.save_document @comment
+      CouchTomato.couchrest_database.documents['rows'].should be_empty
+    end
+  end
+end
+