ripple 1.0.0.beta → 1.0.0.beta2

data/lib/ripple/embedded_document.rb

@@ -28,6 +28,7 @@ module Ripple
       include Persistence
       extend Ripple::Properties
       include Ripple::AttributeMethods
+      include Ripple::Indexes
       include Ripple::Timestamps
       include Ripple::Validations
       include Ripple::Associations
@@ -46,19 +47,17 @@ module Ripple
       end
     end
 
-    module InstanceMethods
-      def ==(other)
-        self.class == other.class &&
+    def ==(other)
+      self.class == other.class &&
         _parent_document == other._parent_document &&
         serializable_hash == other.serializable_hash
-      end
-      alias eql? ==
+    end
+    alias eql? ==
 
-      def hash
-        parent = [_parent_document.class]
-        parent << [_parent_document.key] if _parent_document.respond_to?(:key)
-        [ self.class, parent, serializable_hash ].hash
-      end
+    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/persistence.rb

@@ -24,53 +24,51 @@ module Ripple
         end
       end
 
-      module InstanceMethods
-        # 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
+      # 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
-
-        # 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
+      
+      # 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
-
-        # @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
+      
+      # @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

data/lib/ripple/i18n.rb

@@ -1,2 +1,5 @@
 require 'active_support/i18n'
-I18n.load_path << File.expand_path("../locale/en.yml", __FILE__)
+
+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

data/lib/ripple/locale/en.yml

@@ -10,13 +10,17 @@ en:
       no_key: "Couldn't find document without a key"
       one_key: "Couldn't find document with key: %{key}"
       many_keys: "Couldn't find documents with keys: %{keys}"
+    index_type_unknown: "Cannot determine index type for property '%{property}' of type '%{type}'."
+    index_undefined: "No index has been defined for property '%{property}' of type '%{type}'."
     invalid_association_value: "Invalid value %{value} for association %{name} of type %{klass} on %{owner}"
     many_association_validation_error: "are invalid (%{association_errors})"
     many_key_association: "You cannot use a many association using :key"
+    mass_assignment_roles_unsupported: "Roles for mass assignment are not supported for Rails 3.0"
     missing_configuration: "You are missing your ripple configuration file that should be at %{file}"
     no_root_document: "You cannot call %{method} on %{doc} without a root document"
     one_association_validation_error: "is invalid (%{association_errors})"
     property_type_mismatch: "Cannot cast %{value} into a %{class}"
+    stored_key_requires_property: "Missing property: %{name}. Stored-key associations require a property on the owner document."
     undefined_property: "Undefined property :%{prop} for class '%{class}'"
     unexpected_conflicts: "Conflict cannot be resolved for %{conflicts} (for %{document})"
 

data/lib/ripple/locale/fr.yml

@@ -0,0 +1,24 @@
+fr:
+  ripple:
+    around_callbacks_not_supported: "Les callbacks around_%{type} ne sont pas utilisables sur les documents embarqués. Voir https://github.com/seancribbs/ripple/issues/188 pour plus d'information."
+    associated_document_error_summary: "Pour %{doc_type} %{doc_id}: %{errors}"
+    attribute_hash: "La valeur des attributs doit être un Hash"
+    cluster_not_created: "Le cluster pour l'environnement actuel n'a pas été créé. Executez d'abord `rake riak:create`"
+    conflict_handler_not_implemented: "Aucun handler on_conflict n'a été implémenté pour %{document}"
+    document_invalid: "La validation a échoué : %{errors}"
+    document_not_found: 
+      no_key: "Document introuvable sans clé."
+      one_key: "Document introuvable avec la clé %{key}"
+      many_keys: "Documents introuvables avec les clés : %{keys}"
+    index_type_unknown: "Impossible de déterminer le type d'index pour la propriété '%{property}' of type '%{type}'."
+    invalid_association_value: "Valeur invalide %{value} pour l'association %{name} de type %{klass} sur %{owner}"
+    many_association_validation_error: "sont invalides (%{association_errors})"
+    many_key_association: "Vous ne pouvez pas utiliser une association `many` avec :key"
+    mass_assignment_roles_unsupported: "Les rôles pour les assignations de masse ne sont pas supportés avec Rails 3.0"
+    missing_configuration: "Votre fichier de configuration est introuvable. Il devrait être ici : %{file}"
+    no_root_document: "Vous ne pouvez appeler %{method} sur %{doc} sans document racine."
+    one_association_validation_error: "est invalide (%{association_errors})"
+    property_type_mismatch: "Ne peut caster %{value} en %{class}"
+    undefined_property: "Propriété indéfinie :%{prop} pour la  classe '%{class}'"
+    unexpected_conflicts: "Le conflit ne peut être résolu : %{conflicts} (pour %{document})"
+

