langalex-couch_potato 0.1.1 → 0.2.0

data/lib/couch_potato/ordering.rb

@@ -1,84 +0,0 @@
-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 items
-      if @item_class.property_names.include?(:position)
-        super @item_class, @owner_id_attribute_name => owner_id, :position => 1..CouchPotato::Ordering::MAX
-      else
-        super
-      end
-    end
-  end
-  CouchPotato::Persistence::ExternalCollection.send :include, ExternalCollectionOrderedFindExtension
-end
-

data/lib/couch_potato/persistence/bulk_save_queue.rb

@@ -1,47 +0,0 @@
-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/collection.rb

@@ -1,51 +0,0 @@
-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/custom_view.rb

@@ -1,41 +0,0 @@
-module CouchPotato
-  module Persistence
-    module CustomView
-      
-      def self.included(base)
-        base.extend ClassMethods
-      end
-      
-      module ClassMethods
-        
-        def view(name, options)
-          (class << self; self; end).instance_eval do
-            if options[:properties]
-              define_method name do
-                ViewQuery.new(self.name.underscore, name, map_function(options[:key], options[:properties]), nil, {}, {}).query_view!['rows'].map{|doc| self.new(doc['value'].merge(:_id => doc['id']))}
-              end
-            else
-              define_method name do
-                ViewQuery.new(self.name.underscore, name, map_function(options[:key], options[:properties]), nil, {}, {:include_docs =>  true}).query_view!['rows'].map{|doc| self.new(doc['doc'])}
-              end
-            end
-          end
-        end
-        
-        def map_function(key, properties)
-          "function(doc) {
-              emit(doc.#{key}, #{properties_for_map(properties)});
-           }"
-        end
-        
-        def properties_for_map(properties)
-          if properties.nil?
-            'null'
-          else
-            '{' + properties.map{|p| "#{p}: doc.#{p}"}.join(', ') + '}'
-          end
-        end
-      end
-    end
-  end
-end

data/lib/couch_potato/persistence/external_collection.rb

@@ -1,83 +0,0 @@
-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 all(options = {}, view_options = {})
-        if options.empty? && view_options.empty?
-          items
-        else
-          Finder.new.find @item_class, options.merge(@owner_id_attribute_name => @owner_id), view_options
-        end
-      end
-      
-      def first(options = {}, view_options = {})
-        if options.empty? && view_options.empty?
-          items.first
-        else
-          Finder.new.find(@item_class, options.merge(@owner_id_attribute_name => @owner_id), view_options).first
-        end
-      end
-      
-      def count(options = {}, view_options = {})
-        Finder.new.count @item_class, options.merge(@owner_id_attribute_name => @owner_id), view_options
-      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 dirty?
-        return unless @items
-        @original_item_ids != @items.map(&:_id) || @items.inject(false) {|res, item| res || item.dirty?}
-      end
-      
-      def items
-        unless @items
-          @items = Finder.new.find @item_class, @owner_id_attribute_name => owner_id
-          @original_item_ids = @items.map(&:_id)
-        end
-        @items
-      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

@@ -1,72 +0,0 @@
-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 dirty?(object)
-        object.send("#{name}").dirty?
-      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

@@ -1,21 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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 = {})
-        to_instances clazz, ViewQuery.new(design_document(clazz), view(conditions), map_function(clazz, search_fields(conditions)), nil, conditions, view_options).query_view!
-      end
-      
-      def count(clazz, conditions = {}, view_options = {})
-        ViewQuery.new(design_document(clazz), view(conditions) + '_count', map_function(clazz, search_fields(conditions)), count_reduce_function, conditions, view_options).query_view!['rows'].first.try(:[], 'value') || 0
-      end
-      
-      private
-      
-      def db(name = nil)
-        ::CouchPotato::Persistence.Db(name)
-      end
-      
-      def design_document(clazz)
-        clazz.name.underscore
-      end
-      
-      def map_function(clazz, search_fields)
-        "function(doc) {
-          if(doc.ruby_class == '#{clazz}') {
-            emit(
-              [#{search_fields.map{|attr| "doc[\"#{attr}\"]"}.join(', ')}], doc
-                );
-          }
-        }"
-      end
-      
-      def count_reduce_function
-        "function(keys, values, combine) {
-          if (combine) {
-            return sum(values);
-          } else {
-            return values.length;
-          }
-        }"
-      end
-      
-      def to_instances(clazz, query_result)
-        query_result['rows'].map{|doc| doc['value']}.map{|json| clazz.json_create json}
-      end
-      
-      def view(conditions)
-        "by_#{view_name(conditions)}"
-      end
-      
-      def search_fields(conditions)
-        conditions.to_a.sort_by{|f| f.first.to_s}.map(&:first)
-      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_has_many_property.rb

