better-ripple 1.0.0

data/lib/ripple/inspection.rb

@@ -0,0 +1,32 @@
+require 'ripple'
+
+module Ripple
+  # Makes IRB and other inspect output a bit friendlier
+  module Inspection
+
+    # A human-readable version of the {Ripple::Document} or {Ripple::EmbeddedDocument}
+    # plus attributes
+    def inspect
+      attribute_list = attributes_for_persistence.except("_type").map {|k,v| "#{k}=#{v.inspect}" }.join(' ')
+      inspection_string(attribute_list)
+    end
+
+    # A string representation of the {Ripple::Document} or {Ripple::EmbeddedDocument}
+    def to_s
+      inspection_string
+    end
+
+    private
+
+    def inspection_string(extra = nil)
+      body = self.class.name + persistance_identifier
+      body += " #{extra}" if extra
+      "<#{body}>"
+    end
+
+    def persistance_identifier
+      self.class.embeddable? ? "" : ":#{key || '[new]'}"
+    end
+
+  end
+end

data/lib/ripple/locale/en.yml

@@ -0,0 +1,26 @@
+en:
+  ripple:
+    around_callbacks_not_supported: "around_%{type} callbacks are not supported on embedded documents.  See https://github.com/seancribbs/ripple/issues/188 for more detail."
+    associated_document_error_summary: "for %{doc_type} %{doc_id}: %{errors}"
+    attribute_hash: "value of attributes must be a Hash"
+    cluster_not_created: "The cluster for the current environment is not created yet. Run `rake riak:create` first."
+    conflict_handler_not_implemented: "No on_conflict handler has been implemented for %{document}"
+    document_invalid: "Validation failed: %{errors}"
+    document_not_found: 
+      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

@@ -0,0 +1,275 @@
+require 'active_support/concern'
+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:
+    extend ActiveSupport::Concern
+
+    UNASSIGNABLE_KEYS = %w{ _destroy }
+    TRUE_VALUES = [ true, "true", 1, "1", "yes", "ok", "y" ]
+
+    included do
+      if respond_to?(:class_attribute) # ActiveSupport 3.1
+        class_attribute :nested_attributes_options, :instance_writer => false
+      else
+        class_inheritable_accessor :nested_attributes_options, :instance_writer => false
+      end
+      self.nested_attributes_options = {}
+    end
+
+    # = Nested Attributes
+    #
+    # This is similar to the `accepts_nested_attributes` functionality
+    # as found in AR.  This allows the use update attributes and create
+    # new child records through the parent.  It also allows the use of
+    # the `fields_for` form view helper, using a presenter pattern.
+    #
+    # To enable in the model, call the class method, using the same
+    # relationship as defined in the `one` or `many`.
+    #
+    #   class Shipment
+    #     include Ripple::Document
+    #     one :box
+    #     many :addresses
+    #     accepts_nested_attributes_for :box, :addresses
+    #   end
+    #
+    # == One
+    #
+    # Given this model:
+    #
+    #   class Shipment
+    #     include Ripple::Document
+    #     one :box
+    #     accepts_nested_attributes_for :box
+    #   end
+    #
+    # This allows creating a box child during creation:
+    #
+    #   shipment = Shipment.create(:box_attributes => { :shape => 'square' })
+    #   shipment.box.shape # => 'square'
+    #
+    # This also allows updating box attributes:
+    #
+    #   shipment.update_attributes(:box_attributes => { :key => 'xxx', :shape => 'triangle' })
+    #   shipment.box.shape # => 'triangle'
+    #
+    # == Many
+    #
+    # Given this model
+    #
+    #   class Manifest
+    #     include Ripple::Document
+    #     many :shipments
+    #     accepts_nested_attributes_for :shipments
+    #   end
+    #
+    # This allows creating several shipments during manifest creation:
+    #
+    #   manifest = Manifest.create(:shipments_attributes => [ { :reference => "foo1" }, { :reference => "foo2" } ])
+    #   manifest.shipments.size # => 2
+    #   manifest.shipments.first.reference # => foo1
+    #   manifest.shipments.second.reference # => foo2
+    #
+    # And updating shipment attributes:
+    #
+    #   manifest.update_attributes(:shipment_attributes => [ { :key => 'xxx', :reference => 'updated foo1' },
+    #                                                        { :key => 'yyy', :reference => 'updated foo2' } ])
+    #   manifest.shipments.first.reference # => updated foo1
+    #   manifest.shipments.second.reference # => updated foo2
+    #
+    # NOTE: On many embedded, then entire collection of embedded documents is replaced, as there
+    # is no key to specifically update.
+    #
+    # Given
+    #
+    #   class Manifest
+    #     include Ripple::Documnet
+    #     many :signatures
+    #     accepts_nested_attributes_for :signatures
+    #   end
+    #
+    #   class Signature
+    #     include Ripple::EmbeddedDocument
+    #     property :esignature, String
+    #   end
+    #
+    # The assigning of attributes replaces existing:
+    #
+    #   manifest = Manifest.create(:signature_attributes => [ { :esig => 'a00001' }, { :esig => 'b00001' } ]
+    #   manifest.signatures # => [<Signature esig="a00001">, <Signature esig="b00001">]
+    #
+    #   manifest.signature_attributes = [ { :esig => 'c00001' } ]
+    #   manifest.signatures # => [<Signature esig="c00001">]
+    #
+    module ClassMethods
+
+      def accepts_nested_attributes_for(*attr_names)
+        options = { :allow_destroy => false }
+        options.update(attr_names.extract_options!)
+
+        attr_names.each do |association_name|
+          if association = self.associations[association_name]
+            nested_attributes_options[association_name.to_sym] = options
+
+            define_method "#{association_name}_attributes=" do |attributes|
+              send("assign_nested_attributes_for_#{association.type}_association",
+                association_name, attributes
+              )
+            end
+
+            before_save :"autosave_nested_attributes_for_#{association_name}"
+            before_save :destroy_marked_for_destruction
+
+            define_method "autosave_nested_attributes_for_#{association_name}" do
+              if self.autosave[association_name]
+                send("save_nested_attributes_for_#{association.type}_association",
+                  association_name
+                )
+              end
+            end
+            private :"autosave_nested_attributes_for_#{association_name}"
+
+          else
+            raise ArgumentError, "Association #{association_name} not found!"
+          end
+        end
+      end
+    end
+
+
+    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
+    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
+    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
+    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
+    end
+
+    def assign_to_or_mark_for_destruction(record, attributes, association_name, allow_destroy)
+      if has_destroy_flag?(attributes) && allow_destroy
+        (self.marked_for_destruction[association_name] ||= []) << record
+      else
+        record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
+      end
+    end
+
+    def has_destroy_flag?(hash)
+      TRUE_VALUES.include?(hash.stringify_keys['_destroy'])
+    end
+
+    def reject_new_record?(association_name, attributes)
+      has_destroy_flag?(attributes) || call_reject_if(association_name, attributes)
+    end
+
+    def call_reject_if(association_name, attributes)
+      attributes = attributes.stringify_keys
+      case callback = nested_attributes_options[association_name][:reject_if]
+      when Symbol
+        method(callback).arity == 0 ? send(callback) : send(callback, attributes)
+      when Proc
+        callback.call(attributes)
+      end
+    end
+
+  end
+
+end

