seomoz-ripple 1.0.0.pre

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,26 @@
+require 'active_support/concern'
+
+module Ripple
+  module AttributeMethods
+    module Read
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix ""
+      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,74 @@
+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
+    module InstanceMethods
+      # @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
+end

data/lib/ripple/conflict/basic_resolver.rb

@@ -0,0 +1,82 @@
+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 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 = 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 = 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,20 @@
+module Ripple
+  module Conflict
+    module DocumentHooks
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        attr_reader :on_conflict_block
+
+        def on_conflict(*expected_conflicts, &block)
+          @expected_conflicts = expected_conflicts
+          @on_conflict_block = block
+        end
+
+        def expected_conflicts
+          @expected_conflicts ||= []
+        end
+      end
+    end
+  end
+end

data/lib/ripple/conflict/resolver.rb

@@ -0,0 +1,71 @@
+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['_type'] }.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 { |s| @model_class.send(:instantiate, s) }
+      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,33 @@
+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
+          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
+            Ripple.client.client_id += 1
+
+            modifier.call(record)
+            record.save!
+          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,28 @@
+require 'active_model/conversion'
+
+module Ripple
+  # Provides ActionPack compatibility for {Ripple::Document} models.
+  module Conversion
+    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,2 @@
+require 'ripple/core_ext/casting'
+require 'ripple/core_ext/object'

data/lib/ripple/core_ext/casting.rb

@@ -0,0 +1,148 @@
+require 'active_support/json'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/to_json'
+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 self.ripple_cast(value)
+    value
+  end
+end
+
+# @private
+class Symbol
+  def self.ripple_cast(value)
+    return nil if value.blank?
+    value.respond_to?(:to_s) && value.to_s.intern or raise Ripple::PropertyTypeMismatch.new(self, value)
+  end
+end
+
+# @private
+class Numeric
+  def self.ripple_cast(value)
+    return nil if value.blank?
+    raise Ripple::PropertyTypeMismatch.new(self,value) unless value.respond_to?(:to_i) && value.respond_to?(:to_f)
+    float_value = value.to_f
+    int_value = value.to_i
+    float_value == int_value ? int_value : float_value
+  end
+end
+
+# @private
+class Integer
+  def self.ripple_cast(value)
+    return nil if value.nil? || (String === value && value.blank?)
+    !value.is_a?(Symbol) && value.respond_to?(:to_i) && value.to_i or raise Ripple::PropertyTypeMismatch.new(self, value)
+  end
+end
+
+# @private
+class Float
+  def self.ripple_cast(value)
+    return nil if value.nil? || (String === value && value.blank?)
+    value.respond_to?(:to_f) && value.to_f or raise Ripple::PropertyTypeMismatch.new(self, value)
+  end
+end
+
+# @private
+class String
+  def self.ripple_cast(value)
+    return nil if value.nil?
+    value.respond_to?(:to_s) && value.to_s or raise Ripple::PropertyTypeMismatch.new(self, value)
+  end
+end
+
+boolean_cast = proc do
+  def self.ripple_cast(value)
+    case value
+    when NilClass
+      nil
+    when Numeric
+      !value.zero?
+    when TrueClass, FalseClass
+      value
+    when /^\s*t/i
+      true
+    when /^\s*f/i
+      false
+    else
+      value.present?
+    end
+  end
+end
+
+unless defined?(::Boolean)
+  # Stand-in for true/false property types.
+  module ::Boolean; end
+end
+
+::Boolean.module_eval(&boolean_cast)
+TrueClass.module_eval(&boolean_cast)
+FalseClass.module_eval(&boolean_cast)
+
+# @private
+class Time
+  def as_json(options={})
+    self.utc.send(Ripple.date_format)
+  end
+
+  def self.ripple_cast(value)
+    return nil if value.blank?
+    value.respond_to?(:to_time) && value.to_time or raise Ripple::PropertyTypeMismatch.new(self, value)
+  end
+end
+
+# @private
+class Date
+  def as_json(options={})
+    self.to_s(Ripple.date_format)
+  end
+
+  def self.ripple_cast(value)
+    return nil if value.blank?
+    value.respond_to?(:to_date) && value.to_date or raise Ripple::PropertyTypeMismatch.new(self, value)
+  end
+end
+
+# @private
+class DateTime
+  def as_json(options={})
+    self.utc.to_s(Ripple.date_format)
+  end
+
+  def self.ripple_cast(value)
+    return nil if value.blank?
+    value.respond_to?(:to_datetime) && value.to_datetime or raise Ripple::PropertyTypeMismatch.new(self, value)
+  end
+end
+
+# @private
+module ActiveSupport
+  class TimeWithZone
+    def as_json(options={})
+      self.utc.send(Ripple.date_format)
+    end
+  end
+end
+
+# @private
+class Set
+  def as_json(options = {})
+    map { |e| e.as_json(options) }
+  end
+
+  def self.ripple_cast(value)
+    return nil if value.nil?
+    value.is_a?(Enumerable) && new(value) or raise Ripple::PropertyTypeMismatch.new(self, value)
+  end
+end
+