hobo 0.7.2 → 0.7.3

data/hobo_files/plugin/lib/hobo/scopes/defined_scope_proxy_extender.rb

@@ -0,0 +1,88 @@
+module Hobo
+
+  module Scopes
+    
+    module DefinedScopeProxyExtender
+      
+      attr_accessor :reflections
+      
+      include AutomaticScopes
+      
+      def method_missing(name, *args, &block)
+        if (scope = named_scope(name))
+          association_proxy_for_scope(name, scope, args)
+        elsif member_class.create_automatic_scope(name)
+          # create_automatic_scope returned true -- the method now exists
+          send(name, *args, &block)
+        else
+          super
+        end
+      end
+      
+      
+      def named_scope(name)
+        proxy_reflection.klass.try.defined_scopes._?[name.to_sym]
+      end
+      
+      
+      def association_proxy_for_scope(name, scope_or_proc, args)
+        if scope_or_proc.is_a?(Proc)
+          scope = scope_or_proc.call(*args)
+          create_association_proxy_for_scope(name, scope)
+        else
+          # This scope is not parameterised so we can cache the
+          # association-proxy in an instance variable
+          scope = scope_or_proc
+          scope_ivar = "@#{name.to_s.gsub('?','')}_scope"
+          
+          # Some craziness here -- calling instance_variable_get or
+          # set directly causes self to get loaded, hence the 'bind'
+          # tricks
+          Kernel.instance_method(:instance_variable_get).bind(self).call(scope_ivar) or
+            begin
+              assoc = create_association_proxy_for_scope(name, scope)
+              Kernel.instance_method(:instance_variable_set).bind(self).call(scope_ivar, assoc)
+            end
+        end
+      end
+      
+      
+      def create_association_proxy_for_scope(name, scope)
+        options = proxy_reflection.options
+        has_many_conditions = options[:conditions]
+        has_many_conditions = nil if has_many_conditions.blank?
+        source = proxy_reflection.source_reflection
+        scope_conditions = scope[:conditions]
+        scope_conditions = nil if scope_conditions.blank?
+        conditions = if has_many_conditions && scope_conditions
+                       "(#{sanitize_sql scope_conditions}) AND (#{sanitize_sql has_many_conditions})"
+                     else
+                       scope_conditions || has_many_conditions
+                     end
+        
+        options = options.merge(scope).update(:class_name => proxy_reflection.klass.name,
+                                              :foreign_key => proxy_reflection.primary_key_name)
+        options[:conditions] = conditions unless conditions.blank?
+        options[:source] = source.name if source
+        
+        options[:limit]   = scope[:limit]   if scope[:limit]
+        options[:order]   = scope[:order]   if scope[:order]
+        options[:include] = scope[:include] if scope[:include]
+
+        r = ScopeReflection.new(:has_many, name, options, proxy_owner.class, proxy_reflection.name)
+        
+        @reflections ||= {}
+        @reflections[name] = r
+        
+        if source
+          ActiveRecord::Associations::HasManyThroughAssociation
+        else
+          ActiveRecord::Associations::HasManyAssociation
+        end.new(proxy_owner, r)
+      end
+   
+    end
+    
+  end      
+
+end

data/hobo_files/plugin/lib/hobo/scopes/scope_reflection.rb

@@ -0,0 +1,18 @@
+module Hobo
+  
+  module Scopes
+    
+    class ScopeReflection < ActiveRecord::Reflection::AssociationReflection
+      
+      def initialize(macro, name, options, klass, association_name)
+        super(macro, name, options, klass)
+        @association_name = association_name
+      end
+      
+      attr_accessor :association_name
+      
+    end
+
+  end
+  
+end

data/hobo_files/plugin/lib/hobo/scopes/scoped_proxy.rb

@@ -0,0 +1,59 @@
+module Hobo
+  
+  module Scopes
+    
+    class ScopedProxy
+      
+      #include AutomaticScopes
+      
+      def initialize(klass, scope)
+        @klass = klass
+        @scope = scope
+      end
+      
+      
+      def method_missing(name, *args, &block)
+        if name.to_sym.in?(@klass.defined_scopes.keys) || @klass.create_automatic_scope(name)
+          proxy = @klass.send(name, *args)
+          proxy.instance_variable_set("@parent_scope", self)
+          proxy
+        else
+          _apply_scope { @klass.send(name, *args, &block) }
+        end
+      end
+      
+      def all
+        self.find(:all)
+      end
+      
+      def first
+        self.find(:first)
+      end
+      
+      def member_class
+        @klass
+      end
+      
+      private
+      def _apply_scope
+        if @parent_scope
+          @parent_scope.send(:_apply_scope) do
+            @scope ? @klass.send(:with_scope, :find => @scope) { yield } : yield
+          end
+        else
+          @scope ? @klass.send(:with_scope, :find => @scope) { yield } : yield
+        end
+      end
+      
+    end
+    (Object.instance_methods + 
+     Object.private_instance_methods +
+     Object.protected_instance_methods).each do |m|
+      ScopedProxy.send(:undef_method, m) unless
+        m.in?(%w{initialize method_missing send instance_variable_set instance_variable_get puts}) || m.starts_with?('_')
+      
+    end
+    
+  end
+  
+end

