wyngle-ripple 0.1.0

data/lib/ripple/document/key.rb

@@ -0,0 +1,35 @@
+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)
+          prop = prop.to_sym
+
+          define_method(:key) { send(prop).to_s }
+          define_method(:key=) { |v| send(:"#{prop}=", v) }
+          define_method(:key_attr) { prop }
+        end
+      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
+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,130 @@
+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(*args, &block)
+          new(*args, &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
+
+      # @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

data/lib/ripple/embedded_document.rb

@@ -0,0 +1,63 @@
+require 'active_support/concern'
+require 'active_support/core_ext/hash/except'
+require 'ripple/translation'
+require 'ripple/embedded_document/around_callbacks'
+require 'ripple/embedded_document/finders'
+require 'ripple/embedded_document/persistence'
+require 'ripple/properties'
+require 'ripple/attribute_methods'
+require 'ripple/timestamps'
+require 'ripple/validations'
+require 'ripple/associations'
+require 'ripple/callbacks'
+require 'ripple/conversion'
+require 'ripple/inspection'
+require 'ripple/nested_attributes'
+require 'ripple/serialization'
+
+module Ripple
+  # Represents a document model that is composed into or stored in a parent
+  # Document.  Embedded documents may also embed other documents, have
+  # callbacks and validations, but are solely dependent on the parent Document.
+  module EmbeddedDocument
+    extend ActiveSupport::Concern
+    include Translation
+
+    included do
+      extend ActiveModel::Naming
+      include Persistence
+      extend Ripple::Properties
+      include Ripple::AttributeMethods
+      include Ripple::Indexes
+      include Ripple::Timestamps
+      include Ripple::Validations
+      include Ripple::Associations
+      include Ripple::Callbacks
+      include Ripple::EmbeddedDocument::AroundCallbacks
+      include Ripple::Conversion
+      include Finders
+      include Ripple::Inspection
+      include Ripple::NestedAttributes
+      include Ripple::Serialization
+    end
+
+    module ClassMethods
+      def embeddable?
+        true
+      end
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        _parent_document == other._parent_document &&
+        serializable_hash == other.serializable_hash
+    end
+    alias eql? ==
+
+    def hash
+      hash  = self.class.hash ^ _parent_document.class.hash ^ serializable_hash.to_s.hash
+      hash ^= _parent_document.key.hash if _parent_document.respond_to?(:key)
+      hash
+    end
+  end
+end

data/lib/ripple/embedded_document/around_callbacks.rb

@@ -0,0 +1,18 @@
+require 'ripple/callbacks'
+
+module Ripple
+  module EmbeddedDocument
+    module AroundCallbacks
+      extend ActiveSupport::Concern
+      extend Translation
+
+      included do
+        Ripple::Callbacks::CALLBACK_TYPES.each do |type|
+          define_singleton_method "around_#{type}" do |*args|
+            raise NotImplementedError.new(t("around_callbacks_not_supported", :type => type))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ripple/embedded_document/finders.rb

@@ -0,0 +1,26 @@
+require 'active_support/concern'
+require 'active_support/inflector'
+
+module Ripple
+  module EmbeddedDocument
+    # @private
+    module Finders
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def instantiate(attrs)
+          begin
+            klass = attrs['_type'].present? ? attrs.delete('_type').constantize : self
+          rescue NameError
+            klass = self
+          end
+          klass.new.tap do |object|
+            object.raw_attributes = attrs
+            object.changed_attributes.clear
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ripple/embedded_document/persistence.rb

@@ -0,0 +1,75 @@
+require 'active_support/concern'
+require 'ripple/translation'
+
+module Ripple
+  # Exception raised when save is called on an EmbeddedDocument that
+  # is not attached to a root Document.
+  class NoRootDocument < StandardError
+    include Translation
+    def initialize(doc, method)
+      super(t("no_root_document", :doc => doc.inspect, :method => method))
+    end
+  end
+
+  module EmbeddedDocument
+    # Adds methods to {Ripple::EmbeddedDocument} that delegate storage
+    # operations to the parent document.
+    module Persistence
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Creates a method that points to the parent document.
+        def embedded_in(parent)
+          define_method(parent) { @_parent_document }
+        end
+      end
+
+      # The parent document to this embedded document. This may be a
+      # {Ripple::Document} or another {Ripple::EmbeddedDocument}.
+      attr_accessor :_parent_document
+      
+      # Whether the root document is unsaved.
+      def new?
+        if _root_document
+          _root_document.new?
+        else
+          true
+        end
+      end
+      
+      # Sets this embedded documents attributes and saves the root document.
+      def update_attributes(attrs)
+        self.attributes = attrs
+        save
+      end
+      
+      # Updates this embedded document's attribute and saves the
+      # root document, skipping validations.
+      def update_attribute(attribute, value)
+        send("#{attribute}=", value)
+        save(:validate => false)
+      end
+      
+      # Saves this embedded document by delegating to the root document.
+      def save(*args)
+        if _root_document
+          run_save_callbacks do
+            _root_document.save(*args)
+          end
+        else
+          raise NoRootDocument.new(self, :save)
+        end
+      end
+      
+      # @private
+      def attributes_for_persistence
+        raw_attributes.merge("_type" => self.class.name)
+      end
+      
+      # The root {Ripple::Document} to which this embedded document belongs.
+      def _root_document
+        @_parent_document.try(:_root_document)
+      end
+    end
+  end
+end

data/lib/ripple/i18n.rb

@@ -0,0 +1,5 @@
+require 'active_support/i18n'
+
+Dir.glob(File.expand_path("../locale/*.yml", __FILE__)).each do |locale_file|
+  I18n.load_path << locale_file
+end

data/lib/ripple/indexes.rb

@@ -0,0 +1,151 @@
+require 'ripple/translation'
+require 'active_support/concern'
+
+module Ripple
+  # Adds secondary-indexes to {Document} properties.
+  module Indexes
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def inherited(subclass)
+        super
+        subclass.indexes = indexes.dup
+      end
+
+      # Indexes defined on the document.
+      def indexes
+        @indexes ||= {}.with_indifferent_access
+      end
+
+      def indexes=(idx)
+        @indexes = idx
+      end
+
+      def property(key, type, options={})
+        if indexed = options.delete(:index)
+          indexes[key] = Index.new(key, type, indexed)
+        end
+        super
+      end
+
+      def index(key, type, &block)
+        if block_given?
+          indexes[key] = Index.new(key, type, &block)
+        else
+          indexes[key] = Index.new(key, type)
+        end
+      end
+    end
+
+    # Returns indexes in a form suitable for persisting to Riak.
+    # @return [Hash] indexes for this document
+    def indexes_for_persistence(prefix = '')
+      Hash.new {|h,k| h[k] = Set.new }.tap do |indexes|
+        # Add embedded associations' indexes
+        self.class.embedded_associations.each do |association|
+          documents = instance_variable_get(association.ivar)
+          unless documents.nil?
+            Array(documents).each do |doc|
+              embedded_indexes = doc.indexes_for_persistence("#{prefix}#{association.name}_")
+              indexes.merge!(embedded_indexes) do |_,original,new|
+                original.merge new
+              end
+            end
+          end
+        end
+
+        # Add this document's indexes
+        self.class.indexes.each do |key, index|
+          if index.block
+            index_value = index.to_index_value instance_exec(&index.block)
+          else
+            index_value = index.to_index_value send(key)
+          end
+          index_value = Set[index_value] unless index_value.is_a?(Enumerable) && !index_value.is_a?(String)
+          indexes[prefix + index.index_key].merge index_value
+        end
+      end
+    end
+
+    # Modifies the persistence chain to set indexes on the internal
+    # {Riak::RObject} before saving.
+    module DocumentMethods
+      extend ActiveSupport::Concern
+      def update_robject
+        robject.indexes = indexes_for_persistence
+        super
+      end
+
+      module ClassMethods
+        # Search for a document using an indexed column
+        # @param [Symbol] name of the index
+        # @param [String, Integer, Range] query to search for
+        def find_by_index(index_name, query)
+          if ["$bucket", "$key"].include?(index_name.to_s)
+            self.find(Ripple.client.get_index(self.bucket.name, index_name.to_s, query))
+          else
+            idx = self.indexes[index_name]
+            raise ArgumentError, t('index_undefined', :property => index_name, :type => self.name) if idx.nil?
+            self.find(Ripple.client.get_index(self.bucket.name, idx.index_key, query))
+          end
+        end
+      end
+    end
+  end
+
+  # Represents a Secondary Index on a Document
+  class Index
+    include Translation
+    attr_reader :key, :type, :block
+
+    # Creates an index for a Document
+    # @param [Symbol] key the attribute key
+    # @param [Class] property_type the type of the associated property
+    # @param ['bin', 'int', String, Integer] index_type if given, the
+    #   type of index
+    # @yield a block that returns the value of the index
+    def initialize(key, property_type, index_type=true, &block)
+      @key, @type, @index, @block = key, property_type, index_type, block
+    end
+
+
+    # The key under which a value will be indexed
+    def index_key
+      "#{key}_#{index_type}"
+    end
+
+    # Converts an attribute to a value appropriate for storing in a
+    # secondary index.
+    # @param [Object] value a value of type {#type}
+    # @return [String, Integer, Set] a value appropriate for storing
+    #   in a secondary index
+    def to_index_value(value)
+      value.to_ripple_index(index_type)
+    end
+
+    # @return ["bin", "int", nil] the type of index used for this property
+    # @raise [ArgumentError] if the type cannot be automatically determined
+    def index_type
+      @index_type ||= case @index
+                      when /^bin|int$/
+                        @index
+                      when Class
+                        determine_index_type(@index)
+                      else
+                        determine_index_type(@type)
+                      end
+    end
+
+    private
+    def determine_index_type(itype)
+      if String == itype || itype < String
+        'bin'
+      elsif [Integer, Time, Date, ActiveSupport::TimeWithZone].any? {|t| t == itype || itype < t }
+        'int'
+      else
+        raise ArgumentError, t('index_type_unknown', :property => @key, :type => itype.name)
+      end
+    end
+  end
+end