ripple 1.0.0.beta → 1.0.0.beta2

data/lib/ripple/attribute_methods/dirty.rb

@@ -33,8 +33,8 @@ module Ripple
       end
 
       # @private
-      def initialize(attrs={})
-        super(attrs)
+      def initialize(*args)
+        super
         changed_attributes.clear
       end
 

data/lib/ripple/attribute_methods/read.rb

@@ -5,8 +5,10 @@ module Ripple
     module Read
       extend ActiveSupport::Concern
 
-      included do
-        attribute_method_suffix ""
+      if ActiveSupport::VERSION::STRING < '3.2'
+        included do
+          attribute_method_suffix ''
+        end
       end
 
       def [](attr_name)

data/lib/ripple/callbacks.rb

@@ -38,36 +38,33 @@ module Ripple
     end
 
     # @private
-    module InstanceMethods
-      # @private
-      def really_save(*args, &block)
-        run_save_callbacks do
-          super
-        end
+    def really_save(*args, &block)
+      run_save_callbacks do
+        super
       end
-
-      def run_save_callbacks
-        state = new? ? :create : :update
-        run_callbacks(:save) do
-          run_callbacks(state) do
-            yield
-          end
+    end
+    
+    def run_save_callbacks
+      state = new? ? :create : :update
+      run_callbacks(:save) do
+        run_callbacks(state) do
+          yield
         end
       end
-
-      # @private
-      def destroy(*args, &block)
-        run_callbacks(:destroy) do
-          super
-        end
+    end
+    
+    # @private
+    def destroy!(*args, &block)
+      run_callbacks(:destroy) do
+        super
       end
-
-      # @private
-      def valid?(*args, &block)
-        @_on_validate = new? ? :create : :update
-        run_callbacks(:validation) do
-          super
-        end
+    end
+    
+    # @private
+    def valid?(*args, &block)
+      @_on_validate = new? ? :create : :update
+      run_callbacks(:validation) do
+        super
       end
     end
   end

data/lib/ripple/conflict/basic_resolver.rb

@@ -28,6 +28,10 @@ module Ripple
 
       private
 
+      def undeleted_siblings
+        @undeleted_siblings ||= siblings.reject(&:deleted?)
+      end
+
       def process_properties
         model_class.properties.each do |name, property|
           document.send(:"#{name}=", resolved_property_value_for(property))
@@ -53,7 +57,7 @@ module Ripple
       end
 
       def resolved_property_value_for(property)
-        uniq_values = siblings.map(&property.key).uniq
+        uniq_values = undeleted_siblings.map(&property.key).uniq
 
         value = if uniq_values.size == 1
           uniq_values.first
@@ -69,7 +73,7 @@ module Ripple
 
       def resolved_association_value_for(association, proxy_value_method)
         # the association proxy doesn't uniquify well, so we have to use the target or links directly
-        uniq_values = siblings.map { |s| s.send(association.name).__send__(proxy_value_method) }.uniq
+        uniq_values = undeleted_siblings.map { |s| s.send(association.name).__send__(proxy_value_method) }.uniq
 
         return uniq_values.first if uniq_values.size == 1
         remaining_conflicts << association.name

data/lib/ripple/conflict/document_hooks.rb

@@ -4,13 +4,39 @@ module Ripple
       extend ActiveSupport::Concern
 
       module ClassMethods
+        # @return [Proc] the registered conflict handler
         attr_reader :on_conflict_block
 
+        # Registers a conflict handler for this model.
+        #
+        # @param [Array<Symbol>] expected_conflicts the list of properties and associations
+        #                        you expect to be in conflict.
+        # @yield the conflict handler block
+        # @yieldparam [Array<Ripple::Document>] siblings the sibling documents
+        # @yieldparam [Array<Symbol>] conflicts the properties and associations that could not
+        #                             be resolved by ripple's basic resolution logic.
+        #
+        # The block is instance_eval'd in the context of a partially resolved model instance.
+        # Thus, you should apply your resolution logic directly to self. Before calling
+        # your block, Ripple attempts some basic resolution on your behalf:
+        #
+        # * Any property or association for which all siblings agree will be set to the common value.
+        # * created_at will be set to the minimum value.
+        # * updated_at will be set to the maximum value.
+        # * All other properties and associations will be set to the default: nil or the default
+        #   value for a property, nil for a one association, and an empty array for a many association.
+        #
+        # Note that any conflict you do not resolve is a potential source of data loss (since ripple
+        # sets it to a default such as nil). It is recommended (but not required) that you pass the list
+        # of expected conflicts, as that informs ripple of what conflicts your block handles. If it detects
+        # conflicts for any other properties or associations, a NotImplementedError will be raised.
         def on_conflict(*expected_conflicts, &block)
           @expected_conflicts = expected_conflicts
           @on_conflict_block = block
         end
 
