hobo 1.3.0.pre31 → 1.3.0

data/lib/hobo/controller/{user.rb → user_base.rb}

@@ -1,6 +1,6 @@
 module Hobo
   module Controller
- 	 module User
+  module UserBase
 
     class << self
       def included(base)
@@ -12,7 +12,7 @@ module Hobo
             alias_method_chain :def_auto_actions, :user_actions
           end
 
-          skip_before_filter :login_required, :only => [:login, :signup, :forgot_password, :reset_password, :do_reset_password,
+          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"
@@ -52,7 +52,7 @@ module Hobo
 
     private
 
-    def hobo_login(options={})
+    def hobo_login(options={}, &block)
       if logged_in?
         respond_to do |wants|
           wants.html { redirect_to home_page }
@@ -62,8 +62,7 @@ module Hobo
       end
 
       login_attr = model.human_attribute_name(model.login_attribute)
-      options.reverse_merge!(:success_notice => ht(:"#{model.to_s.underscore}.messages.login.success", :default=>["You have logged in."]),
-                             :failure_notice => ht(:"#{model.to_s.underscore}.messages.login.error", :login=>login_attr, :default=>["You did not provide a valid #{login_attr} and password."]))
+      options.reverse_merge!(:failure_notice => ht(:"#{model.to_s.underscore}.messages.login.error", :login=>login_attr, :default=>["You did not provide a valid #{login_attr} and password."]))
 
       if request.post?
         user = model.authenticate(params[:login], params[:password])
@@ -71,33 +70,7 @@ module Hobo
           flash[:error] = options[:failure_notice]
           hobo_ajax_response if request.xhr? && !performed?
         else
-          old_user = current_user
-          self.current_user = user
-
-          yield if block_given?
-
-          if !user.account_active?
-            # account not activate - cancel this login
-            self.current_user = old_user
-            unless performed?
-              respond_to do |wants|
-                wants.html {render :action => :account_disabled}
-                wants.js {hobo_ajax_response}
-              end
-            end
-          else
-            if params[:remember_me].present?
-              current_user.remember_me
-              create_auth_cookie
-            end
-            flash[:notice] ||= options[:success_notice]
-            unless performed?
-              respond_to do |wants|
-                wants.html {redirect_back_or_default(options[:redirect_to] || home_page) }
-                wants.js {hobo_ajax_response}
-              end
-            end
-          end
+          self.sign_user_in(user, options){ yield if block_given?}
         end
       end
     end
@@ -183,6 +156,44 @@ module Hobo
       end
     end
 
+    protected
+    # If you are authenticating user on your own call this method -
+    # hobo will remember signed-in user this way. Arguments:
+    # user - user that you want to sign in
+    # options - hash with messages (:success_notice, :redirect_to)
+    # block - (optional) will be called after assigning current_user
+    def sign_user_in(user, options={}, &block)
+      options.reverse_merge!(:success_notice => ht(:"#{model.to_s.underscore}.messages.login.success", :default=>["You have logged in."]))
+
+      old_user = current_user
+      self.current_user = user
+
+      yield if block_given?
+
+      if !user.account_active?
+        # account not activate - cancel this login
+        self.current_user = old_user
+        unless performed?
+          respond_to do |wants|
+            wants.html {render :action => :account_disabled}
+            wants.js {hobo_ajax_response}
+          end
+        end
+      else
+        if params[:remember_me].present?
+          current_user.remember_me
+          create_auth_cookie
+        end
+        flash[:notice] ||= options[:success_notice]
+        unless performed?
+          respond_to do |wants|
+            wants.html {redirect_back_or_default(options[:redirect_to] || home_page) }
+            wants.js {hobo_ajax_response}
+          end
+        end
+      end
+    end
+
   end
   end
 end

data/lib/hobo/extensions/action_controller/hobo_methods.rb

@@ -2,7 +2,7 @@ ActionController::Base.class_eval do
 
   def self.hobo_user_controller
     include Hobo::Controller::Model
-    include Hobo::Controller::User
+    include Hobo::Controller::UserBase
   end
 
   def self.hobo_model_controller
@@ -17,4 +17,28 @@ ActionController::Base.class_eval do
     base_url
   end
 
+  # moved here from authentication_support.rb for easy overriding
+  # Redirect as appropriate when an access request fails.
+  #
+  # The default action is to redirect to the login screen.
+  #
+  # Override this method in your controllers if you want to have special
+  # behavior in case the user is not authorized
+  # to access the requested action.  For example, a popup window might
+  # simply close itself.
+  def access_denied(user_model)
+    respond_to do |accepts|
+      accepts.html do
+        store_location
+        redirect_to(login_url(user_model))
+      end
+      accepts.xml do
+        headers["Status"]           = "Unauthorized"
+        headers["WWW-Authenticate"] = %(Basic realm="Web Password")
+        render :text => t("hobo.messages.unauthenticated", :default=>["Couldn't authenticate you"]), :status => '401 Unauthorized'
+      end
+    end
+    false
+  end
+
 end

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

@@ -28,12 +28,17 @@ module ActiveRecord
       # 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)
-        proxy_respond_to?(*args) || Array.new.respond_to?(*args)
+        return super if has_one_collection?
+        proxy_respond_to?(*args) || [].respond_to?(*args)
       end
 
-      # TODO: send this patch into Rails. There's no reason to load the collection just to find out it acts like an array.
       def is_a?(klass)
-        [].is_a?(klass)
+        if has_one_collection?
+          load_target
+          @target.is_a?(klass)
+        else
+          [].is_a?(klass)
+        end
       end
 
       def member_class
@@ -52,6 +57,10 @@ module ActiveRecord
           end
         end
 
+        def has_one_collection?
+          proxy_reflection.macro == :has_one
+        end
+
     end
   end
 end

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

@@ -9,7 +9,7 @@ module ActiveRecord
           begin
             klass_without_create_polymorphic_class
           rescue NameError => e
-            Object.class_eval "class #{e.missing_name} < ActiveRecord::Base; set_table_name '#{active_record.name.tableize}'; end"
+            Object.class_eval "class #{e.missing_name} < ActiveRecord::Base; set_table_name '#{active_record.name.tableize}'; def self.hobo_shim?; true; end; end"
             e.missing_name.constantize
           end
         else

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

@@ -2,6 +2,10 @@ module ActiveRecord
 
   class Relation
     attr_accessor :origin, :origin_attribute
+
+    def member_class
+      @klass
+    end
   end
 
   module Associations

data/lib/hobo/helper.rb

@@ -179,6 +179,10 @@ module Hobo
       object.respond_to?(:typed_id) ? "model::#{typed_id(object, attribute).to_s.dasherize}" : ""
     end
 
+    def update_elements_class(updates)
+      'update::'+comma_split(updates).join(':') unless updates.blank?
+    end
+
     def can_create?(object=this)
       if object.is_a?(Class) and object < ActiveRecord::Base
         object = object.new
@@ -248,7 +252,8 @@ module Hobo
       # TODO: Man does this need a big cleanup!
 
       if args.empty?
-        if this_parent && this_field
+        # if we're repeating over an array, this_field ends up with the current index. Is this useful to anybody?
+        if this_parent && this_field && !this_field.is_a?(Integer)
           object = this_parent
           field = this_field
         else

data/lib/hobo/helper/translations.rb

@@ -42,7 +42,7 @@ en:
           raise Hobo::I18nError, %(wrong model name: "#{model_name}" (extracted from translation key: "#{key}"). You might want to use the translate/t tag/method instead.)
         end
         options[:default].unshift("hobo.#{keys.join(".")}".to_sym)
-        options[:model] = model_class.model_name.human(:count=>options[:count]||1)
+        options[:model] = model_class.model_name.human(:count=>(options[:count] || 1).to_i)
         translate key.to_sym, options
       end
       alias_method :ht, :hobo_translate

data/lib/hobo/model.rb

@@ -33,17 +33,6 @@ module Hobo
         alias_method_chain :attr_accessor, :creator_metadata
 
         alias_method_chain :has_one, :new_method
-
-        # eval avoids the ruby 1.9.2 "super from singleton method ..." error
-        eval %(
-        def inherited(klass)
-          super
-          fields(false) do
-            Hobo.register_model(klass)
-            field(klass.inheritance_column, :string)
-          end
-        end
-        )
       end
 
       base.fields(false) # force hobo_fields to load
@@ -56,18 +45,45 @@ module Hobo
 
         WillPaginate::Collection.class_eval do
           attr_accessor :member_class, :origin, :origin_attribute
+
+          # make paginate_by_sql, etc. carry metadata
+          def replace_with_hobo_metadata(array)
+            result = replace_without_hobo_metadata(array)
+            self.member_class = array.try.member_class
+            self.origin = array.try.origin
+            self.origin_attribute = array.try.origin_attribute
+            result
+          end
+          alias_method_chain :replace, :hobo_metadata
         end
 
-        WillPaginate::Finders::Base.class_eval do
-          def paginate_with_hobo_metadata(*args, &block)
-            collection = paginate_without_hobo_metadata(*args, &block)
-            collection.member_class     = self.is_a?(ActiveRecord::Relation) ? member_class : self
+        WillPaginate::ActiveRecord::Pagination.class_eval do
+
+          def apply_hobo_metadata(collection)
+            klass = Object.instance_method(:class).bind(self).call
+            is_relation = klass <= ActiveRecord::Relation
+            is_association_proxy = klass <= ActiveRecord::Associations::AssociationProxy
+            collection.member_class     = (is_relation || is_association_proxy) ? member_class : self
             collection.origin           = try.proxy_owner
             collection.origin_attribute = try.proxy_reflection._?.name
             collection
           end
+
+          # NOTE: as of will_paginate 3.0.0, the standard paginate method calls the page method.
+          # However, it converts an association proxy into a relation first (via adding a limit clause),
+          # which causes the proxy_owner and proxy_reflection methods to disappear.
+          def paginate_with_hobo_metadata(*args, &block)
+            collection = paginate_without_hobo_metadata(*args, &block)
+            apply_hobo_metadata(collection)
+          end
           alias_method_chain :paginate, :hobo_metadata
 
+          def page_with_hobo_metadata(*args, &block)
+            collection = page_without_hobo_metadata(*args, &block)
+            apply_hobo_metadata(collection)
+          end
+          alias_method_chain :page, :hobo_metadata
+
         end
 
       end
@@ -116,7 +132,6 @@ module Hobo
       end
     end
 
-
     module ClassMethods
 
       # TODO: should this be an inheriting_cattr_accessor as well? Probably.
@@ -146,6 +161,18 @@ module Hobo
         send(:login_attribute=, name.to_sym, validate) if options.delete(:login) && respond_to?(:login_attribute=)
       end
 
+      # eval avoids the ruby 1.9.2 "super from singleton method ..." error
+      eval %(
+        def inherited(klass)
+          super
+          Hobo::Model.register_model(klass)
+          # TODO: figure out when this is needed, as Hobofields already does this
+          fields(false) do
+            field(klass.inheritance_column, :string)
+          end
+        end
+      )
+
       private
 
       def attrib_names
@@ -162,22 +189,27 @@ module Hobo
       def belongs_to_with_test_methods(name, options={}, &block)
         belongs_to_without_test_methods(name, options, &block)
         refl = reflections[name]
+        id_method = refl.options[:primary_key] || refl.klass.primary_key
         if options[:polymorphic]
           # TODO: the class lookup in _is? below is incomplete; a polymorphic association to an STI base class
           #       will fail to match an object of a derived type
           #       (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 == self.#{refl.primary_key_name}
+              target.class.name == self.#{refl.options[:foreign_type]} && target.#{id_method} == self.#{refl.primary_key_name}
             end
             def #{name}_changed?
               #{refl.primary_key_name}_changed? || #{refl.options[:foreign_type]}_changed?
             end
           }
         else
