ripple 1.0.0.beta → 1.0.0.beta2

data/Rakefile

@@ -24,6 +24,25 @@ task :release => :gem do
   system "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
 end
 
+desc "Cleans up white space in source files"
+task :clean_whitespace do
+  no_file_cleaned = true
+
+  Dir["**/*.rb"].each do |file|
+    contents = File.read(file)
+    cleaned_contents = contents.gsub(/([ \t]+)$/, '')
+    unless cleaned_contents == contents
+      no_file_cleaned = false
+      puts " - Cleaned #{file}"
+      File.open(file, 'w') { |f| f.write(cleaned_contents) }
+    end
+  end
+
+  if no_file_cleaned
+    puts "No files with trailing whitespace found"
+  end
+end
+
 desc "Run Unit Specs Only"
 RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.rspec_opts = %w[--profile --tag ~integration]

data/lib/rails/generators/ripple/configuration/templates/ripple.yml

@@ -3,6 +3,7 @@ development:
   http_port: 8098
   pb_port: 8087
   host: 127.0.0.1
+  source: /usr/local/bin  #Default for Homebrew.
 
 # The test environment has additional keys for configuring the
 # Riak::TestServer for your test/spec suite:

data/lib/rails/generators/ripple/model/model_generator.rb

@@ -11,7 +11,7 @@ module Ripple
       check_class_collision
 
       def create_model_file
-        template 'model.rb', "app/models/#{file_path}.rb"
+        template 'model.rb.erb', "app/models/#{file_path}.rb"
       end
 
       hook_for :test_framework

data/lib/rails/generators/ripple/observer/observer_generator.rb

@@ -7,7 +7,7 @@ module Ripple
       check_class_collision :suffix => "Observer"
 
       def create_observer_file
-        template 'observer.rb', File.join("app/models", class_path, "#{file_name}_observer.rb")
+        template 'observer.rb.erb', File.join("app/models", class_path, "#{file_name}_observer.rb")
       end
 
       hook_for :test_framework

data/lib/rails/generators/ripple/observer/templates/{observer.rb → observer.rb.erb}

@@ -1,4 +1,2 @@
-<% module_namespacing do -%>
 class <%= class_name %>Observer < ActiveModel::Observer
 end
-<% end -%>

data/lib/rails/generators/ripple/test/templates/cucumber.rb.erb

@@ -0,0 +1,7 @@
+require 'ripple/test_server'
+
+After do
+  Ripple::TestServer.clear
+end
+
+Ripple::TestServer.setup

data/lib/rails/generators/ripple/test/test_generator.rb

@@ -6,32 +6,36 @@ module Ripple
       desc 'Generates test helpers for Ripple. Test::Unit, RSpec and Cucumber are supported.'
       # Cucumber
       def create_cucumber_file
-        if File.directory?(Rails.root + "features/support")
-          insert_into_file 'features/support/ripple.rb', "\n\nAfter do\n  Ripple::TestServer.clear\nend", :after => "Ripple::TestServer.setup"
+        if File.directory?("features/support")
+          template 'cucumber.rb.erb', 'features/support/ripple.rb'
         end
       end
 
       # RSpec
       def create_rspec_file
-        if File.file?(Rails.root + 'spec/spec_helper.rb')
-          inject_into_file 'spec/spec_helper.rb', :before => /R[Ss]pec\.configure do \|config\|/ do
-            "require 'ripple/test_server'\n"
+        if File.file?('spec/spec_helper.rb')
+          rspec_prelude = /\s*R[Ss]pec\.configure do \|config\|/
+          indentation = File.binread('spec/spec_helper.rb').match(rspec_prelude)[0].match(/^\s*/)[0]
+          inject_into_file 'spec/spec_helper.rb', :before => rspec_prelude do
+            "#{indentation}require 'ripple/test_server'\n"
           end