@@ -1,43 +0,0 @@
-class InlineHasManyProperty
-  attr_accessor :name
-  
-  def initialize(owner_clazz, name, options = {})
-    @name = name
-    getter =  <<-GETTER
-      def #{name}
-        @#{name} ||= CouchPotato::Persistence::InlineCollection.new(#{item_class_name})
-      end
-    GETTER
-    owner_clazz.class_eval getter
-  end
-  
-  def build(object, json)
-    object.send("#{name}").clear
-    json[name.to_s].each do |item|
-      item.delete 'ruby_class'
-      object.send("#{name}").build item
-    end
-  end
-  
-  def dirty?(object)
-    object.send("#{name}").dirty?
-  end
-  
-  def save(object)
-    
-  end
-  
-  def serialize(json, object)
-    json[name.to_s] = object.send(name)
-  end
-  
-  def destroy(object)
-    
-  end
-  
-  private
-  
-  def item_class_name
-    @name.to_s.singularize.camelcase
-  end
-end

data/lib/couch_potato/persistence/view_query.rb

@@ -1,81 +0,0 @@
-module CouchPotato
-  module Persistence
-
-    class ViewQuery
-      def initialize(design_document_name, view_name, map_function, reduce_function = nil, conditions = {}, view_options = {})
-        @design_document_name = design_document_name
-        @view_name = view_name
-        @map_function = map_function
-        @reduce_function = reduce_function
-        @conditions = conditions
-        @view_options = view_options
-      end
-      
-      def query_view!
-        begin
-          query_view
-        rescue RestClient::ResourceNotFound => e
-          create_view
-          query_view
-        end
-      end
-      
-      private
-      
-      def create_view
-        # 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/#{@design_document_name}" rescue nil
-        design_doc ||= {'views' => {}, "_id" => "_design/#{@design_document_name}"}
-        design_doc['views'][@view_name.to_s] = {
-          'map' => @map_function,
-          'reduce' => @reduce_function
-        }
-        db.save(design_doc)
-      end
-      
-      def db(name = nil)
-        ::CouchPotato::Persistence.Db(name)
-      end
-      
-      def query_view
-        db.view view_url, search_keys
-      end
-      
-      def view_url
-        "#{@design_document_name}/#{@view_name}"
-      end
-      
-      def search_keys
-        if search_values.select{|v| v.is_a?(Range)}.any?
-          {:startkey => search_values.map{|v| v.is_a?(Range) ? v.first : v}, :endkey => search_values.map{|v| v.is_a?(Range) ? v.last : v}}.merge(view_options)
-        elsif search_values.select{|v| v.is_a?(Array)}.any?
-          {:keys => prepare_multi_key_search(search_values)}.merge(view_options)
-        else
-          view_options.merge(search_values.any? ? {:key => search_values} : {})
-        end
-      end
-      
-      def search_values
-        conditions.to_a.sort_by{|f| f.first.to_s}.map(&:last)
-      end
-      
-      def view_options
-        @view_options
-      end
-      
-      def conditions
-        @conditions
-      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
-    end
-  end
-end

data/lib/couch_potato/versioning.rb

@@ -1,46 +0,0 @@
-module CouchPotato
-  module Versioning
-    def self.included(base)
-      base.class_eval do
-        property :version
-        property :master_version_id
-        cattr_accessor :new_version_condition
-        before_create :set_version_default
-        before_update :prepare_for_new_version
-        
-        def self.set_version_condition(lambda)
-          self.new_version_condition = lambda
-        end
-      end
-    end
-    
-    def versions(version_no = nil)
-      if version_no
-        CouchPotato::Persistence::Finder.new.find(self.class, :version => version_no).first
-      elsif version == 1
-        [self]
-      else
-        CouchPotato::Persistence::Finder.new.find(self.class, :master_version_id => _id).sort_by(&:version)
-      end
-    end
-    
-    private
-    
-    def set_version_default
-      self.version ||= 1
-    end
-    
-    def prepare_for_new_version
-      if new_version_condition.nil? || new_version_condition.call(self)
-        copy = self.class.get self._id
-        copy._id = nil
-        copy._rev = nil
-        copy.master_version_id = self._id
-        copy.save_without_callbacks
-        self.master_version_id ||= self.id
-        self.version += 1
-      end
-    end
-    
-  end
-end

data/spec/attributes_spec.rb

@@ -1,42 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper'
-
-class Plant
-  include CouchPotato::Persistence
-  property :leaf_count
-end
-
-describe "attributes" do
-  before(:all) do
-    CouchPotato::Persistence.Db!
-  end
-  
-  describe 'attributes=' do
-    it "should assign the attributes" do
-      plant = Plant.new 
-      plant.attributes = {:leaf_count => 1}
-      plant.leaf_count.should == 1
-    end
-  end
-
-  describe "attributes" do
-    it "should return the attributes" do
-      plant = Plant.new :leaf_count => 1
-      plant.attributes .should == {:leaf_count => 1}
-    end
-  end
-
-  describe 'update_attributes' do
-    it "should assign the attributes" do
-      plant = Plant.new 
-      plant.update_attributes :leaf_count => 1
-      plant.leaf_count.should == 1
-    end
-
-    it "should save the object" do
-      plant = Plant.new 
-      plant.update_attributes :leaf_count => 1
-      plant.should_not be_new_document
-    end
-  end
-end
-