data/hobo_files/plugin/lib/hobo/undefined.rb

@@ -40,3 +40,5 @@ module Hobo
   end
 
 end
+
+

data/hobo_files/plugin/lib/hobo/user.rb

@@ -4,6 +4,12 @@ module Hobo
 
   module User
     
+    @user_models = []
+    
+    def self.default_user_model
+      @user_models.first._?.constantize
+    end
+    
     AUTHENTICATION_FIELDS = [:salt, :crypted_password, :remember_token, :remember_token_expires_at]
 
     # Extend the base class with AuthenticatedUser functionality
@@ -12,9 +18,12 @@ module Hobo
     # - plaintext password validation
     # - login token for rembering a login during multiple browser sessions
     def self.included(base)
+      @user_models << base.name
+      
       base.extend(ClassMethods)
 
       base.class_eval do
+        
         fields do
           crypted_password          :string, :limit => 40
           salt                      :string, :limit => 40
@@ -22,21 +31,20 @@ module Hobo
           remember_token_expires_at :datetime
         end
         
-        # Virtual attribute for the unencrypted password
-        attr_accessor :password
+        validates_confirmation_of :password, :if => :password_required?
 
-        validates_presence_of     :password,                   :if => :password_required?
-        validates_presence_of     :password_confirmation,      :if => :password_required?
-        validates_confirmation_of :password,                   :if => :password_required?
-      
+        # Virtual attributes for setting and changing the password
+        attr_accessor :current_password, :password, :password_confirmation, :type => :password
+
+
+        validate :validate_current_password_when_changing_password
+        
         before_save :encrypt_password
         
         never_show *AUTHENTICATION_FIELDS
         
         attr_protected *AUTHENTICATION_FIELDS
         
-        set_field_type :password => :password, :password_confirmation => :password
-        
         password_validations
       end
     end
@@ -50,23 +58,22 @@ module Hobo
       end
       
       def login_attribute=(attr, validate=true)
-        @login_attr = attr = attr.to_sym
+        @login_attribute = attr = attr.to_sym
         unless attr == :login
           alias_attribute(:login, attr)
-          set_field_type :login => field_type(attr)
+          declare_attr_type(:login, attr_type(attr)) if table_exists? # this breaks if the table doesn't exist
         end
         
         if validate
-          validates_presence_of   attr
           validates_length_of     attr, :within => 3..100
           validates_uniqueness_of attr, :case_sensitive => false
         end
       end
-      attr_reader :login_attr
+      attr_reader :login_attribute
 
       # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
       def authenticate(login, password)
-        u = find(:first, :conditions => ["#{@login_attr} = ?", login]) # need to get the salt
+        u = find(:first, :conditions => ["#{@login_attribute} = ?", login]) # need to get the salt
         
         if u && u.authenticated?(password)
           if u.respond_to?(:last_login_at) || u.respond_to?(:login_count)
@@ -125,6 +132,10 @@ module Hobo
       false
     end
     
+    def changing_password?
+      crypted_password? && (password || password_confirmation)
+    end
+
     protected
     # Before filter that encrypts the password before having it stored in the database.
     def encrypt_password
@@ -133,9 +144,15 @@ module Hobo
       self.crypted_password = encrypt(password)
     end
 
+    
     # Is a password required for login? (or do we have an empty password?)
     def password_required?
-      (crypted_password.blank? && password != nil) || !password.blank?
+      (crypted_password.blank? && password != nil) || !password.blank? || changing_password?
+    end
+
+    
+    def validate_current_password_when_changing_password
+      changing_password? && !authenticated?(current_password) and errors.add :current_password, "is not correct" 
     end
     
   end

data/hobo_files/plugin/lib/hobo/user_controller.rb

@@ -2,15 +2,18 @@ module Hobo
 
   module UserController
 