+        # @return [Array<Symbol>] list of properties and associations that are expected
+        #                         to be in conflict.
         def expected_conflicts
           @expected_conflicts ||= []
         end

data/lib/ripple/conflict/resolver.rb

@@ -11,7 +11,7 @@ module Ripple
 
       def self.to_proc
         @to_proc ||= lambda do |robject|
-          possible_model_classes = robject.siblings.map { |s| s.data['_type'] }.uniq
+          possible_model_classes = robject.siblings.map { |s| s.data && s.data['_type'] }.compact.uniq
           return nil unless possible_model_classes.size == 1
 
           resolver = new(robject, possible_model_classes.first.constantize)
@@ -36,7 +36,15 @@ module Ripple
       end
 
       def siblings
-        @siblings ||= @robject.siblings.map { |s| @model_class.send(:instantiate, s) }
+        @siblings ||= @robject.siblings.map do |s|
+          @model_class.send(:instantiate, s).tap do |record|
+            # TODO: make the deleted conditional explicit by putting logic in
+            #       RObject to know it has loaded a deleted sibling.
+            #       Here we assume it is deleted if the data is nil because
+            #       that's the only way we know of that the data can be nil.
+            record.instance_variable_set(:@deleted, true) if s.data.nil?
+          end
+        end
       end
 
       def document

data/lib/ripple/conflict/test_helper.rb

@@ -9,14 +9,15 @@ module Ripple
 
         begin
           klass, key = main_record.class, main_record.key
+          raise "#{klass.bucket.name} allow_mult property is false!" unless klass.bucket.allow_mult
           records = modifiers.map { |_| klass.find!(key) }
 
           records.zip(modifiers).each do |(record, modifier)|
-            # necessary to get conflict, so riak thinks they are being saved by different clients
+            # necessary to get conflict on 0.14 and earlier, so riak thinks they are being saved by different clients
             Ripple.client.client_id += 1
 
             modifier.call(record)
-            record.save!
+            record.save! unless record.deleted?
           end
 
           robject = klass.bucket.get(key)

data/lib/ripple/conversion.rb

@@ -3,6 +3,7 @@ require 'active_model/conversion'
 module Ripple
   # Provides ActionPack compatibility for {Ripple::Document} models.
   module Conversion
+    extend  ActiveSupport::Concern
     include ActiveModel::Conversion
 
     # True if this is a new document

data/lib/ripple/core_ext.rb

@@ -1,2 +1,3 @@
 require 'ripple/core_ext/casting'
 require 'ripple/core_ext/object'
+require 'ripple/core_ext/indexes'

data/lib/ripple/core_ext/casting.rb

@@ -71,6 +71,8 @@ BooleanCast = Module.new do
       !value.zero?
     when TrueClass, FalseClass
       value
+    when /^\s*0/
+      false
     when /^\s*t/i
       true
     when /^\s*f/i

data/lib/ripple/core_ext/indexes.rb

@@ -0,0 +1,89 @@
+require 'tzinfo'
+require 'active_support/core_ext/date/conversions'
+require 'active_support/core_ext/date/zones'
+require 'active_support/core_ext/date_time/conversions'
+require 'active_support/core_ext/date_time/zones'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/time/zones'
+require 'active_support/core_ext/string/conversions'
+require 'ripple/property_type_mismatch'
+require 'set'
+
+# @private
+class Object
+  def to_ripple_index(type)
+    case type
+    when 'bin'
+      to_s
+    when 'int'
+      to_i
+    end
+  end
+end
+
+# @private
+class Time
+  def to_ripple_index(type)
+    case type
+    when 'bin'
+      utc.send(Ripple.date_format)
+    when 'int'
+      # Use millisecond-precision
+      (utc.to_f * 1000).round
+    end
+  end
+end
+
+# @private
+class Date
+  def to_ripple_index(type)
+    case type
+    when 'bin'
+      to_s(Ripple.date_format)
+    when 'int'
+      to_time(:utc).to_ripple_index(type)
+    end
+  end
+end
+
+# @private
+class DateTime
+  def to_ripple_index(type)
+    case type
+    when 'bin'
+      utc.to_s(Ripple.date_format)
+    when 'int'
+      (utc.to_f * 1000).round
+    end
+  end
+end
+
+# @private
+module ActiveSupport
+  class TimeWithZone
+    def to_ripple_index(type)
+      utc.to_ripple_index(type)
+    end
+  end
+end
+
+# @private
+module Enumerable
+  def to_ripple_index(type)
+    Set.new(map {|v| v.to_ripple_index(type) })
+  end
+end
+
+if String < Enumerable
+  # Fix for 1.8, in which String is Enumerable
+  class String
+    def to_ripple_index(type)
+      case type
+      when 'bin'
+        to_s
+      when 'int'
+        to_i
+      end
+    end
+  end
+end

