hobo 1.3.3 → 1.4.0.pre2

data/lib/hobo/controller/user_base.rb

@@ -15,8 +15,6 @@ module Hobo
           skip_before_filter :login_required, :only => [:login, :signup, :do_signup, :forgot_password, :reset_password, :do_reset_password,
                                                         :accept_invitation, :do_accept_invitation]
 
-          include_taglib "rapid_user_pages", :plugin => "hobo"
-
           alias_method_chain :hobo_update, :account_flash
         end
 
@@ -112,7 +110,7 @@ module Hobo
 
     def hobo_forgot_password
       if request.post?
-        user = model.find_by_email_address(params[:email_address].to_s)
+        user = model.find_by_email_address(params[:email_address])
         if user && (!block_given? || yield(user))
           user.lifecycle.request_password_reset!(:nobody)
         end

data/lib/hobo/engine.rb

@@ -24,6 +24,7 @@ module Hobo
     end
 
     ActiveSupport.on_load(:active_record) do
+      require 'hobo/extensions/active_record/associations/association'
       require 'hobo/extensions/active_record/associations/collection'
       require 'hobo/extensions/active_record/associations/proxy'
       require 'hobo/extensions/active_record/associations/reflection'
@@ -41,7 +42,6 @@ module Hobo
     ActiveSupport.on_load(:action_view) do
       require 'hobo/extensions/action_view/tag_helper'
       require 'hobo/extensions/action_view/translation_helper'
-      include Hobo::Helper::Translations::Normalizer
     end
 
     ActiveSupport.on_load(:before_initialize) do

data/lib/hobo/extensions/active_record/associations/association.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  module Associations
+    class Association #:nodoc:
+      def scoped
+        # Rails implementation just returns target_scope.merge(association_scope)
+        sc = target_scope.merge(association_scope)
+
+        # Hobo adds in scopes declared on the association, e.g. has_many ..... :scope => :foo
+        if (declared_scope = options[:scope])
+          if declared_scope.is_a? Array
+            declared_scope.inject(sc) { |result, element| result.merge(klass.send(element)) }
+          elsif declared_scope.is_a? Hash
+            method = declared_scope.keys.first
+            arg = declared_scope.values.first
+            sc.merge(klass.send(method, arg))
+          else
+            # It's just a symbol -- the name of a scope
+            sc.merge(klass.send(declared_scope))
+          end
+        else
+          sc
+        end
+      end
+
+      private
+
+      def raise_on_type_mismatch(record)
+        # Don't complain if the interface type of a polymorphic association doesn't exist
+        klass = @reflection.klass rescue nil
+        unless klass.nil? || record.is_a?(klass)
+          raise ActiveRecord::AssociationTypeMismatch, "#{@reflection.klass} expected, got #{record.class}"
+        end
+      end
+    end
+  end
+end

data/lib/hobo/extensions/active_record/associations/collection.rb

@@ -1,18 +1,18 @@
 module ActiveRecord
   module Associations
-    class AssociationCollection
+    class CollectionProxy
 
       include Hobo::Model::Scopes::ApplyScopes
 
 
       def hobo_association_collection?
-        Hobo::Model.in?(@owner.class.included_modules)
+        Hobo::Model.in?(proxy_association.owner.class.included_modules)
       end
 
 
       def new_candidate(attributes = {})
         record = new
-        @target.delete record
+        proxy_association.target.delete record
         set_reverse_association(record) if hobo_association_collection?
         record
       end
@@ -20,45 +20,36 @@ module ActiveRecord
 
       def user_new_candidate(user, attributes = {})
         record = user_new(user, attributes)
-        @target.delete record
+        proxy_association.target.delete record
         set_reverse_association(record) if hobo_association_collection?
         record
       end
 
-      # DO NOT call super here - AssociationProxy's version loads the collection, and that's bad.
-      # TODO: this really belongs in Rails; migrate it there ASAP
-      def respond_to?(*args)
-        return super if has_one_collection?
-        proxy_respond_to?(*args) || [].respond_to?(*args)
-      end
-
       def is_a?(klass)
         if has_one_collection?
           load_target
-          @target.is_a?(klass)
+          proxy_association.target.is_a?(klass)
         else
           [].is_a?(klass)
         end
       end
 
       def member_class
-        proxy_reflection.klass
+        proxy_association.reflection.klass
       end
 
       private
 
         def set_reverse_association(object)