data/lib/ripple/nested_attributes.rb

@@ -1,5 +1,9 @@
 require 'active_support/concern'
-require 'active_support/core_ext/class/inheritable_attributes'
+if ActiveSupport::VERSION::STRING < '3.2'
+  require 'active_support/core_ext/class/inheritable_attributes'
+else
+  require 'active_support/core_ext/class/attribute'
+end
 
 module Ripple
   module NestedAttributes #:nodoc:
@@ -137,107 +141,105 @@ module Ripple
       end
     end
 
-    module InstanceMethods
-
-      protected
-
-      def autosave
-        @autosave_nested_attributes_for ||= {}
-      end
-
-      def marked_for_destruction
-        @marked_for_destruction ||= {}
-      end
-
-      private
 
-      def save_nested_attributes_for_one_association(association_name)
-        send(association_name).save
+    protected
+    
+    def autosave
+      @autosave_nested_attributes_for ||= {}
+    end
+    
+    def marked_for_destruction
+      @marked_for_destruction ||= {}
+    end
+    
+    private
+    
+    def save_nested_attributes_for_one_association(association_name)
+      send(association_name).save
+    end
+    
+    def save_nested_attributes_for_many_association(association_name)
+      send(association_name).map(&:save)
+    end
+    
+    def destroy_marked_for_destruction
+      self.marked_for_destruction.each_pair do |association_name, resources|
+        resources.map(&:destroy)
+        send(association_name).reload
       end
-
-      def save_nested_attributes_for_many_association(association_name)
-        send(association_name).map(&:save)
+    end
+    
+    def destroy_nested_many_association(association_name)
+      send(association_name).map(&:destroy)
+    end
+    
+    def assign_nested_attributes_for_one_association(association_name, attributes)
+      association = self.class.associations[association_name]
+      if association.embedded?
+        assign_nested_attributes_for_one_embedded_association(association_name, attributes)
+      else
+        self.autosave[association_name] = true
+        assign_nested_attributes_for_one_linked_association(association_name, attributes)
       end
-
-      def destroy_marked_for_destruction
-        self.marked_for_destruction.each_pair do |association_name, resources|
-          resources.map(&:destroy)
-          send(association_name).reload
+    end
+    
+    def assign_nested_attributes_for_one_embedded_association(association_name, attributes)
+      send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
+    end
+    
+    def assign_nested_attributes_for_one_linked_association(association_name, attributes)
+      attributes = attributes.stringify_keys
+      options = nested_attributes_options[association_name]
+    
+      if attributes[key_attr.to_s].blank? && !reject_new_record?(association_name, attributes)
+        send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
+      else
+        if ((existing_record = send(association_name)).key.to_s == attributes[key_attr.to_s].to_s)
+          assign_to_or_mark_for_destruction(existing_record, attributes, association_name, options[:allow_destroy])
+        else
+          raise ArgumentError, "Attempting to update a child that isn't already associated to the parent."
         end
       end
-
-      def destroy_nested_many_association(association_name)
-        send(association_name).map(&:destroy)
+    end
+    
+    def assign_nested_attributes_for_many_association(association_name, attributes_collection)
+      unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+        raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
       end