-    @user_models = []
-
     class << self
-      attr_reader :user_models
-      
       def included(base)
-        base.filter_parameter_logging "password"
-        base.skip_before_filter :login_required, :only => [:login]
-        user_models << base.model
+        base.class_eval do 
+          filter_parameter_logging "password"
+          skip_before_filter :login_required, :only => [:login, :signup]
+          
+          include_taglib "rapid_user_pages", :plugin => "hobo"
+          
+          show_action :account
+          
+          alias_method_chain :hobo_update, :account_flash
+        end
       end
     end
     
@@ -20,9 +23,10 @@ module Hobo
     
     def logout; hobo_logout; end
     
+    private
+    
     def hobo_login(options={})
-      options = LazyHash.new(options)
-      login_attr = model.login_attr.to_s.titleize.downcase
+      login_attr = model.login_attribute.to_s.titleize.downcase
       options.reverse_merge!(:success_notice => "You have logged in.",
                              :failure_notice => "You did not provide a valid #{login_attr} and password.")
       
@@ -36,10 +40,12 @@ module Hobo
           
           # If supplied, a block can be used to test if this user is
           # allowed to log in (e.g. the account may be disabled)
-          if block_given? && !yield
+          account_available = block_given? ? yield : true
+
+          if !account_available
             # block returned false - cancel this login
             self.current_user = old_user
-            hobo_render(:account_disabled)
+            render :action => :account_disabled unless performed?
           else
             if params[:remember_me] == "1"
               current_user.remember_me
@@ -50,30 +56,21 @@ module Hobo
           end
         end
       end
-
-      hobo_render unless performed?
     end
 
     
     def hobo_signup(&b)
       if request.post?
-        @user = model.new(params[model.name.underscore])
-        @this = @user
-        save_and_set_status!(@user)
-        self.current_user = @user if valid?
+        self.this = model.user_create(current_user, params[model.name.underscore])
+        self.current_user = this if valid?
         response_block(&b) or
           if valid?
             flash[:notice] ||= "Thanks for signing up!"
             redirect_back_or_default(home_page)
-          elsif invalid?
-            hobo_render
-          elsif not_allowed?
-            permission_denied
           end
       else
-        @this = @user = model.new
+        self.this = model.new
         yield if block_given?
-        hobo_render unless performed?
       end
     end
 
@@ -81,15 +78,32 @@ module Hobo
     def hobo_logout(options={})
       options = options.reverse_merge(:notice => "You have logged out.",
                                       :redirect_to => base_url)
-        
-      current_user.forget_me if logged_in?
-      cookies.delete :auth_token
-      reset_session
+
+      logout_current_user
       yield if block_given?
       flash[:notice] ||= options[:notice]
       redirect_back_or_default(options[:redirect_to]) unless performed?
     end
     
+    
+    def hobo_update_with_account_flash(*args)
+      hobo_update_without_account_flash(*args) do
+        flash[:notice] = "Changes to your account were saved" if valid? && @this == current_user
+        yield if block_given?
+      end
+    end
+    
+    private
+    
+    def logout_current_user
+      if logged_in?
+        current_user.forget_me
+        cookies.delete :auth_token
+        reset_session
+        self.current_user = nil
+      end
+    end
+    
   end
   
 end

data/hobo_files/plugin/taglibs/core.dryml

@@ -3,9 +3,9 @@
 </def>
 
 
-<def tag="wrap" attrs="tag, when">
-  <% body = parameters.default %>
-  <%= when_ ? call_tag(tag, attributes, &proc { body }) : body %>
+<def tag="wrap" attrs="tag, when, parameter">
+  <% parameter ||= :default %>
+  <%= when_ ? send(tag, attributes, { parameter.to_sym => parameters[:default] }) : parameter.default %>
 </def>
 
     
@@ -15,8 +15,8 @@
 %></def>
 
 
-<def tag="repeat" attrs="even-odd, join"><%= 
-  if !this.blank? 
+<def tag="repeat" attrs="even-odd, join">
+  <if><%= 
     if even_odd
       map_this do
         klass = [attributes[:class], cycle("even", "odd")].compact.join(' ')
@@ -31,15 +31,13 @@
           res
         end.join(join)
       end
-    end
-  else
-    ""
-  end
-%></def>
+    end %>
+  </if>
+</def>
 
 
 <def tag="do"><%= parameters.default %></def>
-<def tag="with"><%= parameters.default %></def>
+<def tag="with" alias-of="do"/>
 
 
 <def tag="if" attrs="test"><%=