-          if @owner.new_record? &&
-              (refl = @owner.class.reverse_reflection(@reflection.name)) &&
+          if proxy_association.owner.new_record? &&
+              (refl = proxy_association.owner.class.reverse_reflection(proxy_association.reflection.name)) &&
               refl.macro == :belongs_to
-            bta = ActiveRecord::Associations::BelongsToAssociation.new(object, refl)
-            bta.replace(@owner)
-            object.instance_variable_set("@#{refl.name}", bta)
+            object.send("#{refl.name}=", proxy_association.owner)
           end
         end
 
         def has_one_collection?
-          proxy_reflection.macro == :has_one
+          proxy_association.reflection.macro == :has_one
         end
 
     end

data/lib/hobo/extensions/active_record/associations/proxy.rb

@@ -1,25 +1,13 @@
 module ActiveRecord
   module Associations
-    class AssociationProxy #:nodoc:
-
+    class CollectionProxy #:nodoc:
       def origin
-        proxy_owner
+        proxy_association.owner
       end
 
       def origin_attribute
-        proxy_reflection.name
+        proxy_association.reflection.name
       end
-
-      private
-
-      def raise_on_type_mismatch(record)
-        # Don't complain if the interface type of a polymorphic association doesn't exist
-        klass = @reflection.klass rescue nil
-        unless klass.nil? || record.is_a?(klass)
-          raise ActiveRecord::AssociationTypeMismatch, "#{@reflection.klass} expected, got #{record.class}"
-        end
-      end
-
     end
   end
 end

data/lib/hobo/extensions/active_record/associations/scope.rb

@@ -2,7 +2,7 @@
 
 module ActiveRecord
   module Associations
-    module ThroughAssociationScope
+    module ThroughAssociationScope # No such module in ActiveRecord any more - there is only ThroughAssociation
 
       def construct_scope_with_scope
         s = construct_scope_without_scope
@@ -12,7 +12,7 @@ module ActiveRecord
       alias_method_chain :construct_scope, :scope
 
       end
-    end
+    end if false # DISABLED Getting Rails 3.1 working
 
   module SpawnMethods
 

data/lib/hobo/extensions/active_record/permissions.rb

@@ -6,15 +6,19 @@ ActiveRecord::Associations::HasManyAssociation.class_eval do
   end
 
 
-  def delete_records(records)
-    case @reflection.options[:dependent]
-      when :destroy
-        records.each { |r| r.is_a?(Hobo::Model) ? r.user_destroy(acting_user) : r.destroy }
-      when :delete_all
-        # No destroy permission check if the :delete_all option has been chosen
-        @reflection.klass.delete(records.map(&:id))
+  def delete_records(records, method)
+    if method == :destroy
+      records.each { |r| r.is_a?(Hobo::Model) ? r.user_destroy(acting_user) : r.destroy }
+      update_counter(-records.length) unless inverse_updates_counter_cache?
+    else
+      keys  = records.map { |r| r[reflection.association_primary_key] }
+      scope = scoped.where(reflection.association_primary_key => keys)
+
+      if method == :delete_all
+        update_counter(-scope.delete_all)
       else
-        nullify_keys(records)
+        update_counter(-scope.update_all(reflection.foreign_key => nil))
+      end
     end
   end
 
@@ -23,34 +27,27 @@ ActiveRecord::Associations::HasManyAssociation.class_eval do
   # and record in question are Hobo models
   def nullify_keys(records)
     if (user = acting_user)
-      records.each { |r| r.user_update_attributes!(user, @reflection.primary_key_name => nil) if r.is_a?(Hobo::Model) }
+      records.each { |r| r.user_update_attributes!(user, @reflection.foreign_key => nil) if r.is_a?(Hobo::Model) }
     end
 
     # Normal ActiveRecord implementatin
     ids = records.map { |record| record.quoted_id }.join(',')
     @reflection.klass.update_all(
-      "#{@reflection.primary_key_name} = NULL",
-      "#{@reflection.primary_key_name} = #{@owner.quoted_id} AND #{@reflection.klass.primary_key} IN (#{ids})"
+      "#{@reflection.foreign_key} = NULL",
+      "#{@reflection.foreign_key} = #{@owner.quoted_id} AND #{@reflection.klass.primary_key} IN (#{ids})"
     )
   end
 
 