+          id_method = refl.options[:primary_key] || refl.klass.primary_key
           class_eval %{
             def #{name}_is?(target)
-              target.class <= ::#{refl.klass.name} && target.id == self.#{refl.primary_key_name}
+              our_id = self.#{refl.primary_key_name}
+              # 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?
@@ -438,7 +470,11 @@ module Hobo
           if parts.include?(0)
             nil
           else
-            Date.new(*parts)
+            begin
+              Date.new(*parts)
+            rescue ArgumentError => ex
+              Time.time_with_datetime_fallback(ActiveRecord::Base.default_timezone, *parts).to_date
+            end
           end
         else
           value

data/lib/hobo/model/lifecycles.rb

@@ -103,9 +103,9 @@ module Hobo
         end
 
         def transition(name, change, options={}, &block)
-          @lifecycle.def_transition(name,
-                                    Array(change.keys.first), change.values.first,
-                                    block, options)
+          change.each do |k,v|
+		    @lifecycle.def_transition(name, Array(k), v, block, options)
+          end
         end
 
         def invariant(&block)

data/lib/hobo/model/lifecycles/lifecycle.rb

@@ -41,7 +41,7 @@ module Hobo
           Creator.new(self, name.to_s, on_create, options)
         end
 
-        def self.def_transition(name, start_state, end_states, on_transition, options)
+        def self.def_transition(name, start_states, end_state, on_transition, options)
           class_eval %{
                        def #{name}!(user, attributes=nil)
                          transition(:#{name}, user, attributes)
@@ -50,7 +50,7 @@ module Hobo
                          can_transition?(:#{name}, user)
                        end
                       }
-          Transition.new(self, name.to_s, start_state, end_states, on_transition, options)
+          Transition.new(self, name.to_s, start_states, end_state, on_transition, options)
         end
 
         def self.state_names
@@ -149,7 +149,11 @@ module Hobo
         end
 
         def publishable_transitions_for(user)
-          available_transitions_for(user).select {|t| t.publishable_by(user, t.available_to, record)}
+          record.with_acting_user(user) do
+            available_transitions_for(user).select do |t|
+              t.publishable_by(user, t.available_to, record)
+            end
+          end
         end
 
 

data/lib/hobo/model/permissions.rb

@@ -161,6 +161,7 @@ module Hobo
 
 
       def with_acting_user(user)
+        return yield if user == acting_user
         old = acting_user
         self.acting_user = user
         result = yield

data/lib/hobo/model/scopes/automatic_scopes.rb

@@ -288,8 +288,6 @@ module Hobo
             end
 
           when name == "order_by"
-            # DEPRECATED: use :order instead.
-            Rails.logger.warn "Automatic scope :order_by has been deprecated: use :order instead."
             return true if check_only
 
             klass = @klass

data/lib/hobo/model/view_hints.rb

@@ -73,6 +73,7 @@ module Hobo
           if arg.nil?
             @sortable ||= defined?(ActiveRecord::Acts::List::InstanceMethods) &&
                           model < ActiveRecord::Acts::List::InstanceMethods &&
+                          model.table_exists? &&
                           model.new.try.scope_condition == "1 = 1"
           else
             @sortable = arg

data/lib/hobo/rapid/generators/rapid/forms.dryml.erb

@@ -1,5 +1,6 @@
 <% each_controller do -%>
 <%
+next unless @controller < Hobo::Controller::Model
 form_fields = standard_fields :belongs_to, :has_many
 
 cancel_to_show_page  = linkable?(:show)
@@ -29,7 +30,7 @@ model_key = model.to_s.underscore
 </def>
 <% end -%>
 
-<% transitions.each do |transition| -%>
+<% transitions.uniq{|s| s.name}.each do |transition| -%>
 <def tag="<%= transition.name.to_s.dasherize %>-form" polymorphic/>
 <def tag="<%= transition.name.to_s.dasherize %>-form" for="<%= model.name %>">
   <form lifecycle="<%= transition.name %>" merge param="default">