-          inject_into_file 'spec/spec_helper.rb', :after => /R[Ss]pec\.configure do \|config\|/ do
-            "\n  config.before(:all){ Ripple::TestServer.setup }" +
-            "\n  config.after(:each){ Ripple::TestServer.clear }\n"
+          inject_into_file 'spec/spec_helper.rb', :after => rspec_prelude do
+            "\n#{indentation}  config.before(:suite) { Ripple::TestServer.setup }" +
+              "\n#{indentation}  config.after(:each) { Ripple::TestServer.clear }\n"
           end
         end
       end
 
       # Test::Unit
       def create_test_unit_file
-        if File.file?(Rails.root + 'test/test_helper.rb')
-          inject_into_file "test/test_helper.rb", :before => "class ActiveSupport::TestCase" do
-            "# Setup in-memory test server for Riak\nrequire 'ripple/test_server'\n\n"
+        if File.file?('test/test_helper.rb')
+          test_case_prelude = /\s*class ActiveSupport::TestCase/
+          indentation = File.binread('test/test_helper.rb').match(test_case_prelude)[0].match(/^\s*/)[0]
+          inject_into_file "test/test_helper.rb", :before => test_case_prelude do
+            "#{indentation}# Setup in-memory test server for Riak\n#{indentation}require 'ripple/test_server'\n\n"
           end
-          inject_into_class "test/test_helper.rb", ActiveSupport::TestCase do
-            "  setup { Ripple::TestServer.setup }\n  teardown { Ripple::TestServer.clear }\n\n"
+          inject_into_class "test/test_helper.rb", 'ActiveSupport::TestCase' do
+            "#{indentation}  setup { Ripple::TestServer.setup }\n#{indentation}  teardown { Ripple::TestServer.clear }\n\n"
           end
         end
       end

data/lib/rails/generators/ripple_generator.rb

@@ -1,3 +1,4 @@
+require 'rails/generators'
 require "rails/generators/named_base"
 require "rails/generators/active_model"
 

data/lib/ripple/associations.rb

@@ -101,6 +101,7 @@ module Ripple
       private
       def create_association(type, name, options={})
         association = associations[name] = Association.new(type, name, options)
+        association.validate!(self)
         association.setup_on(self)
 
         define_method(name) do
@@ -120,72 +121,71 @@ module Ripple
       end
     end
 
-    module InstanceMethods
-      # @private
-      def get_proxy(association)
-        unless proxy = instance_variable_get(association.ivar)
-          proxy = association.proxy_class.new(self, association)
-          instance_variable_set(association.ivar, proxy)
-        end
-        proxy
+
+    # @private
+    def get_proxy(association)
+      unless proxy = instance_variable_get(association.ivar)
+        proxy = association.proxy_class.new(self, association)
+        instance_variable_set(association.ivar, proxy)
       end
+      proxy
+    end
 
-      # @private
-      def reset_associations
-        self.class.associations.each do |name, assoc_object|
-          send(name).reset
-        end
+    # @private
+    def reset_associations
+      self.class.associations.each do |name, assoc_object|
+        send(name).reset
       end
+    end
 
-      # Adds embedded documents to the attributes
-      # @private
-      def attributes_for_persistence
-        self.class.embedded_associations.inject(super) do |attrs, association|
-          documents = instance_variable_get(association.ivar)
-          # We must explicitly check #nil? (rather than just saying `if documents`)
-          # because documents can be an association proxy that is proxying nil.
-          # In this case ruby treats documents as true because it is not _really_ nil,
-          # but #nil? will tell us if it is proxying nil.
-
-          unless documents.nil?
-            attrs[association.name] = documents.is_a?(Array) ? documents.map(&:attributes_for_persistence) : documents.attributes_for_persistence
-          end
-          attrs
+    # Adds embedded documents to the attributes
+    # @private
+    def attributes_for_persistence
+      self.class.embedded_associations.inject(super) do |attrs, association|
+        documents = instance_variable_get(association.ivar)
+        # We must explicitly check #nil? (rather than just saying `if documents`)
+        # because documents can be an association proxy that is proxying nil.
+        # In this case ruby treats documents as true because it is not _really_ nil,
+        # but #nil? will tell us if it is proxying nil.
+
+        unless documents.nil?
+          attrs[association.name] = documents.is_a?(Array) ? documents.map(&:attributes_for_persistence) : documents.attributes_for_persistence
         end
