langalex-couch_potato 0.1

data/CREDITS

@@ -0,0 +1,3 @@
+Parts of this are taken or inspired by Geoffrey Grosenbach's travel_app which is part of his CouchDB screencast.
+
+Jan Lehnardt got me started on doing this.

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/init.rb

@@ -0,0 +1,5 @@
+# this is for rails only
+
+require File.dirname(__FILE__) + '/lib/couch_potato'
+
+CouchPotato::Config.database_name = YAML::load(File.read(RAILS_ROOT + '/config/couchdb.yml'))[RAILS_ENV]

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/time.rb

@@ -0,0 +1,14 @@
+class Time
+  def to_json(*a)
+    {
+      'json_class'   => self.class.name,
+      'data'         => self.strftime("%Y/%m/%d %H:%M:%S %z")
+    }.to_json(*a)
+  end
+end
+
+class Time
+  def self.json_create(o)
+    parse(*o['data'])
+  end
+end

data/lib/couch_potato/active_record/compatibility.rb

@@ -0,0 +1,9 @@
+module CouchPotato
+  module Persistence
+    alias_method :new_record?, :new_document?
+    
+    module ClassMethods
+      alias_method :find, :get
+    end
+  end
+end

data/lib/couch_potato/ordering.rb

@@ -0,0 +1,88 @@
+module CouchPotato
+  module Ordering
+    def self.included(base)
+      base.class_eval do
+        property :position
+        cattr_accessor :ordering_scope
+        
+        before_create :set_position
+        before_create :update_positions
+        before_destroy :update_lower_positions_after_destroy
+        before_update :update_positions
+        
+        def self.set_ordering_scope(scope)
+          self.ordering_scope = scope
+        end
+        
+        def position=(new_position)
+          @old_position = position
+          @position = new_position
+        end
+      end
+    end
+    
+    private
+    
+    MAX = 9999999
+    
+    def set_position
+      self.position ||= self.class.count(scope_conditions) + 1
+    end
+    
+    def update_positions
+      @old_position = MAX if new_document?
+      return unless @old_position
+      if position < @old_position
+        new_lower_items = find_in_positions self.position, @old_position - 1
+        move new_lower_items, :down
+      elsif position > @old_position
+        new_higher_items = find_in_positions @old_position + 1, position
+        move new_higher_items, :up
+      end
+    end
+    
+    def update_lower_positions_after_destroy
+      lower_items = find_in_positions self.position + 1, MAX
+      move lower_items, :up
+    end
+    
+    def find_in_positions(from, to)
+      self.class.all scope_conditions.merge(:position => from..to)
+    end
+    
+    def scope_conditions
+      if ordering_scope
+        {ordering_scope => self.send(ordering_scope)}
+      else
+        {}
+      end
+    end
+    
+    def move(items, direction)
+      items.each do |item|
+        if direction == :up
+          item.position -= 1
+        else
+          item.position += 1
+        end
+        self.bulk_save_queue << item
+      end
+    end
+  end
+  
+  module ExternalCollectionOrderedFindExtension
+    def self.included(base)
+      base.class_eval do
+        def items
+          if @item_class.property_names.include?(:position)
+            @items ||= CouchPotato::Persistence::Finder.new.find @item_class, @owner_id_attribute_name => owner_id, :position => 1..CouchPotato::Ordering::MAX
+          else
+            @items ||= CouchPotato::Persistence::Finder.new.find @item_class, @owner_id_attribute_name => owner_id
+          end
+        end
+      end
+    end
+  end
+  CouchPotato::Persistence::ExternalCollection.send :include, ExternalCollectionOrderedFindExtension
+end
+

data/lib/couch_potato/persistence/belongs_to_property.rb

@@ -0,0 +1,44 @@
+module CouchPotato
+  module Persistence
+    class BelongsToProperty
+      attr_accessor :name
+      
+      def initialize(owner_clazz, name, options = {})
+        self.name = name
+        accessors =  <<-ACCESSORS
+          def #{name}
+            @#{name} || @#{name}_id ? #{item_class_name}.find(@#{name}_id) : nil
+          end
+          
+          def #{name}=(value)
+            @#{name} = value
+            @#{name}_id = value.id
+          end
+        ACCESSORS
+        owner_clazz.class_eval accessors
+        owner_clazz.send :attr_accessor, "#{name}_id"
+      end
+      
+      def save(object)
+        
+      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.singularize.camelcase
+      end
+      
+    end
+  end
+end

data/lib/couch_potato/persistence/bulk_save_queue.rb

