couch_potato-rails2 0.5.6

data/Rakefile

@@ -0,0 +1,82 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require "rspec/core/rake_task"
+require 'rake/rdoctask'
+
+def with_validatable(&block)
+  begin
+    require 'validatable'
+    
+    ENV['VALIDATION_FRAMEWORK'] = 'validatable'
+    puts "Running task with Validatable validation framework."
+    yield block
+  rescue LoadError
+    STDERR.puts "WARNING: Validatable not available, skipping task."
+  end
+end
+
+def with_active_model(&block)
+  begin
+    require 'active_model'
+    
+    ENV['VALIDATION_FRAMEWORK'] = 'active_model'
+    puts "Running task with ActiveModel validation framework."
+    yield block
+  rescue LoadError
+    STDERR.puts "WARNING: ActiveModel not available, skipping task."
+  end
+end
+
+task :default => :spec
+
+task :spec_functional_validatable do
+  with_validatable { Rake::Task['spec_functional_default'].execute }
+end
+
+task :spec_functional_active_model do
+  with_active_model { Rake::Task['spec_functional_default'].execute }
+end
+
+task :spec_unit_validatable do
+  with_validatable { Rake::Task['spec_unit_default'].execute }
+end
+
+task :spec_unit_active_model do
+  with_active_model { Rake::Task['spec_unit_default'].execute }
+end
+
+desc "Run functional specs with default validation framework, override with VALIDATION_FRAMEWORK"
+RSpec::Core::RakeTask.new(:spec_functional_default) do |spec|
+  spec.pattern = 'spec/*_spec.rb'
+  spec.rspec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+end
+
+desc "Run unit specs with default validation framework, override with VALIDATION_FRAMEWORK"
+RSpec::Core::RakeTask.new(:spec_unit_default) do |spec|
+  spec.pattern = 'spec/unit/*_spec.rb'
+  spec.rspec_opts = ['--options', "\"#{File.dirname(__FILE__)}/spec/spec.opts\""]
+end
+
+desc "Run functional specs with all validation frameworks"
+task :spec_functional => [:spec_functional_validatable, :spec_functional_active_model] do
+end
+
+desc "Run unit specs with all validation frameworks"
+task :spec_unit => [:spec_unit_validatable, :spec_unit_active_model] do
+end
+
+desc "Run all specs"
+task :spec => [:spec_unit, :spec_functional] do
+end
+
+desc 'Generate documentation'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Couch Potato'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/couch_potato.rb')
+  rdoc.rdoc_files.include('lib/couch_potato/**/*.rb')
+end

data/couch_potato.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "couch_potato/version"
+
+Gem::Specification.new do |s|
+  s.name = "couch_potato-rails2"
+  s.summary = %Q{Ruby persistence layer for CouchDB}
+  s.email = "alex@upstre.am"
+  s.homepage = "http://github.com/langalex/couch_potato"
+  s.description = "Ruby persistence layer for CouchDB"
+  s.authors = ["Alexander Lang"]
+  s.version     = CouchPotato::VERSION
+  s.platform    = Gem::Platform::RUBY
+  
+  s.add_dependency 'json'
+  s.add_dependency 'couchrest', '>=1.0.1'
+  
+  s.add_development_dependency 'rspec', '>=2.0'
+  s.add_development_dependency 'timecop'
+  s.add_development_dependency 'tzinfo'
+  s.add_development_dependency 'rake'
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

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,14 @@
+class Date
+  def to_json(*a)
+    %("#{as_json}")
+  end
+  
+  def as_json(*args)
+    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,12 @@
+module ActiveSupportMethods
+  def camelize
+    sub(/^([a-z])/) {$1.upcase}.gsub(/_([a-z])/) do
+      $1.upcase
+    end
+  end
+
+  def blank?
+    empty?
+  end
+end
+String.send :include, ActiveSupportMethods unless String.new.respond_to?(:underscore)

data/lib/core_ext/symbol.rb

@@ -0,0 +1,15 @@
+# taken from ActiveSupport 2.3.2
+unless :to_proc.respond_to?(:to_proc)
+  class Symbol
+    # Turns the symbol into a simple proc, which is especially useful for enumerations. Examples:
+    #
+    #   # The same as people.collect { |p| p.name }
+    #   people.collect(&:name)
+    #
+    #   # The same as people.select { |p| p.manager? }.collect { |p| p.salary }
+    #   people.select(&:manager?).collect(&:salary)
+    def to_proc
+      Proc.new { |*args| args.shift.__send__(self, *args) }
+    end
+  end
+end

data/lib/core_ext/time.rb

@@ -0,0 +1,23 @@
+require 'active_support/time'
+
+class Time
+  def to_json(*a)
+    %("#{as_json}")
+  end
+  
+  def as_json(*args)
+    getutc.strftime("%Y/%m/%d %H:%M:%S +0000")
+  end
+  
+  def self.json_create string
+    return nil if string.nil?
+    d = DateTime.parse(string.to_s).new_offset
+    self.utc(d.year, d.month, d.day, d.hour, d.min, d.sec).in_time_zone
+  end
+end
+
+ActiveSupport::TimeWithZone.class_eval do
+  def as_json(*args)
+    utc.as_json
+  end
+end