data/lib/ripple/document.rb

@@ -8,6 +8,7 @@ require 'ripple/document/finders'
 require 'ripple/document/link'
 require 'ripple/properties'
 require 'ripple/attribute_methods'
+require 'ripple/indexes'
 require 'ripple/timestamps'
 require 'ripple/validations'
 require 'ripple/associations'
@@ -55,6 +56,8 @@ module Ripple
       include Ripple::Document::Finders
       include Ripple::AttributeMethods
       include Ripple::Timestamps
+      include Ripple::Indexes
+      include Ripple::Indexes::DocumentMethods
       include Ripple::Validations
       include Ripple::Associations
       include Ripple::Callbacks
@@ -72,32 +75,30 @@ module Ripple
       end
     end
 
-    module InstanceMethods
-      def _root_document
-        self
-      end
+    def _root_document
+      self
+    end
 
-      # Returns true if the +comparison_object+ is the same object, or is of the same type and has the same key.
-      def ==(comparison_object)
-        comparison_object.equal?(self) ||
-          (comparison_object.class < Document && (comparison_object.instance_of?(self.class) || comparison_object.class.bucket.name == self.class.bucket.name) &&
-           !new? && comparison_object.key == key && !comparison_object.new?)
-      end
+    # Returns true if the +comparison_object+ is the same object, or is of the same type and has the same key.
+    def ==(comparison_object)
+      comparison_object.equal?(self) ||
+        (comparison_object.class < Document && (comparison_object.instance_of?(self.class) || comparison_object.class.bucket.name == self.class.bucket.name) &&
+         !new? && comparison_object.key == key && !comparison_object.new?)
+    end
 
-      def eql?(other)
-        return true if other.equal?(self)
+    def eql?(other)
+      return true if other.equal?(self)
 
-        (other.class.equal?(self.class)) &&
-        !other.new? && !new? &&
-        (other.key == key)
-      end
+      (other.class.equal?(self.class)) &&
+      !other.new? && !new? &&
+      (other.key == key)
+    end
 
-      def hash
-        if new?
-          super # every new document should be treated as a different doc
-        else
-          [self.class, key].hash
-        end
+    def hash
+      if new?
+        super # every new document should be treated as a different doc
+      else
+        [self.class, key].hash
       end
     end
   end

data/lib/ripple/document/key.rb

@@ -17,20 +17,18 @@ module Ripple
         end
       end
 
-      module InstanceMethods
-        # Reads the key for this Document.
-        def key
-          @key
-        end
-
-        # Sets the key for this Document.
-        def key=(value)
-          @key = value.to_s
-        end
-
-        def key_attr
-          :key
-        end
+      # Reads the key for this Document.
+      def key
+        @key
+      end
+      
+      # Sets the key for this Document.
+      def key=(value)
+        @key = value.to_s
+      end
+      
+      def key_attr
+        :key
       end
     end
   end

data/lib/ripple/document/persistence.rb

@@ -8,8 +8,8 @@ module Ripple
       module ClassMethods
 
         # Instantiates a new record, applies attributes from a block, and saves it
-        def create(attrs={}, &block)
-          new(attrs, &block).tap {|s| s.save }
+        def create(*args, &block)
+          new(*args, &block).tap {|s| s.save }
         end
 
         # Destroys all records one at a time.
@@ -26,90 +26,105 @@ module Ripple
         end
       end
 