-  def insert_record(record, force = false, validate = true)
-    set_belongs_to_association_for(record)
+  def insert_record_with_owner_attributes(record, force = true, raise = false)
+    set_owner_attributes(record)
     if (user = acting_user) && record.is_a?(Hobo::Model)
-      if force
-        record.user_save!(user)
-      else
-        record.user_save(user, validate)
-      end
+      with_acting_user(user) { insert_record_without_owner_attributes(record, force, raise) }
     else
-       if force
-         record.save!
-       else
-         record.save(:validate => validate)
-       end
+      insert_record_without_owner_attributes(record, force, raise)
     end
   end
+  alias_method_chain :insert_record, :owner_attributes
 
   def viewable_by?(user, field=nil)
     # view check on an example member record is not supported on associations with conditions
@@ -97,23 +94,20 @@ ActiveRecord::Associations::HasManyThroughAssociation.class_eval do
   end
 
 
-  def insert_record(record, force=true, validate=true)
-    user = acting_user if record.is_a?(Hobo::Model)
-    if record.new_record?
-      if force
-        user ? record.user_save!(user) : record.save!
-      else
-        return false unless (user ? record.user_save(user, validate) : record.save(validate))
-      end
+  def insert_record_with_owner_attributes(record, force = true, raise = false)
+    if (user = acting_user) && record.is_a?(Hobo::Model)
+      with_acting_user(user) { insert_record_without_owner_attributes(record, force, raise) }
+    else
+      insert_record_without_owner_attributes(record, force, raise)
     end
-    klass = @reflection.through_reflection.klass
-    @owner.send(@reflection.through_reflection.name).proxy_target <<
-      klass.send(:with_scope, :create => construct_join_attributes(record)) { user ? klass.user_create!(user) : klass.create! }
+    # the following code was in Hobo 1.3, but isn't required if you have the :inverse_of option set
+    # klass = @reflection.through_reflection.klass
+    # @owner.send(@reflection.through_reflection.name).proxy_target << klass.send(:with_scope, :create => construct_join_attributes(record)) { user ? klass.user_create!(user) : klass.create! }
   end
-
+  alias_method_chain :insert_record, :owner_attributes
 
   # TODO - add dependent option support
-  def delete_records_with_hobo_permission_check(records)
+  def delete_records_with_hobo_permission_check(records, method)
     klass  = @reflection.through_reflection.klass
     user = acting_user
     if user && records.any? { |r|
@@ -122,13 +116,13 @@ ActiveRecord::Associations::HasManyThroughAssociation.class_eval do
       }
       raise Hobo::PermissionDeniedError, "#{@owner.class}##{proxy_reflection.name}.destroy"
     end
-    delete_records_without_hobo_permission_check(records)
+    delete_records_without_hobo_permission_check(records, method)
   end
   alias_method_chain :delete_records, :hobo_permission_check
 
 end
 
-ActiveRecord::Associations::AssociationCollection.class_eval do
+ActiveRecord::Associations::AssociationProxy.class_eval do
 
   # Helper - the user acting on the owner (if there is one)
   def acting_user

data/lib/hobo/extensions/active_record/relation_with_origin.rb

@@ -20,20 +20,20 @@ module ActiveRecord
   end
 
   module Associations
-    class AssociationCollection
+    class CollectionProxy
 
       def scoped_with_origin
         relation = scoped_without_origin.clone
-        relation.origin = @owner
-        relation.origin_attribute = @reflection.name
+        relation.origin = proxy_association.owner
+        relation.origin_attribute = proxy_association.reflection.name
         relation
       end
       alias_method_chain :scoped, :origin
 
       def method_missing_with_origin(method, *args, &block)
         res = method_missing_without_origin(method, *args, &block)
-        res.origin = @owner if res.respond_to?(:origin)
-        res.origin_attribute = @reflection.name if res.respond_to?(:origin_attribute)
+        res.origin = proxy_association.owner if res.respond_to?(:origin)
+        res.origin_attribute = proxy_association.reflection.name if res.respond_to?(:origin_attribute)
         res
       end
       alias_method_chain :method_missing, :origin

data/lib/hobo/model.rb

@@ -1,6 +1,6 @@
 module Hobo
-
   module Model
+    require 'will_paginate/active_record'
 
     class NoNameError < RuntimeError; end
 