data/lib/couch_potato.rb

@@ -0,0 +1,48 @@
+require 'couchrest'
+require 'json'
+require 'json/add/core'
+require 'json/add/rails'
+
+require 'ostruct'
+
+JSON.create_id = 'ruby_class'
+
+module CouchPotato
+  Config = Struct.new(:database_name, :validation_framework, :split_design_documents_per_view).new
+  Config.validation_framework = :active_model
+  Config.split_design_documents_per_view = false
+  
+  class NotFound < StandardError; end
+
+  # Returns a database instance which you can then use to create objects and query views. You have to set the CouchPotato::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 CouchPotato::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 CouchPotato::Config.database_name') unless CouchPotato::Config.database_name
+    if CouchPotato::Config.database_name.match(%r{https?://})
+      CouchPotato::Config.database_name
+    else
+      "http://127.0.0.1:5984/#{CouchPotato::Config.database_name}"
+    end
+  end
+end
+
+$LOAD_PATH << File.dirname(__FILE__)
+
+require 'core_ext/object'
+require 'core_ext/time'
+require 'core_ext/date'
+require 'core_ext/string'
+require 'core_ext/symbol'
+require 'couch_potato/validation'
+require 'couch_potato/persistence'
+require 'couch_potato/railtie' if defined?(Rails)

data/lib/couch_potato/database.rb

@@ -0,0 +1,179 @@
+module CouchPotato
+  class Database
+
+    class ValidationsFailedError < ::StandardError; end
+
+    def initialize(couchrest_database)
+      @couchrest_database = couchrest_database
+      begin
+        couchrest_database.info
+      rescue RestClient::ResourceNotFound
+        raise "Database '#{couchrest_database.name}' does not exist."
+      end
+    end
+
+    # executes a view and return the results. you pass in a view spec
+    # which is usually a result of a SomePersistentClass.some_view call.
+    # also return the total_rows returned by CouchDB as an accessor on the results.
+    #
+    # Example:
+    #
+    #   class User
+    #     include CouchPotato::Persistence
+    #     property :age
+    #     view :all, key: :age
+    #   end
+    #   db = CouchPotato.database
+    #
+    #   db.view(User.all) # => [user1, user2]
+    #   db.view(User.all).total_rows # => 2
+    #
+    # You can pass the usual parameters you can pass to a couchdb view to the view:
+    #
+    #   db.view(User.all(limit: 5, startkey: 2, reduce: false))
+    #
+    # For your convenience when passing a hash with only a key parameter you can just pass in the value
+    #
+    #   db.view(User.all(key: 1)) == db.view(User.all(1))
+    # 
+    # Instead of passing a startkey and endkey you can pass in a key with a range:
+    #
+    #   db.view(User.all(key: 1..20)) == db.view(startkey: 1, endkey: 20) == db.view(User.all(1..20))
+    #   
+    # You can also pass in multiple keys:
+    #
+    #   db.view(User.all(keys: [1, 2, 3]))
+    def view(spec)
+      results = CouchPotato::View::ViewQuery.new(
+        couchrest_database,
+        spec.design_document,
+        {spec.view_name => {
+          :map => spec.map_function,
+          :reduce => spec.reduce_function}
+        },
+        ({spec.list_name => spec.list_function} unless spec.list_name.nil?)
+      ).query_view!(spec.view_parameters)
+      processed_results = spec.process_results results
+      processed_results.instance_eval "def total_rows; #{results['total_rows']}; end" if results['total_rows']
+      processed_results.each do |document|
+        document.database = self if document.respond_to?(:database=)
+      end if processed_results.respond_to?(:each)
+      processed_results
+    end
+    
+    # returns the first result from a #view query or nil
+    def first(spec)
+      view(spec).first
+    end
+    
+    # returns th first result from a #view or raises CouchPotato::NotFound
+    def first!(spec)
+      first(spec) || raise(CouchPotato::NotFound)
+    end
+
+    # saves a document. returns true on success, false on failure
+    def save_document(document, validate = true)
+      return true unless document.dirty? || document.new?
+      if document.new?
+        create_document(document, validate)
+      else
+        update_document(document, validate)
+      end
+    end
+    alias_method :save, :save_document
+    
+    # saves a document, raises a CouchPotato::Database::ValidationsFailedError on failure
+    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 :destroy do
+        document._deleted = true
+        couchrest_database.delete_doc document.to_hash
+      end
+      document._id = nil
+      document._rev = nil
+    end
+    alias_method :destroy, :destroy_document
+
+    # loads a document by its id
+    def load_document(id)
+      raise "Can't load a document without an id (got nil)" if id.nil?
+      begin
+        instance = couchrest_database.get(id)
+        instance.database = self
+        instance
+      rescue(RestClient::ResourceNotFound)
+        nil
+      end
+    end
+    alias_method :load, :load_document
+    
+    def load!(id)
+      load(id) || raise(CouchPotato::NotFound)
+    end
+
+    def inspect #:nodoc:
+      "#<CouchPotato::Database @root=\"#{couchrest_database.root}\">"
+    end
+    
+    # returns the underlying CouchRest::Database instance
+    def couchrest_database
+      @couchrest_database
+    end
+
+    private
+
+    def create_document(document, validate)
+      document.database = self
+      
+      if validate
+        document.errors.clear
+        document.run_callbacks :validation_on_save do
+          document.run_callbacks :validation_on_create do
+            return false unless valid_document?(document)
+          end
+        end
+      end
+      
+      document.run_callbacks :save do
+        document.run_callbacks :create do
+          res = couchrest_database.save_doc document.to_hash
+          document._rev = res['rev']
+          document._id = res['id']
+        end
+      end
+      true
+    end
+
+    def update_document(document, validate)
+      if validate
+        document.errors.clear
+        document.run_callbacks :validation_on_save do
+          document.run_callbacks :validation_on_update do
+            return false unless valid_document?(document)
+          end
+        end
+      end
+
+      document.run_callbacks :save do
+        document.run_callbacks :update do
+          res = couchrest_database.save_doc document.to_hash
+          document._rev = res['rev']
+        end
+      end
+      true
+    end
+
+    def valid_document?(document)
+      errors = document.errors.errors.dup
+      document.valid?
+      errors.each_pair do |k, v|
+        v.each {|message| document.errors.add(k, message)}
+      end
+      document.errors.empty?
+    end
+  end
+end

data/lib/couch_potato/persistence.rb

@@ -0,0 +1,124 @@
+require 'digest/md5'
+require File.dirname(__FILE__) + '/database'
+require File.dirname(__FILE__) + '/persistence/active_model_compliance'
+require File.dirname(__FILE__) + '/persistence/properties'
+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/ghost_attributes'
+require File.dirname(__FILE__) + '/persistence/attachments'
+require File.dirname(__FILE__) + '/persistence/type_caster'
+require File.dirname(__FILE__) + '/view/custom_views'
+require File.dirname(__FILE__) + '/view/lists'
+require File.dirname(__FILE__) + '/view/view_query'
+
+
+module CouchPotato
+  module Persistence
+    
+    def self.included(base) #:nodoc:
+      base.send :include, Properties, Callbacks, Json, CouchPotato::View::CustomViews, CouchPotato::View::Lists
+      base.send :include, DirtyAttributes, GhostAttributes, Attachments
+      base.send :include, MagicTimestamps, ActiveModelCompliance
+      base.send :include, Validation
+      base.class_eval do
+        attr_accessor :_id, :_rev, :_deleted, :database
+        alias_method :id, :_id
+        alias_method :id=, :_id=
+      end
+    end
+
+    # initialize a new instance of the model optionally passing it a hash of attributes.
+    # the attributes have to be declared using the #property method.
+    # the new model will be yielded to an optionally given block.
+    # 
+    # example: 
+    #   class Book
+    #     include CouchPotato::Persistence
+    #     property :title
+    #   end
+    #   book = Book.new :title => 'Time to Relax'
+    #
+    #   OR
+    #
+    #   book = Book.new do |b|
+    #     b.title = 'Time to Relax'
+    #   end
+    #   book.title # => 'Time to Relax'
+    def initialize(attributes = {})
+      if attributes
+        attributes.each do |name, value|
+          self.send("#{name}=", value)
+        end
+      end
+      yield self if block_given?
+    end
+    
+    # assign multiple attributes at once.
+    # the attributes have to be declared using the #property method
+    #
+    # example:
+    #   class Book
+    #     include CouchPotato::Persistence
+    #     property :title
+    #     property :year
+    #   end
+    #   book = Book.new
+    #   book.attributes = {:title => 'Time to Relax', :year => 2009}
+    #   book.title # => 'Time to Relax'
+    #   book.year # => 2009
+    def attributes=(hash)
+      hash.each do |attribute, value|
+        self.send "#{attribute}=", value
+      end
+    end
+    
+    # returns all of a model's attributes that have been defined using the #property method as a Hash
+    #
+    # example:
+    #   class Book
+    #     include CouchPotato::Persistence
+    #     property :title
+    #     property :year
+    #   end
+    #   book = Book.new :year => 2009
+    #   book.attributes # => {:title => nil, :year => 2009}
+    def attributes
+      self.class.properties.inject({}) do |res, property|
+        property.value(res, self)
+        res
+      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
+    
+    def ==(other) #:nodoc:
+      other.class == self.class && self.to_json == other.to_json
+    end
+    
+    def eql?(other)
+      self == other
+    end
+    
+    def hash
+      _id.hash * (_id.hash.to_s.size ** 10) + _rev.hash
+    end
+   
+    def inspect
+      attributes_as_string = attributes.map {|attribute, value| "#{attribute}: #{value.inspect}"}.join(", ")
+      %Q{#<#{self.class} _id: "#{_id}", _rev: "#{_rev}", #{attributes_as_string}>}
+    end
+  end    
+end