-      module InstanceMethods
-        # @private
-        def initialize
-          super
-          @new = true
-        end
-
-        # Determines whether this is a new document.
-        def new?
-          @new || false
-        end
-
-        # Updates a single attribute and then saves the document
-        # NOTE: THIS SKIPS VALIDATIONS! Use with caution.
-        # @return [true,false] whether the document succeeded in saving
-        def update_attribute(attribute, value)
-          send("#{attribute}=", value)
-          save(:validate => false)
-        end
-
-        # Writes new attributes and then saves the document
-        # @return [true,false] whether the document succeeded in saving
-        def update_attributes(attrs)
-          self.attributes = attrs
-          save
-        end
-
-        # Saves the document in Riak.
-        # @return [true,false] whether the document succeeded in saving
-        def save(*args)
-          really_save(*args)
-        end
-
-        def really_save(*args)
-          update_robject
-          robject.store(self.class.quorums.slice(:w,:dw))
-          self.key = robject.key
-          @new = false
-          true
-        end
-
-        # Reloads the document from Riak
-        # @return self
-        def reload
-          return self if new?
-          @robject = @robject.reload(:force => true)
-          self.__send__(:raw_attributes=, @robject.data.except("_type"))
-          reset_associations
-          self
-        end
-
-        # Deletes the document from Riak and freezes this instance
-        def destroy
-          robject.delete(self.class.quorums.slice(:rw)) unless new?
-          freeze
-          true
-        rescue Riak::FailedRequest
-          false
-        end
-
-        # Freezes the document, preventing further modification.
-        def freeze
-          @attributes.freeze; super
-        end
-
-        attr_writer :robject
-
-        def robject
-          @robject ||= Riak::RObject.new(self.class.bucket, key).tap do |obj|
-            obj.content_type = "application/json"
-          end
-        end
-
-        def update_robject
-          robject.key = key if robject.key != key
-          robject.content_type = 'application/json'
-          robject.data = attributes_for_persistence
-        end
-
-        private
-        def attributes_for_persistence
-          raw_attributes.merge("_type" => self.class.name)
+      # @private
+      def initialize
+        super
+        @new = true
+        @deleted = false
+      end
+      
+      # Determines whether this document has been deleted or not.
+      def deleted?
+        @deleted
+      end
+      
+      # Determines whether this is a new document.
+      def new?
+        @new || false
+      end
+      
+      # Updates a single attribute and then saves the document
+      # NOTE: THIS SKIPS VALIDATIONS! Use with caution.
+      # @return [true,false] whether the document succeeded in saving
+      def update_attribute(attribute, value)
+        send("#{attribute}=", value)
+        save(:validate => false)
+      end
+      
+      # Writes new attributes and then saves the document
+      # @return [true,false] whether the document succeeded in saving
+      def update_attributes(attrs)
+        self.attributes = attrs
+        save
+      end
+      
+      # Saves the document in Riak.
+      # @return [true,false] whether the document succeeded in saving
+      def save(*args)
+        really_save(*args)
+      end
+      
+      def really_save(*args)
+        update_robject
+        robject.store(self.class.quorums.slice(:w,:dw))
+        self.key = robject.key
+        @new = false
+        true
+      end
+      
+      # Reloads the document from Riak
+      # @return self
+      def reload
+        return self if new?
+        @robject = @robject.reload(:force => true)
+        self.__send__(:raw_attributes=, @robject.data.except("_type"))
+        reset_associations
+        self
+      end
+      
+      # Deletes the document from Riak and freezes this instance
+      def destroy!
+        robject.delete(self.class.quorums.slice(:rw)) unless new?
+        @deleted = true
+        freeze
+      end
+      
+      def destroy
+        destroy!
+        true
+      rescue Riak::FailedRequest
+        false
+      end
+      
+      # Freeze the attributes hash instead of the record itself to avoid
+      # errors when calling methods on frozen records.
+      def freeze
+        @attributes.freeze
+      end
+      
+      # Returns +true+ if the attributes hash has been frozen.
+      def frozen?
+        @attributes.frozen?
+      end
+      
+      attr_writer :robject
+      
+      def robject
+        @robject ||= Riak::RObject.new(self.class.bucket, key).tap do |obj|
+          obj.content_type = "application/json"
         end
       end
+      
+      def update_robject
+        robject.key = key if robject.key != key
+        robject.content_type = 'application/json'
+        robject.data = attributes_for_persistence
+      end
+      
+      private
+      def attributes_for_persistence
+        raw_attributes.merge("_type" => self.class.name)
+      end
     end
   end
 end