@@ -0,0 +1,47 @@
+module CouchPotato
+  module Persistence
+    class BulkSaveQueue
+      attr_reader :callbacks
+      
+      def initialize
+        @other_queues = []
+        @callbacks = []
+        @instances = []
+      end
+      
+      def <<(instance)
+        if own?
+          @instances << instance
+        else
+          @other_queues.last << instance
+        end
+      end
+      
+      def push_queue(queue)
+        @other_queues.push queue
+      end
+      
+      def pop_queue
+        @other_queues.pop
+      end
+      
+      def own?
+        @other_queues.empty?
+      end
+      
+      def save(&callback)
+        if own?
+          @callbacks << callback if callback
+          res = CouchPotato::Persistence.Db.bulk_save @instances
+          @instances.clear
+          @callbacks.each do |_callback|
+            _callback.call res
+          end
+          @callbacks.clear
+        else
+          @other_queues.last.callbacks << callback if callback
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/callbacks.rb

@@ -0,0 +1,96 @@
+module CouchPotato
+  module Persistence
+    module Callbacks
+      def self.included(base)
+        base.extend ClassMethods
+        
+        base.class_eval do
+          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
+      
+      private
+      
+      def run_callbacks(name)
+        self.class.callbacks[name].each do |callback|
+          self.send callback
+        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/collection.rb

@@ -0,0 +1,51 @@
+module CouchPotato
+  module Persistence
+    class Collection
+      attr_accessor :items, :item_class
+      
+      def initialize(item_class)
+        @item_class = item_class
+        @items = []
+      end
+      
+      def build(attributes)
+        item = @item_class.new(attributes)
+        self.<< item
+        item
+      end
+      
+      def ==(other)
+        other.class == self.class && other.items == items && other.item_class == item_class
+      end
+      
+      def to_json(*args)
+        raise 'implement me in a subclass'
+      end
+      
+      def self.json_create(json)
+        raise 'implement me in a subclass'
+      end
+      
+      delegate :[], :<<, :empty?, :any?, :each, :+, :size, :first, :last, :map, :inject, :join, :clear, :select, :reject, :to => :items
+      
+    end
+  end
+end
+
+if Object.const_defined? 'WillPaginate'
+  module CouchPotato
+    module Persistence
+      class Collection
+        def paginate(options = {})
+          page = (options[:page] || 1).to_i
+          per_page = options[:per_page] || 20
+          collection = WillPaginate::Collection.new page, per_page, self.size
+          items[((page - 1) * per_page)..(page * (per_page - 1))].each do |item|
+            collection << item
+          end
+          collection
+        end
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/external_collection.rb

@@ -0,0 +1,54 @@
+require File.dirname(__FILE__) + '/collection'
+require File.dirname(__FILE__) + '/finder'
+
+module CouchPotato
+  module Persistence
+    class ExternalCollection < Collection
+      
+      attr_accessor :item_ids, :owner_id
+      
+      def initialize(item_class, owner_id_attribute_name)
+        super item_class
+        @items = nil
+        @owner_id_attribute_name = owner_id_attribute_name
+      end
+      
+      def build(attributes = {})
+        item = @item_class.new(attributes)
+        self.<< item
+        item.send "#{@owner_id_attribute_name}=", owner_id
+        item
+      end
+      
+      def create(attributes = {})
+        item = build(attributes)
+        item.save
+        item
+      end
+      
+      def create!(attributes = {})
+        item = build(attributes)
+        item.save!
+        item
+      end
+      
+      def items
+        @items ||= Finder.new.find @item_class, @owner_id_attribute_name => owner_id
+      end
+      
+      def save
+        items.each do |item|
+          item.send "#{@owner_id_attribute_name}=", owner_id
+          item.save
+        end
+      end
+      
+      def destroy
+        @items.each do |item|
+          item.destroy
+        end
+      end
+    end
+  end
+end
+

data/lib/couch_potato/persistence/external_has_many_property.rb

@@ -0,0 +1,68 @@
+module CouchPotato
+  module Persistence
+    class ExternalHasManyProperty
+      attr_accessor :name, :dependent
+      def initialize(owner_clazz, name, options = {})
+        @name, @owner_clazz = name, owner_clazz
+        @dependent = options[:dependent] || :nullify
+        getter =  <<-ACCESORS
+          def #{name}
+            @#{name} ||= CouchPotato::Persistence::ExternalCollection.new(#{item_class_name}, :#{owner_clazz.name.underscore}_id)
+          end
+          
+          def #{name}=(items)
+            items.each do |item|
+              #{name} << item
+            end
+          end
+        ACCESORS
+        owner_clazz.class_eval getter
+      end
+      
+      def save(object)
+        object.send(name).owner_id = object._id
+        object.send(name).each do |item|
+          item.send("#{@owner_clazz.name.underscore}_id=", object.id)
+          begin
+            item.bulk_save_queue.push_queue object.bulk_save_queue
+            item.save
+          ensure
+            item.bulk_save_queue.pop_queue
+          end
+        end
+      end
+      
+      def destroy(object)
+        object.send(name).each do |item|
+          if dependent == :destroy
+            begin
+              item.bulk_save_queue.push_queue object.bulk_save_queue
+              item.destroy
+            ensure
+              item.bulk_save_queue.pop_queue
+            end
+          else
+            item.send("#{@owner_clazz.name.underscore}_id=", nil)
+          end
+        end
+      end
+      
+      def build(object, json)
+        collection = ExternalCollection.new(item_class_name.constantize, "#{@owner_clazz.name.underscore}_id")
+        collection.owner_id = object.id
+        object.send("#{name}").clear
+        object.send "#{name}=", collection
+      end
+      
+      def serialize(json, object)
+        nil
+      end
+      
+      private
+      
+      def item_class_name
+        @name.to_s.singularize.camelcase
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/find.rb