-
-      def assign_nested_attributes_for_one_association(association_name, attributes)
-        association = self.class.associations[association_name]
-        if association.embedded?
-          assign_nested_attributes_for_one_embedded_association(association_name, attributes)
-        else
-          self.autosave[association_name] = true
-          assign_nested_attributes_for_one_linked_association(association_name, attributes)
-        end
+    
+      if attributes_collection.is_a? Hash
+        attributes_collection = attributes_collection.sort_by { |index, _| index.to_i }.map { |_, attributes| attributes }
       end
-
-      def assign_nested_attributes_for_one_embedded_association(association_name, attributes)
-        send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
+    
+      association = self.class.associations[association_name]
+      if association.embedded?
+        assign_nested_attributes_for_many_embedded_association(association_name, attributes_collection)
+      else
+        self.autosave[association_name] = true
+        assign_nested_attributes_for_many_linked_association(association_name, attributes_collection)
       end
-
-      def assign_nested_attributes_for_one_linked_association(association_name, attributes)
+    end
+    
+    def assign_nested_attributes_for_many_embedded_association(association_name, attributes_collection)
+      options = nested_attributes_options[association_name]
+      send(:"#{association_name}=", []) # Clobber existing
+      attributes_collection.each do |attributes|
         attributes = attributes.stringify_keys
-        options = nested_attributes_options[association_name]
-
-        if attributes[key_attr.to_s].blank? && !reject_new_record?(association_name, attributes)
+        if !reject_new_record?(association_name, attributes)
           send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
-        else
-          if ((existing_record = send(association_name)).key.to_s == attributes[key_attr.to_s].to_s)
-            assign_to_or_mark_for_destruction(existing_record, attributes, association_name, options[:allow_destroy])
-          else
-            raise ArgumentError, "Attempting to update a child that isn't already associated to the parent."
-          end
-        end
-      end
-
-      def assign_nested_attributes_for_many_association(association_name, attributes_collection)
-        unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
-          raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
-        end
-
-        if attributes_collection.is_a? Hash
-          attributes_collection = attributes_collection.sort_by { |index, _| index.to_i }.map { |_, attributes| attributes }
-        end
-
-        association = self.class.associations[association_name]
-        if association.embedded?
-          assign_nested_attributes_for_many_embedded_association(association_name, attributes_collection)
-        else
-          self.autosave[association_name] = true
-          assign_nested_attributes_for_many_linked_association(association_name, attributes_collection)
-        end
-      end
-
-      def assign_nested_attributes_for_many_embedded_association(association_name, attributes_collection)
-        options = nested_attributes_options[association_name]
-        send(:"#{association_name}=", []) # Clobber existing
-        attributes_collection.each do |attributes|
-          attributes = attributes.stringify_keys
-          if !reject_new_record?(association_name, attributes)
-            send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
-          end
         end
       end
-
-      def assign_nested_attributes_for_many_linked_association(association_name, attributes_collection)
-        options = nested_attributes_options[association_name]
-        attributes_collection.each do |attributes|
-          attributes = attributes.stringify_keys
-
-          if attributes[key_attr.to_s].blank? && !reject_new_record?(association_name, attributes)
-            send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
-          elsif existing_record = send(association_name).detect { |record| record.key.to_s == attributes[key_attr.to_s].to_s }
-            assign_to_or_mark_for_destruction(existing_record, attributes, association_name, options[:allow_destroy])
-          end
+    end
+    
+    def assign_nested_attributes_for_many_linked_association(association_name, attributes_collection)
+      options = nested_attributes_options[association_name]
+      attributes_collection.each do |attributes|
+        attributes = attributes.stringify_keys
+    
+        if attributes[key_attr.to_s].blank? && !reject_new_record?(association_name, attributes)
+          send(association_name).build(attributes.except(*UNASSIGNABLE_KEYS))
+        elsif existing_record = send(association_name).detect { |record| record.key.to_s == attributes[key_attr.to_s].to_s }
+          assign_to_or_mark_for_destruction(existing_record, attributes, association_name, options[:allow_destroy])
         end
       end
     end