hobo 1.3.0.RC4 → 1.3.0.pre10

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

@@ -1,6 +1,6 @@
 module Hobo
   module Controller
-  module UserBase
+ 	 module User
 
     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, :do_signup, :forgot_password, :reset_password, :do_reset_password,
+          skip_before_filter :login_required, :only => [:login, :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={}, &block)
+    def hobo_login(options={})
       if logged_in?
         respond_to do |wants|
           wants.html { redirect_to home_page }
@@ -62,7 +62,8 @@ module Hobo
       end
 
       login_attr = model.human_attribute_name(model.login_attribute)
-      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."]))
+      options.reverse_merge!(:success_notice => ht(:"users.messages.login.success", :default=>["You have logged in."]),
+                             :failure_notice => ht(:"users.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])
@@ -70,7 +71,33 @@ module Hobo
           flash[:error] = options[:failure_notice]
           hobo_ajax_response if request.xhr? && !performed?
         else
-          self.sign_user_in(user, options){ yield if block_given?}
+          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
@@ -86,7 +113,7 @@ module Hobo
     def hobo_do_signup(&b)
       do_creator_action(:signup) do
         if valid?
-          flash[:notice] = ht(:"#{model.to_s.underscore}.messages.signup.success", :default=>["Thanks for signing up!"])
+          flash[:notice] = ht(:"users.messages.signup.success", :default=>["Thanks for signing up!"])
         end
         response_block(&b) or if valid?
                                 self.current_user = this if this.account_active?
@@ -100,7 +127,7 @@ module Hobo
 
 
     def hobo_logout(options={})
-      options = options.reverse_merge(:notice => ht(:"#{model.to_s.underscore}.messages.logout", :default=>["You have logged out."]),
+      options = options.reverse_merge(:notice => ht(:"users.messages.logout", :default=>["You have logged out."]),
                                       :redirect_to => base_url)
 
       logout_current_user
@@ -128,7 +155,7 @@ module Hobo
       do_transition_action :reset_password do
         response_block(&b) or if valid?
                                 self.current_user = this
-                                flash[:notice] = ht(:"#{model.to_s.underscore}.messages.reset_password", :default=>["Your password has been reset"])
+                                flash[:notice] = ht(:"users.messages.reset_password", :default=>["Your password has been reset"])
                                 respond_to do |wants|
                                   wants.html { redirect_to(home_page) }
                                   wants.js { hobo_ajax_response }
@@ -140,7 +167,7 @@ module Hobo
 
     def hobo_update_with_account_flash(*args)
       hobo_update_without_account_flash(*args) do
-        flash[:notice] = ht(:"#{model.to_s.underscore}.messages.update.success", :default=>["Changes to your account were saved"]) if valid? && @this == current_user
+        flash[:notice] = ht(:"users.messages.update.success", :default=>["Changes to your account were saved"]) if valid? && @this == current_user
         yield if block_given?
       end
     end
@@ -156,44 +183,6 @@ 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/engine.rb

@@ -13,9 +13,6 @@ module Hobo
       h.routes_path = Pathname.new File.expand_path('config/hobo_routes.rb', Rails.root)
       h.rapid_generators_path = Pathname.new File.expand_path('lib/hobo/rapid/generators', Hobo.root)
       h.auto_taglibs_path = Pathname.new File.expand_path('app/views/taglibs/auto', Rails.root)
-      h.read_only_file_system = !!ENV['HEROKU_TYPE']
-      h.show_translation_keys = false
-      h.dryml_only_templates = false
     end
 
     ActiveSupport.on_load(:action_controller) do
@@ -24,55 +21,44 @@ module Hobo
     end
 
     ActiveSupport.on_load(:active_record) do
-      require 'hobo/extensions/active_record/associations/collection'
-      require 'hobo/extensions/active_record/associations/proxy'
-      require 'hobo/extensions/active_record/associations/reflection'
+      require 'hobo/extensions/active_record/association_collection'
+      require 'hobo/extensions/active_record/association_proxy'
+      require 'hobo/extensions/active_record/association_reflection'
       require 'hobo/extensions/active_record/hobo_methods'
       require 'hobo/extensions/active_record/permissions'
-      require 'hobo/extensions/active_record/associations/scope'
-      require 'hobo/extensions/active_record/relation_with_origin'
+      require 'hobo/extensions/active_record/scopes'
       require 'hobo/extensions/active_model/name'
       require 'hobo/extensions/active_model/translation'
-      # added legacy namespace for backward compatibility
-      # TODO: remove the following line if Hobo::VERSION > 1.3.x
-      Hobo::ViewHints = Hobo::Model::ViewHints
     end
 
     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
       require 'hobo/undefined'
-      HoboFields.never_wrap(Hobo::Undefined)
+
       h = config.hobo
       Dryml::DrymlGenerator.enable([h.rapid_generators_path], h.auto_taglibs_path)
-    end
 
-    initializer 'hobo.i18n' do |app|
-      require 'hobo/extensions/i18n' if app.config.hobo.show_translation_keys
+      HoboFields.never_wrap(Hobo::Undefined)
     end
 
     initializer 'hobo.routes' do |app|
       h = app.config.hobo
       # generate at first boot, so no manual generation is required
-      unless File.exists?(h.routes_path)
-        raise Hobo::Error, "No #{h.routes_path} found!" if h.read_only_file_system
-        Rails::Generators.invoke('hobo:routes', %w[-f -q])
-      end
+      Rails::Generators.invoke('hobo:routes', %w[-f -q]) unless File.exists?(h.routes_path)
       app.routes_reloader.paths << h.routes_path
       app.config.to_prepare do
+        Rails::Generators.configure!
+        # generate before each request in development
         Rails::Generators.invoke('hobo:routes', %w[-f -q])
       end
     end
 
     initializer 'hobo.dryml' do |app|
-      unless app.config.hobo.read_only_file_system
-        app.config.to_prepare do
-          Dryml::DrymlGenerator.run
-        end
+      app.config.to_prepare do
+        Dryml::DrymlGenerator.run
       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::UserBase
+    include Hobo::Controller::User
   end
 
   def self.hobo_model_controller
@@ -17,28 +17,4 @@ 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_model/translation.rb

@@ -21,7 +21,7 @@ ActiveModel::Translation.class_eval do
     # otherwise it returns "".
     def attribute_help(attribute, options = {})
       defaults = lookup_ancestors.map do |klass|
-        :"#{self.i18n_scope}.attribute_help.#{klass.to_s.underscore}.#{attribute}"
+        :"#{self.i18n_scope}.attribute_help.#{klass.model_name.underscore}.#{attribute}"
       end
 
       defaults << :"attribute_help.#{attribute}"

data/lib/hobo/extensions/active_record/{associations/collection.rb → association_collection.rb}

@@ -28,17 +28,12 @@ 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)
-        return super if has_one_collection?
-        proxy_respond_to?(*args) || [].respond_to?(*args)
+        proxy_respond_to?(*args) || Array.new.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)
-        if has_one_collection?
-          load_target
-          @target.is_a?(klass)
-        else
-          [].is_a?(klass)
-        end
+        [].is_a?(klass)
       end
 
       def member_class
@@ -57,10 +52,6 @@ module ActiveRecord
           end
         end
 
-        def has_one_collection?
-          proxy_reflection.macro == :has_one
-        end
-
     end
   end
 end

data/lib/hobo/extensions/active_record/{associations/proxy.rb → association_proxy.rb}

@@ -2,16 +2,17 @@ module ActiveRecord
   module Associations
     class AssociationProxy #:nodoc:
 
-      def origin
-        proxy_owner
-      end
+    def origin
+      proxy_owner
+    end
 
-      def origin_attribute
-        proxy_reflection.name
-      end
+    def origin_attribute
+      proxy_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

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

@@ -0,0 +1,19 @@
+class ActiveRecord::Reflection::AssociationReflection
+
+  alias_method :association_name, :name
+
+  def klass_with_create_polymorphic_class
+    if options[:polymorphic]
+      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"
+        e.missing_name.constantize
+      end
+    else
+      klass_without_create_polymorphic_class
+    end
+  end
+  alias_method_chain :klass, :create_polymorphic_class
+
+end

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

@@ -5,7 +5,7 @@ ActiveRecord::Base.class_eval do
   end
   def self.hobo_user_model
     include Hobo::Model
-    include Hobo::Model::UserBase
+    include Hobo::Model::User
   end
   alias_method :has_hobo_method?, :respond_to_without_attributes?
 end

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

@@ -0,0 +1,31 @@
+# Add support for :scope => :my_scope to associations
+
+ActiveRecord::Associations::ThroughAssociationScope.class_eval do
+
+  def construct_scope_with_scope
+    s = construct_scope_without_scope
+    s[:find][:scope] = @reflection.options[:scope]
+    s
+  end
+  alias_method_chain :construct_scope, :scope
+
+end
+
+ActiveRecord::SpawnMethods.class_eval do
+
+  def apply_finder_options_with_scope(options)
+    scopes = []
+    Array.wrap(options.delete(:scope)).each do |s|
+      if s.is_a?(Hash)
+        s.each_pair{|k,v| scopes << [k,v] }
+      else
+        scopes << [s]
+      end
+    end
+    relation = apply_finder_options_without_scope(options)
+    return relation if scopes.empty?
+    scopes.inject(relation) {|r, s| r.send *s }
+  end
+  alias_method_chain :apply_finder_options, :scope
+
+end

data/lib/hobo/extensions/array.rb

@@ -1,13 +1,10 @@
 # Add support for type metadata to arrays
-
-require 'will_paginate/array'
-
 class Array
 
   attr_accessor :member_class, :origin, :origin_attribute
 
   def to_url_path
-    base_path = origin.try.to_url_path
+    base_path = origin_object.try.to_url_path
     "#{base_path}/#{origin_attribute}" unless base_path.blank?
   end
 
@@ -15,13 +12,4 @@ class Array
     origin and origin_id = origin.try.typed_id and "#{origin_id}:#{origin_attribute}"
   end
 
-  def paginate_with_hobo_metadata(*args, &block)
-    collection = paginate_without_hobo_metadata(*args, &block)
-    collection.member_class     = member_class
-    collection.origin           = try.proxy_owner
-    collection.origin_attribute = try.proxy_reflection._?.name
-    collection
-  end
-  alias_method_chain :paginate, :hobo_metadata
-
 end

data/lib/hobo/helper.rb

@@ -58,7 +58,7 @@ module Hobo
       options[:subsite] ||= self.subsite
       subsite, method = options.get :subsite, :method
 
-      if obj.respond_to?(:member_class) && obj.respond_to?(:origin) && obj.origin
+      if obj.respond_to?(:member_class) && obj.respond_to?(:origin)
         # Asking for URL of a collection, e.g. category/1/adverts or category/1/adverts/new
 
         refl = obj.origin.class.reverse_reflection(obj.origin_attribute)
@@ -112,10 +112,7 @@ module Hobo
 
     def app_name(add_subsite=true)
       an = Rails.application.config.hobo.app_name
-      if add_subsite && subsite
-        subsite_name = t 'hobo.admin.subsite_name', :default => subsite.titleize
-        an = an + " - #{subsite_name}"
-      end
+      an = an + " - #{subsite.titleize}" if add_subsite && subsite
       an
     end
 
@@ -126,18 +123,6 @@ module Hobo
     end
 
 
-    def recognize_page_path
-      Rails.application.routes.recognize_path(params[:page_path]||request.fullpath)
-    end
-
-    def url_for_page_path(options={})
-      url_for recognize_page_path.merge(options)
-    end
-
-    def controller_action_from_page_path
-      recognize_page_path.values_at(:controller,:action)
-    end
-
     def _as_params(name, obj)
       if obj.is_a? Array
         obj.map {|x| _as_params("#{name}[]", x)}.join("&")
@@ -179,10 +164,6 @@ 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
@@ -252,8 +233,7 @@ module Hobo
       # TODO: Man does this need a big cleanup!
 
       if args.empty?
-        # 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)
+        if this_parent && this_field
           object = this_parent
           field = this_field
         else
@@ -348,19 +328,19 @@ module Hobo
 
 
     # Login url for a given user record or user class
-    def forgot_password_url(user_class=Hobo::Model::UserBase.default_user_model)
+    def forgot_password_url(user_class=Hobo::Model::User.default_user_model)
       send("#{user_class.name.underscore}_forgot_password_url") rescue nil
     end
 
 
     # Login url for a given user record or user class
-    def login_url(user_class=Hobo::Model::UserBase.default_user_model)
+    def login_url(user_class=Hobo::Model::User.default_user_model)
       send("#{user_class.name.underscore}_login_url") rescue nil
     end
 
 
     # Sign-up url for a given user record or user class
-    def signup_url(user_class=Hobo::Model::UserBase.default_user_model)
+    def signup_url(user_class=Hobo::Model::User.default_user_model)
       send("#{user_class.name.underscore}_signup_url") rescue nil
     end
 
@@ -400,7 +380,6 @@ module Hobo
       options = args.extract_options!
       target = args.empty? || args.first.is_a?(Symbol) ? this : args.shift
       action = args.first
-      return false if action.nil? && target.try.new_record?
 
       if target.respond_to?(:member_class) && (origin = target.try.origin)
         klass = origin.class