@@ -167,23 +167,23 @@ module Hobo
           #       (ie X belongs_to Y (polymorphic), Z is a subclass of Y; @x.y_is?(some_z) will never pass)
           class_eval %{
             def #{name}_is?(target)
-              target.class.name == self.#{refl.options[:foreign_type]} && target.#{id_method} == self.#{refl.primary_key_name}
+              target.class.name == self.#{refl.options[:foreign_type]} && target.#{id_method} == self.#{refl.foreign_key}
             end
             def #{name}_changed?
-              #{refl.primary_key_name}_changed? || #{refl.options[:foreign_type]}_changed?
+              #{refl.foreign_key}_changed? || #{refl.options[:foreign_type]}_changed?
             end
           }
         else
           id_method = refl.options[:primary_key] || refl.klass.primary_key
           class_eval %{
             def #{name}_is?(target)
-              our_id = self.#{refl.primary_key_name}
+              our_id = self.#{refl.foreign_key}
               # if our_id is nil, only return true if target is nil
               return target.nil? unless our_id
               target.class <= ::#{refl.klass.name} && target.#{id_method} == our_id
             end
             def #{name}_changed?
-              #{refl.primary_key_name}_changed?
+              #{refl.foreign_key}_changed?
             end
           }
         end
@@ -298,7 +298,7 @@ module Hobo
               r.klass >= self &&
               !r.options[:conditions] &&
               !r.options[:scope] &&
-              r.primary_key_name == refl.primary_key_name
+              r.foreign_key == refl.foreign_key
           end
         end
       end
@@ -377,7 +377,12 @@ module Hobo
 
     def attributes_with_hobo_type_conversion=(attributes, guard_protected_attributes=true)
       converted = attributes.map_hash { |k, v| convert_type_for_mass_assignment(self.class.attr_type(k), v) }
-      send(:attributes_without_hobo_type_conversion=, converted, guard_protected_attributes)
+      # Avoid passing this third argument if possible, to avoid a deprecation warning in Rails 3.1
+      if guard_protected_attributes
+        send(:attributes_without_hobo_type_conversion=, converted)
+      else
+        send(:attributes_without_hobo_type_conversion=, converted, true)
+      end
     end
 
 

data/lib/hobo/model/accessible_associations.rb

@@ -5,11 +5,13 @@ module Hobo
       extend self
 
       def prepare_has_many_assignment(association, association_name, array_or_hash)
-        owner = association.proxy_owner
+        owner = association.proxy_association.owner
 
         array = params_hash_to_array(array_or_hash)
         array.map! do |record_hash_or_string|
-          finder = association.member_class.scoped :conditions => association.send(:conditions)
+          finder = association.member_class
+          conditions = association.proxy_association.reflection.conditions
+          finder = finder.scoped :conditions => conditions unless conditions == [[]] || conditions == [[],[]]
           find_or_create_and_update(owner, association_name, finder, record_hash_or_string) do |id|
             # The block is required to either locate find an existing record in the collection, or build a new one
             if id
@@ -109,7 +111,7 @@ module Hobo
               __items = Hobo::Model::AccessibleAssociations.prepare_has_many_assignment(#{name}, :#{name}, array_or_hash)
               self.#{name}_without_accessible = __items
               # ensure the loaded array contains any changed records
-              self.#{name}.proxy_target[0..-1] = __items
+              self.association(:#{name}).target[0..-1] = __items
             end
           }, __FILE__, __LINE__ - 7
           alias_method_chain :"#{name}=", :accessible
@@ -160,18 +162,9 @@ module Hobo
       metaclass.alias_method_chain :belongs_to, :accessible
 
 
-      # Add :accessible to the valid keys so AR doesn't complain
-
-      def self.valid_keys_for_has_many_association_with_accessible
-        valid_keys_for_has_many_association_without_accessible + [:accessible]
-      end
-      metaclass.alias_method_chain :valid_keys_for_has_many_association, :accessible
-
-      def self.valid_keys_for_belongs_to_association_with_accessible
-        valid_keys_for_belongs_to_association_without_accessible + [:accessible]
-      end
-      metaclass.alias_method_chain :valid_keys_for_belongs_to_association, :accessible
-
+      # Add :accessible to the valid options so AR doesn't complain
+      ::ActiveRecord::Associations::Builder::BelongsTo.valid_options << :accessible
+      ::ActiveRecord::Associations::Builder::HasMany.valid_options << :accessible
 
     end
   end