seomoz-ripple 1.0.0.pre

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,104 @@
+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/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::AttributeMethods
+      include Ripple::Timestamps
+      include Ripple::Validations
+      include Ripple::Associations
+      include Ripple::Callbacks
+      include Ripple::Observable
+      include Ripple::Conversion
+      include Ripple::Document::Finders
+      include Ripple::Inspection
+      include Ripple::NestedAttributes
+      include Ripple::Serialization
+      include Ripple::Conflict::DocumentHooks
+    end
+
+    module ClassMethods
+      def embeddable?
+        false
+      end
+    end
+
+    module InstanceMethods
+      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
+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

data/lib/ripple/document/key.rb

@@ -0,0 +1,43 @@
+require 'active_support/concern'
+
+module Ripple
+  module Document
+    module Key
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Defines the key to be derived from a property.
+        # @param [String,Symbol] prop the property to derive the key from
+        def key_on(prop)
+          class_eval <<-CODE
+          def key
+            #{prop}.to_s
+          end
+          def key=(value)
+            self.#{prop} = value
+          end
+          def key_attr
+            :#{prop}
+          end          
+          CODE
+        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        
+      end
+    end
+  end
+end

data/lib/ripple/document/link.rb

@@ -0,0 +1,30 @@
+require 'riak/link'
+
+module Ripple
+  module Document
+    # A Link that is tied to a particular document and tag.
+    # The key is fetched from the document lazily when needed.
+    class Link < Riak::Link
+      attr_reader :document
+      private :document
+
+      def initialize(document, tag)
+        @document = document
+        super(document.class.bucket_name, nil, tag)
+      end
+
+      def key
+        document.key
+      end
+
+      def hash
+        document.hash
+      end
+    end
+
+    def to_link(tag)
+      Link.new(self, tag)
+    end
+  end
+end
+

data/lib/ripple/document/persistence.rb

@@ -0,0 +1,115 @@
+require 'active_support/concern'
+
+module Ripple
+  module Document
+    module Persistence
+      extend ActiveSupport::Concern
+
+      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 }
+        end
+
+        # Destroys all records one at a time.
+        # Place holder while :delete to bucket is being developed.
+        def destroy_all
+          list(&:destroy)
+        end
+
+        attr_writer :quorums
+        alias_method "set_quorums", "quorums="
+
+        def quorums
+          @quorums ||= {}
+        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.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)
+        end
+      end
+    end
+  end
+end