+        attrs
       end
+    end
 
-      def propagate_callbacks_to_embedded_associations(name, kind)
-        self.class.embedded_associations.each do |association|
-          documents = instance_variable_get(association.ivar)
-          # We must explicitly check #nil? (rather than just saying `if documents`)
-          # because documents can be an association proxy that is proxying nil.
-          # In this case ruby treats documents as true because it is not _really_ nil,
-          # but #nil? will tell us if it is proxying nil.
-          next if documents.nil?
-
-          Array(documents).each do |doc|
-            doc.send("_#{name}_callbacks").each do |callback|
-              next unless callback.kind == kind
-              doc.send(callback.filter)
-            end
+    def propagate_callbacks_to_embedded_associations(name, kind)
+      self.class.embedded_associations.each do |association|
+        documents = instance_variable_get(association.ivar)
+        # We must explicitly check #nil? (rather than just saying `if documents`)
+        # because documents can be an association proxy that is proxying nil.
+        # In this case ruby treats documents as true because it is not _really_ nil,
+        # but #nil? will tell us if it is proxying nil.
+        next if documents.nil?
+
+        Array(documents).each do |doc|
+          doc.send("_#{name}_callbacks").each do |callback|
+            next unless callback.kind == kind
+            doc.send(callback.filter)
           end
         end
       end
+    end
 
-      # Propagates callbacks (save/create/update/destroy) to embedded associated documents.
-      # This is necessary so that when a parent is saved, the embedded child's before_save
-      # hooks are run as well.
-      # @private
-      def run_callbacks(name, *args, &block)
-        # validation is already propagated to embedded documents via the
-        # AssociatedValidator.  We don't need to duplicate the propgation here.
-        return super if name == :validation
-
-        propagate_callbacks_to_embedded_associations(name, :before)
-        return_value = super
-        propagate_callbacks_to_embedded_associations(name, :after)
-        return_value
-      end
+    # Propagates callbacks (save/create/update/destroy) to embedded associated documents.
+    # This is necessary so that when a parent is saved, the embedded child's before_save
+    # hooks are run as well.
+    # @private
+    def run_callbacks(name, *args, &block)
+      # validation is already propagated to embedded documents via the
+      # AssociatedValidator.  We don't need to duplicate the propagation here.
+      return super if name == :validation
+
+      propagate_callbacks_to_embedded_associations(name, :before)
+      return_value = super
+      propagate_callbacks_to_embedded_associations(name, :after)
+      return_value
     end
   end
 
@@ -202,6 +202,16 @@ module Ripple
       @type, @name, @options = type, name, options.to_options
     end
 
+    def validate!(owner)
+      # TODO: Refactor this into an association subclass. See also GH #284
+      if @options[:using] == :stored_key
+        single_name = ActiveSupport::Inflector.singularize(@name.to_s)
+        prop_name = "#{single_name}_key"
+        prop_name << "s" if many?
+        raise ArgumentError, t('stored_key_requires_property', :name => prop_name) unless owner.properties.include?(prop_name)
+      end
+    end
+
     # @return String The class name of the associated object(s)
     def class_name
       @class_name ||= case

data/lib/ripple/associations/embedded.rb

@@ -18,7 +18,7 @@ module Ripple
       end
 
       def assign_references(docs)
-        Array(docs).each do |doc|
+        Array.wrap(docs).each do |doc|
           next unless doc.respond_to?(:_parent_document=)
           doc._parent_document = owner
         end

data/lib/ripple/associations/linked.rb

