better-ripple 1.0.0

data/lib/ripple/core_ext/casting.rb

@@ -0,0 +1,151 @@
+require 'tzinfo'
+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
+
+BooleanCast = Module.new do
+  def ripple_cast(value)
+    case value
+    when NilClass
+      nil
+    when Numeric
+      !value.zero?
+    when TrueClass, FalseClass
+      value
+    when /^\s*0/
+      false
+    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.send(:extend, BooleanCast)
+TrueClass.send(:extend, BooleanCast)
+FalseClass.send(:extend, BooleanCast)
+
+# @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
+

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/core_ext/object.rb

@@ -0,0 +1,8 @@
+unless respond_to?(:define_singleton_method)
+  class Object
+    def define_singleton_method(name, &block)
+      singleton_class = class << self; self; end
+      singleton_class.send(:define_method, name, &block)
+    end
+  end
+end

data/lib/ripple/document.rb

@@ -0,0 +1,105 @@
+require 'active_support/concern'
+require 'active_model/naming'
+require 'ripple/conflict/document_hooks'
+require 'ripple/document/bucket_access'
+require 'ripple/document/key'
+require 'ripple/document/persistence'
+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'
+require 'ripple/callbacks'
+require 'ripple/observable'
+require 'ripple/conversion'
+require 'ripple/inspection'
+require 'ripple/nested_attributes'
+require 'ripple/serialization'
+
+module Ripple
+  # Represents a model stored in Riak, serialized in JSON object (document).
+  # Ripple::Document models aim to be fully ActiveModel compatible, with a keen
+  # eye toward features that developers expect from ActiveRecord, DataMapper and MongoMapper.
+  #
+  # Example:
+  #
+  #   class Email
+  #     include Ripple::Document
+  #     property :from,    String, :presence => true
+  #     property :to,      String, :presence => true
+  #     property :sent,    Time,   :default => proc { Time.now }
+  #     property :body,    String
+  #   end
+  #
+  #   email = Email.find("37458abc752f8413e")  # GET /riak/emails/37458abc752f8413e
+  #   email.from = "someone@nowhere.net"
+  #   email.save                               # PUT /riak/emails/37458abc752f8413e
+  #
+  #   reply = Email.new
+  #   reply.from = "justin@bashoooo.com"
+  #   reply.to   = "sean@geeemail.com"
+  #   reply.body = "Riak is a good fit for scalable Ruby apps."
+  #   reply.save                               # POST /riak/emails (Riak-assigned key)
+  #
+  module Document
+    extend ActiveSupport::Concern
+
+    included do
+      extend ActiveModel::Naming
+      extend BucketAccess
+      include Ripple::Document::Key
+      include Ripple::Document::Persistence
+      extend Ripple::Properties
+      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
+      include Ripple::Observable
+      include Ripple::Conversion
+      include Ripple::Inspection
+      include Ripple::NestedAttributes
+      include Ripple::Serialization
+      include Ripple::Conflict::DocumentHooks
+    end
+
+    module ClassMethods
+      def embeddable?
+        false
+      end
+    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
+
+    def eql?(other)
+      return true if other.equal?(self)
+
+      (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
+    end
+  end
+end

data/lib/ripple/document/bucket_access.rb

@@ -0,0 +1,25 @@
+require 'ripple'
+
+module Ripple
+  module Document
+    # Similar to ActiveRecord's tables or MongoMapper's collections, we
+    # provide a sane default bucket in which to store your documents.
+    module BucketAccess
+      # @return [String] The bucket name assigned to the document class.  Subclasses will inherit their bucket name from their parent class unless they redefine it.
+      def bucket_name
+        superclass.respond_to?(:bucket_name) ? superclass.bucket_name : model_name.plural
+      end
+
+      # @return [Riak::Bucket] The bucket assigned to this class.
+      def bucket
+        Ripple.client.bucket(bucket_name)
+      end
+
+      # Set the bucket name for this class and its subclasses.
+      # @param [String] value the new bucket name
+      def bucket_name=(value)
+        (class << self; self; end).send(:define_method, :bucket_name){ value }
+      end
+    end
+  end
+end

data/lib/ripple/document/finders.rb

@@ -0,0 +1,131 @@
+require 'ripple/translation'
+require 'active_support/concern'
+require 'active_support/inflector'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+require 'ripple/conflict/resolver'
+
+module Ripple
+
+  # Raised by <tt>find!</tt> when a document cannot be found with the given key.
+  #   begin
+  #     Example.find!('badkey')
+  #   rescue Ripple::DocumentNotFound
+  #     puts 'No Document here!'
+  #   end
+  class DocumentNotFound < StandardError
+    include Translation
+    def initialize(keys, found)
+      if keys.empty?
+        super(t("document_not_found.no_key"))
+      elsif keys.size == 1
+        super(t("document_not_found.one_key", :key => keys.first))
+      else
+        missing = keys - found.compact.map(&:key)
+        super(t("document_not_found.many_keys", :keys => missing.join(', ')))
+      end
+    end
+  end
+
+  module Document
+    module Finders
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Retrieve single or multiple documents from Riak.
+        # @overload find(key)
+        #   Find a single document.
+        #   @param [String] key the key of a document to find
+        #   @return [Document] the found document, or nil
+        # @overload find(key1, key2, ...)
+        #   Find a list of documents.
+        #   @param [String] key1 the key of a document to find
+        #   @param [String] key2 the key of a document to find
+        #   @return [Array<Document>] a list of found documents, including nil for missing documents
+        # @overload find(keylist)
+        #   Find a list of documents.
+        #   @param [Array<String>] keylist an array of keys to find
+        #   @return [Array<Document>] a list of found documents, including nil for missing documents
+        def find(*args)
+          if args.first.is_a?(Array)
+            args.flatten.map {|key| find_one(key) }
+          else
+            args.flatten!
+            return nil if args.empty? || args.all?(&:blank?)
+            return find_one(args.first) if args.size == 1
+            args.map {|key| find_one(key) }
+          end
+        end
+
+        # Retrieve single or multiple documents from Riak
+        # but raise Ripple::DocumentNotFound if a key can
+        # not be found in the bucket.
+        def find!(*args)
+          found = find(*args)
+          raise DocumentNotFound.new(args, found) if !found || Array(found).include?(nil)
+          found
+        end
+
+        # Find the first object using the first key in the
+        # bucket's keys using find. You should not expect to
+        # actually get the first object you added to the bucket.
+        # This is just a convenience method.
+        def first
+          find(bucket.keys.first)
+        end
+
+        # Find the first object using the first key in the
+        # bucket's keys using find!
+        def first!
+          find!(bucket.keys.first)
+        end
+
+        # Find all documents in the Document's bucket and return them.
+        # @overload list()
+        #   Get all documents and return them in an array.
+        #   @param [Hash] options options to be passed to the
+        #     underlying {Bucket#keys} method.
+        #   @return [Array<Document>] all found documents in the bucket
+        # @overload list() {|doc| ... }
+        #   Stream all documents in the bucket through the block.
+        #   @yield [Document] doc a found document
+        # @note This operation is incredibly expensive and should not
+        #     be used in production applications.
+        def list
+          if block_given?
+            bucket.keys do |keys|
+              keys.each do |key|
+                obj = find_one(key)
+                yield obj if obj
+              end
+            end
+            []
+          else
+            bucket.keys.inject([]) do |acc, k|
+              obj = find_one(k)
+              obj ? acc << obj : acc
+            end
+          end
+        end
+
+        private
+        def find_one(key)
+          instantiate(bucket.get(key, quorums.slice(:r)))
+        rescue Riak::FailedRequest => fr
+          raise fr unless fr.not_found?
+        end
+
+        def instantiate(robject)
+          klass = robject.data['_type'].constantize rescue self
+          klass.new.tap do |doc|
+            doc.key = robject.key
+            doc.__send__(:raw_attributes=, robject.data.except("_type")) if robject.data
+            doc.instance_variable_set(:@new, false)
+            doc.instance_variable_set(:@robject, robject)
+            doc.changed_attributes.clear
+          end
+        end
+      end
+    end
+  end
+end