data/lib/ripple/observable.rb

@@ -0,0 +1,28 @@
+
+require 'active_support/concern'
+require 'active_model/observing'
+
+module Ripple
+  module Observable
+    extend ActiveSupport::Concern
+    include ActiveModel::Observing
+
+    included do
+      set_callback(:create, :before)     { notify_observers :before_create }
+      set_callback(:create, :after)      { notify_observers :after_create }
+
+      set_callback(:update, :before)     { notify_observers :before_update }
+      set_callback(:update, :after)      { notify_observers :after_update }
+
+      set_callback(:save, :before)       { notify_observers :before_save }
+      set_callback(:save, :after)        { notify_observers :after_save }
+
+      set_callback(:destroy, :before)    { notify_observers :before_destroy }
+      set_callback(:destroy, :after)     { notify_observers :after_destroy }
+
+      set_callback(:validation, :before) { notify_observers :before_validation }
+      set_callback(:validation, :after)  { notify_observers :after_validation }
+    end
+
+  end
+end

data/lib/ripple/properties.rb

@@ -0,0 +1,74 @@
+require 'ripple/core_ext/casting'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/indifferent_access'
+
+module Ripple
+  # Adds the ability to declare properties on your Ripple::Document class.
+  # Properties will automatically generate accessor (get/set/query) methods and
+  # handle type-casting between your Ruby type and JSON-compatible types.
+  module Properties
+    # @private
+    def inherited(subclass)
+      super
+      subclass.properties.merge!(properties)
+    end
+
+    # @return [Hash] the properties defined on the document
+    def properties
+      @properties ||= {}.with_indifferent_access
+    end
+
+    def property(key, type, options={})
+      prop = Property.new(key, type, options)
+      properties[prop.key] = prop
+    end
+  end
+
+  # Encapsulates a single property on your Ripple::Document class.
+  class Property
+    # @return [Symbol] the key of this property in the Document
+    attr_reader :key
+    # @return [Class] the Ruby type of property.
+    attr_reader :type
+    # @return [Hash] configuration options
+    attr_reader :options
+
+    # Create a new document property.
+    # @param [String, Symbol] key the key of the property
+    # @param [Class] type the Ruby type of the property. Use {Boolean} for true or false types.
+    # @param [Hash] options configuration options
+    # @option options [Object, Proc] :default (nil) a default value
+    #   for the property, or a lambda to evaluate when providing the default.
+    def initialize(key, type, options={})
+      @options = options.to_options
+      @key = key.to_sym
+      @type = type
+    end
+
+    # @return [Object] The default value for this property if defined, or nil.
+    def default
+      default = options[:default]
+      default = default.dup if default.duplicable?
+
+      return nil if default.nil?
+      type_cast(default.respond_to?(:call) ? default.call : default)
+    end
+
+    # @return [Hash] options appropriate for the validates class method
+    def validation_options
+      @options.dup.except(:default)
+    end
+
+    # Attempt to coerce the passed value into this property's type
+    # @param [Object] value the value to coerce
+    # @return [Object] the value coerced into this property's type
+    # @raise [PropertyTypeMismatch] if the value cannot be coerced into the property's type
+    def type_cast(value)
+      if @type.respond_to?(:ripple_cast)
+        @type.ripple_cast(value)
+      else
+        value
+      end
+    end
+  end
+end