better-ripple 1.0.0

data/lib/ripple/attribute_methods/query.rb

@@ -0,0 +1,34 @@
+require 'active_support/concern'
+
+module Ripple
+  module AttributeMethods
+    module Query
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "?"
+      end
+
+      private
+      # Based on code from ActiveRecord
+      def attribute?(attr_name)
+        unless value = attribute(attr_name)
+          false
+        else
+          prop = self.class.properties[attr_name]
+          if prop.nil?
+            if Numeric === value || value !~ /[^0-9]/
+              !value.to_i.zero?
+            else
+              Boolean.ripple_cast(value) || value.present?
+            end
+          elsif prop.type <= Numeric
+            !value.zero?
+          else
+            value.present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ripple/attribute_methods/read.rb

@@ -0,0 +1,28 @@
+require 'active_support/concern'
+
+module Ripple
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+
+      if ActiveSupport::VERSION::STRING < '3.2'
+        included do
+          attribute_method_suffix ''
+        end
+      end
+
+      def [](attr_name)
+        attribute(attr_name)
+      end
+
+      private
+      def attribute(attr_name)
+        if @attributes.include?(attr_name)
+          @attributes[attr_name]
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/ripple/attribute_methods/write.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+
+module Ripple
+  module AttributeMethods
+    module Write
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "="
+      end
+
+      def []=(attr_name, value)
+        __send__(:attribute=, attr_name, value)
+      end
+
+      private
+      def attribute=(attr_name, value)
+        if prop = self.class.properties[attr_name]
+          value = prop.type_cast(value)
+        end
+        @attributes[attr_name] = value
+      end
+    end
+  end
+end

data/lib/ripple/callbacks.rb

@@ -0,0 +1,71 @@
+require 'active_support/concern'
+require 'active_model/callbacks'
+
+module Ripple
+  # Adds lifecycle callbacks to {Ripple::Document} models, in the typical
+  # ActiveModel fashion.
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    CALLBACK_TYPES = [:create, :update, :save, :destroy, :validation]
+
+    included do
+      extend ActiveModel::Callbacks
+      define_model_callbacks *(CALLBACK_TYPES - [:validation])
+      define_callbacks :validation, :terminator => "result == false", :scope => [:kind, :name]
+    end
+
+    module ClassMethods
+      # Defines a callback to be run before validations.
+      def before_validation(*args, &block)
+        options = args.last
+        if options.is_a?(Hash) && options[:on]
+          options[:if] = Array(options[:if])
+          options[:if] << "@_on_validate == :#{options[:on]}"
+        end
+        set_callback(:validation, :before, *args, &block)
+      end
+
+      # Defines a callback to be run after validations.
+      def after_validation(*args, &block)
+        options = args.extract_options!
+        options[:prepend] = true
+        options[:if] = Array(options[:if])
+        options[:if] << "!halted && value != false"
+        options[:if] << "@_on_validate == :#{options[:on]}" if options[:on]
+        set_callback(:validation, :after, *(args << options), &block)
+      end
+    end
+
+    # @private
+    def really_save(*args, &block)
+      run_save_callbacks do
+        super
+      end
+    end
+    
+    def run_save_callbacks
+      state = new? ? :create : :update
+      run_callbacks(:save) do
+        run_callbacks(state) do
+          yield
+        end
+      end
+    end
+    
+    # @private
+    def destroy!(*args, &block)
+      run_callbacks(:destroy) do
+        super
+      end
+    end
+    
+    # @private
+    def valid?(*args, &block)
+      @_on_validate = new? ? :create : :update
+      run_callbacks(:validation) do
+        super
+      end
+    end
+  end
+end

data/lib/ripple/conflict/basic_resolver.rb