@@ -7,7 +7,7 @@ module Ripple
       def replace(value)
         @reflection.verify_type!(value, @owner)
         @owner.robject.links -= links
-        Array(value).compact.each do |doc|
+        Array.wrap(value).compact.each do |doc|
           @owner.robject.links << doc.to_link(@reflection.link_tag)
         end
         loaded

data/lib/ripple/associations/many.rb

@@ -7,7 +7,7 @@ module Ripple
 
       def to_ary
         load_target
-        Array === target ? target.to_ary : Array(target)
+        Array === target ? target.to_ary : Array.wrap(target)
       end
 
       def count

data/lib/ripple/associations/many_embedded_proxy.rb

@@ -10,9 +10,10 @@ module Ripple
 
       def <<(docs)
         load_target
-        @reflection.verify_type!(Array(docs), @owner)
+        docs = Array.wrap(docs)
+        @reflection.verify_type!(docs, @owner)
         assign_references(docs)
-        @target += Array(docs)
+        @target += docs
         self
       end
 

data/lib/ripple/associations/many_linked_proxy.rb

@@ -15,7 +15,7 @@ module Ripple
 
       def <<(value)
         if loaded?
-          new_target = @target.concat(Array(value))
+          new_target = @target.concat(Array.wrap(value))
           replace new_target
         else
           @reflection.verify_type!([value], @owner)

data/lib/ripple/associations/many_reference_proxy.rb

@@ -9,11 +9,12 @@ module Ripple
       include Many
 
       def <<(value)
-        @reflection.verify_type!([value], @owner)
+        values = Array.wrap(value)
+        @reflection.verify_type!(values, @owner)
 
-        assign_key(value)
+        values.each {|v| assign_key(v) }
         load_target
-        @target << value
+        @target.merge values
 
         self
       end
@@ -21,7 +22,7 @@ module Ripple
       def replace(value)
         @reflection.verify_type!(value, @owner)
         delete_all
-        Array(value).compact.each do |doc|
+        Array.wrap(value).compact.each do |doc|
           assign_key(doc)
         end
         loaded
@@ -43,6 +44,7 @@ module Ripple
       end
 
       def target
+        load_target
         @target.to_a
       end
 
@@ -90,4 +92,4 @@ module Ripple
       end
     end
   end
-end
+end

data/lib/ripple/associations/proxy.rb

@@ -20,7 +20,7 @@ module Ripple
 
       def initialize(owner, reflection)
         @owner, @reflection = owner, reflection