@@ -0,0 +1,21 @@
+module CouchPotato
+  module Persistence
+    module Find
+      def first(options = {})
+        Finder.new.find(self, options).first
+      end
+      
+      def last(options = {})
+        Finder.new.find(self, options, :descending => true).first
+      end
+      
+      def all(options = {})
+        Finder.new.find(self, options)
+      end
+      
+      def count(options = {})
+        Finder.new.count(self, options)
+      end
+    end
+  end
+end

data/lib/couch_potato/persistence/finder.rb

@@ -0,0 +1,109 @@
+require 'uri'
+
+module CouchPotato
+  module Persistence
+    class Finder
+      # finds all objects of a given type by the given attribute/value pairs
+      # options: attribute_name => value pairs to search for
+      # value can also be a range which will do a range search with startkey/endkey
+      # WARNING: calling this methods creates a new view in couchdb if it's not present already so don't overuse this
+      def find(clazz, conditions = {}, view_options = {})
+        params = view_parameters(clazz, conditions, view_options)
+        to_instances clazz, query_view!(params)
+      end
+      
+      def count(clazz, conditions = {}, view_options = {})
+        params = view_parameters(clazz, conditions, view_options)
+        query_view!(params, '_count')['rows'].first.try(:[], 'value') || 0
+      end
+      
+      private
+      
+      def query_view!(params, view_postfix = nil)
+        begin
+          query_view params, view_postfix
+        rescue RestClient::ResourceNotFound => e
+          create_view params
+          query_view params, view_postfix
+        end
+      end
+      
+      def db(name = nil)
+        ::CouchPotato::Persistence.Db(name)
+      end
+      
+      def create_view(params)
+        # in couchdb 0.9 we could use only 1 view and pass reduce=false for find and count with reduce
+        design_doc = db.get "_design/#{params[:design_document]}" rescue nil
+        db.save({
+          "_id" => "_design/#{params[:design_document]}",
+          :views => {
+            params[:view] => {
+              :map => map_function(params)
+            },
+            params[:view] + '_count' => {
+              :map => map_function(params),
+              :reduce => "function(keys, values) {
+                return values.length;
+              }"
+            }
+          }
+        }.merge(design_doc ? {'_rev' => design_doc['_rev']} : {}))
+      end
+      
+      def map_function(params)
+        "function(doc) {
+          if(doc.ruby_class == '#{params[:class]}') {
+            emit(
+              [#{params[:search_fields].map{|attr| "doc[\"#{attr}\"]"}.join(', ')}], doc
+                );
+          }
+        }"
+      end
+      
+      def to_instances(clazz, query_result)
+        query_result['rows'].map{|doc| doc['value']}.map{|json| clazz.json_create json}
+      end
+      
+      def query_view(params, view_postfix)
+        db.view params[:view_url] + view_postfix.to_s, search_keys(params)
+      end
+      
+      def search_keys(params)
+        if params[:search_values].select{|v| v.is_a?(Range)}.any?
+          {:startkey => params[:search_values].map{|v| v.is_a?(Range) ? v.first : v}, :endkey => params[:search_values].map{|v| v.is_a?(Range) ? v.last : v}}.merge(params[:view_options])
+        elsif params[:search_values].select{|v| v.is_a?(Array)}.any?
+          {:keys => prepare_multi_key_search(params[:search_values])}.merge(params[:view_options])
+        else
+          {:key => params[:search_values]}.merge(params[:view_options])
+        end
+      end
+      
+      def prepare_multi_key_search(values)
+        array = values.select{|v| v.is_a?(Array)}.first
+        index = values.index array
+        array.map do |item|
+          copy = values.dup
+          copy[index] = item
+          copy
+        end
+      end
+      
+      def view_parameters(clazz, conditions, view_options)
+        {
+          :class => clazz,
+          :design_document => clazz.name.underscore,
+          :search_fields => conditions.to_a.sort_by{|f| f.first.to_s}.map(&:first),
+          :search_values => conditions.to_a.sort_by{|f| f.first.to_s}.map(&:last),
+          :view_options => view_options,
+          :view => "by_#{view_name(conditions)}",
+          :view_url => "#{clazz.name.underscore}/by_#{view_name(conditions)}"
+        }
+      end
+      
+      def view_name(options)
+        options.to_a.sort_by{|f| f.first.to_s}.map(&:first).join('_and_')
+      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
+