@@ -0,0 +1,86 @@
+module Ripple
+  module Conflict
+    class BasicResolver
+      delegate :model_class, :document, :siblings, :to => :@main_resolver
+
+      def initialize(main_resolver)
+        @main_resolver = main_resolver
+      end
+
+      def remaining_conflicts
+        @remaining_conflicts ||= []
+      end
+
+      def unexpected_conflicts
+        # if the user didn't specify the conflict they expect,
+        # then don't consider any conflicts unexpected
+        return [] if model_class.expected_conflicts.blank?
+
+        remaining_conflicts - model_class.expected_conflicts
+      end
+
+      def perform
+        process_properties
+        process_embedded_associations
+        process_linked_associations
+        process_stored_key_associations
+      end
+
+      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))
+        end
+      end
+
+      def process_embedded_associations
+        model_class.embedded_associations.each do |assoc|
+          document.send(:"#{assoc.name}=", resolved_association_value_for(assoc, :load_target))
+        end
+      end
+
+      def process_linked_associations
+        model_class.linked_associations.each do |assoc|
+          document.send(assoc.name).replace_links(resolved_association_value_for(assoc, :links))
+        end
+      end
+
+      def process_stored_key_associations
+        model_class.stored_key_associations.each do |assoc|
+          document.send(assoc.name).reset_owner_keys if (assoc.type == :many)
+        end
+      end
+
+      def resolved_property_value_for(property)
+        uniq_values = undeleted_siblings.map(&property.key).uniq
+
+        value = if uniq_values.size == 1
+          uniq_values.first
+        elsif property.key == :updated_at
+          uniq_values.compact.max
+        elsif property.key == :created_at
+          uniq_values.compact.min
+        else
+          remaining_conflicts << property.key
+          property.default
+        end
+      end
+
+      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 = 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
+
+        association.many? ? [] : nil # default value
+      end
+    end
+  end
+end
+

data/lib/ripple/conflict/document_hooks.rb

@@ -0,0 +1,46 @@
+module Ripple
+  module Conflict
+    module DocumentHooks
+      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
+      end
+    end
+  end
+end

data/lib/ripple/conflict/resolver.rb

@@ -0,0 +1,79 @@
+require 'ripple/conflict/basic_resolver'
+
+module Ripple
+  module Conflict
+    class Resolver
+      include Translation
+
+      attr_reader :document, :model_class
+
+      delegate :expected_conflicts, :on_conflict_block, :to => :model_class
+
+      def self.to_proc
+        @to_proc ||= lambda do |robject|
+          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)
+          resolver.resolve
+          resolver.document.robject
+        end
+      end
+
+      Riak::RObject.on_conflict(&self)
+
+      def initialize(robject, model_class)
+        @robject = robject
+        @model_class = model_class
+      end
+
+      def resolve
+        assert_conflict_block
+        basic_resolver.perform
+        assert_no_unexpected_conflicts
+        document.instance_exec(siblings, basic_resolver.remaining_conflicts, &on_conflict_block)
+        document.update_robject
+      end
+
+      def siblings
+        @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
+        # pick a sibling robject to use as the basis of the document to resolve
+        # which one doesn't really matter.
+        @document ||= @model_class.send(:instantiate, @robject.siblings.first.dup)
+      end
+
+      private
+
+      def basic_resolver
+        @basic_resolver ||= BasicResolver.new(self)
+      end
+
+      def assert_conflict_block
+        return if on_conflict_block
+
+        raise NotImplementedError, t('conflict_handler_not_implemented', :document => document)
+      end
+
+      def assert_no_unexpected_conflicts
+        return unless basic_resolver.unexpected_conflicts.any?
+
+        raise NotImplementedError, t('unexpected_conflicts',
+          :conflicts => basic_resolver.unexpected_conflicts.inspect,
+          :document  => document.inspect
+        )
+      end
+    end
+  end
+end
+

data/lib/ripple/conflict/test_helper.rb

@@ -0,0 +1,34 @@
+module Ripple
+  module Conflict
+    module TestHelper
+      def create_conflict(main_record, *modifiers)
+        # We have to disable all on conflict resolvers while we create conflict
+        # so that they don't auto-resolve it.
+        orig_hooks = Riak::RObject.on_conflict_hooks.dup
+        Riak::RObject.on_conflict_hooks.clear
+
+        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 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! unless record.deleted?
+          end
+
+          robject = klass.bucket.get(key)
+          raise "#{robject} is not in conflict as expected." unless robject.conflict?
+        ensure
+          orig_hooks.each do |hook|
+            Riak::RObject.on_conflict(&hook)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/ripple/conversion.rb

@@ -0,0 +1,29 @@
+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
+    def new_record?
+      new?
+    end
+
+    # True if this is not a new document
+    def persisted?
+      !new?
+    end
+
+    # Converts to a view key
+    def to_key
+      new? ? nil : [key]
+    end
+
+    # Converts to a URL parameter
+    def to_param
+      key
+    end
+  end
+end

data/lib/ripple/core_ext.rb

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