-        Array(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
+        Array.wrap(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
         reset
       end
 
@@ -86,7 +86,7 @@ module Ripple
       end
 
       def loaded_documents
-        loaded? ? Array(target) : []
+        loaded? ? Array.wrap(target) : []
       end
 
       def has_changed_documents?

data/lib/ripple/attribute_methods.rb

@@ -28,8 +28,10 @@ module Ripple
     module ClassMethods
       # @private
       def property(key, type, options={})
-        undefine_attribute_methods
-        super
+        super.tap do
+          undefine_attribute_methods
+          define_attribute_methods
+        end
       end
 
       # Generates all the attribute-related methods for properties defined
@@ -39,80 +41,86 @@ module Ripple
       end
     end
 
-    module InstanceMethods
-      # A copy of the values of all attributes in the Document. The result
-      # is not memoized, so use sparingly.  This does not include associated objects,
-      # nor embedded documents.
-      # @return [Hash] all document attributes, by key
-      def attributes
-        raw_attributes.reject { |k, v| !respond_to?(k) }
-      end
+    # A copy of the values of all attributes in the Document. The result
+    # is not memoized, so use sparingly.  This does not include associated objects,
+    # nor embedded documents.
+    # @return [Hash] all document attributes, by key
+    def attributes
+      raw_attributes.reject { |k, v| !respond_to?(k) }
+    end
 
-      def raw_attributes
-        self.class.properties.values.inject(@attributes.with_indifferent_access) do |hash, prop|
-          hash[prop.key] = attribute(prop.key)
-          hash
-        end
+    def raw_attributes
+      self.class.properties.values.inject(@attributes.with_indifferent_access) do |hash, prop|
+        hash[prop.key] = attribute(prop.key)
+        hash
       end
+    end
+
+    # Mass assign the document's attributes.
+    # @param [Hash] attrs the attributes to assign
+    # @param [Hash] options assignment options
+    def assign_attributes(attrs, options={})
+      raise ArgumentError, t('attribute_hash') unless(Hash === attrs)
 
-      # Mass assign the document's attributes.
-      # @param [Hash] attrs the attributes to assign
-      def attributes=(attrs)
-        raise ArgumentError, t('attribute_hash') unless Hash === attrs
-        sanitize_for_mass_assignment(attrs).each do |k,v|
-          if respond_to?("#{k}=")
-            __send__("#{k}=",v)
-          else
-            raise ArgumentError, t('undefined_property', :prop => k, :class => self.class.name)
+      unless options[:without_protection]
+        if method(:sanitize_for_mass_assignment).arity == 1 # ActiveModel 3.0
+          if options[:as]
+            raise ArgumentError, t('mass_assignment_roles_unsupported')
           end
+          attrs = sanitize_for_mass_assignment(attrs)
+        else
+          mass_assignment_role = (options[:as] || :default)
+          attrs = sanitize_for_mass_assignment(attrs, mass_assignment_role)
         end
       end
 
-      # @private
-      def raw_attributes=(attrs)
-        raise ArgumentError, t('attribute_hash') unless Hash === attrs
-        attrs.each do |k,v|
-          next if k.to_sym == :key
-          if respond_to?("#{k}=")
-            __send__("#{k}=",v)
-          else
-            __send__(:attribute=,k,v)
-          end
+      attrs.each do |k,v|
+        if respond_to?("#{k}=")
+          __send__("#{k}=",v)
+        else
+          raise ArgumentError, t('undefined_property', :prop => k, :class => self.class.name)
         end
       end
+    end
 
-      # @private
-      def initialize(attrs={})
-        super()
-        @attributes = attributes_from_property_defaults
-        self.attributes = attrs
-        yield self if block_given?
-      end
+    # Mass assign the document's attributes.
+    # @param [Hash] attrs the attributes to assign
+    def attributes=(attrs)
+      assign_attributes(attrs)
+    end
 
-      # @private
-      def method_missing(method, *args, &block)
-        self.class.define_attribute_methods
-        super
+    # @private
+    def raw_attributes=(attrs)
+      raise ArgumentError, t('attribute_hash') unless Hash === attrs
+      attrs.each do |k,v|
+        next if k.to_sym == :key
+        if respond_to?("#{k}=")
+          __send__("#{k}=",v)
+        else
+          __send__(:attribute=,k,v)
+        end
       end
+    end
 
-      # @private
-      def respond_to?(*args)
-        self.class.define_attribute_methods
-        super
-      end
+    # @private
+    def initialize(attrs={}, options={})
+      super()
+      @attributes = attributes_from_property_defaults
+      assign_attributes(attrs, options)
+      yield self if block_given?
+    end
 
-      protected
-      # @private
-      def attribute_method?(attr_name)
-        self.class.properties.include?(attr_name)
-      end
+    protected
+    # @private
+    def attribute_method?(attr_name)
+      self.class.properties.include?(attr_name)
+    end
 
-      def attributes_from_property_defaults
-        self.class.properties.values.inject({}) do |hash, prop|
-          hash[prop.key] = prop.default unless prop.default.nil?
-          hash
-        end.with_indifferent_access
-      end
+    def attributes_from_property_defaults
+      self.class.properties.values.inject({}) do |hash, prop|
+        hash[prop.key] = prop.default unless prop.default.nil?
+        hash
+      end.with_indifferent_access
     end
   end
 end