hobo 0.6.1 → 0.6.2

data/hobo_files/plugin/init.rb

@@ -45,6 +45,11 @@ class ActiveRecord::Base
   def self.hobo_model
     include Hobo::Model
   end
+  def self.hobo_user_model(login_attr=nil, &b)
+    include Hobo::Model
+    include Hobo::AuthenticatedUser
+    set_login_attr(login_attr, &b) if login_attr
+  end
 end
 
 # Default settings

data/hobo_files/plugin/lib/active_record/has_many_association.rb

@@ -40,7 +40,7 @@ module ActiveRecord::Associations
     
     def find_with_block(*args, &b)
       if b
-        options = extract_options_from_args!(args)
+        options = args.extract_options!
         args << options.merge(:conditions => member_class.conditions(&b))
         find_without_block(*args)
       else

data/hobo_files/plugin/lib/extensions.rb

@@ -132,10 +132,31 @@ class Object
   def class_def name, &blk
     class_eval { define_method name, &blk }
   end
+  
+  def _?()
+    self
+  end
 
 end
 
 
+class NilClass
+  def _?()
+    SafeNil.instance
+  end
+end
+
+
+class SafeNil
+  def self.instance
+    @instance ||= SafeNil.new
+  end
+  
+  def method_missing(*args, &b)
+    nil.send(*args, &b) rescue nil
+  end
+end
+
 
 module Enumerable
 
@@ -245,14 +266,14 @@ end
 class HashWithIndifferentAccess
   
   def -(keys)
-    res = {}
+    res = HashWithIndifferentAccess.new
     keys = keys.map {|k| k.is_a?(Symbol) ? k.to_s : k }
     each_pair { |k, v| res[k] = v unless k.in?(keys) }
     res
   end
   
   def &(keys)
-    res = {}
+    res = HashWithIndifferentAccess.new
     keys.each do |k|
       k = k.to_s if k.is_a?(Symbol)
       res[k] = self[k] if has_key?(k)
@@ -261,9 +282,9 @@ class HashWithIndifferentAccess
   end
   
   def partition_hash(keys=nil)
-    keys = keys.map {|k| k.is_a?(Symbol) ? k.to_s : k }
-    yes = {}
-    no = {}
+    keys = keys._?.map {|k| k.is_a?(Symbol) ? k.to_s : k }
+    yes = HashWithIndifferentAccess.new
+    no = HashWithIndifferentAccess.new
     each do |k,v|
       if block_given? ? yield(k,v) : keys.include?(k)
         yes[k] = v

data/hobo_files/plugin/lib/extensions/test_case.rb

@@ -31,7 +31,7 @@ class Test::Unit::TestCase
 
     def logs_in_as(user, password)
       @current_user = user
-      post login_url, :login => user.login, :password => password
+      post login_url(user), :login => user.login, :password => password
       assert_response :redirect, "#{user.login} failed to log in"
       get homepage_url
       assert_response :success

data/hobo_files/plugin/lib/hobo.rb

@@ -186,11 +186,12 @@ module Hobo
             end
             
             if controller < Hobo::UserController
-              map.named_route("#{web_name.singularize}_login", "#{web_name.singularize}_login",
+              prefix = web_name == "users" ? "" : "#{web_name.singularize}_"
+              map.named_route("#{web_name.singularize}_login", "#{prefix}login",
                               :controller => web_name, :action => 'login')
-              map.named_route("#{web_name.singularize}_logout", "#{web_name.singularize}_logout",
+              map.named_route("#{web_name.singularize}_logout", "#{prefix}logout",
                               :controller => web_name, :action => 'logout')
-              map.named_route("#{web_name.singularize}_signup", "#{web_name.singularize}_signup",
+              map.named_route("#{web_name.singularize}_signup", "#{prefix}signup",
                               :controller => web_name, :action => 'signup')
             end
           end
@@ -219,7 +220,7 @@ module Hobo
 
 
     def simple_has_many_association?(array_or_reflection)
-      refl = array_or_reflection.is_a?(Array) ? array_or_reflection.proxy_reflection : array_or_reflection
+      refl = array_or_reflection.respond_to?(:proxy_reflection) ? array_or_reflection.proxy_reflection : array_or_reflection
       return false unless refl.is_a?(ActiveRecord::Reflection::AssociationReflection)
       refl.macro == :has_many and
         (not refl.through_reflection) and
@@ -236,6 +237,24 @@ module Hobo
     end
     
     
+    def get_field_path(object, path)
+      path = if path.is_a? Array
+               path
+             elsif path.is_a? String
+               path.split('.')
+             else
+               [path]
+             end
+ 
+      field, parent = nil
+      path.each do |field|
+        parent = object
+        object = get_field(parent, field)
+      end
+      [parent, field, object]
+    end
+    
+    
     # --- Permissions --- #
 
 
@@ -265,7 +284,7 @@ module Hobo
       # has_many and polymorphic associations are not editable (for now)
       return false if refl and (refl.macro == :has_many or refl.options[:polymorphic] or refl.macro == :has_one)
       
-      if object.respond_to?(:editable_by?)
+      if object.has_hobo_method?(:editable_by?)
         check_permission(:edit, person, object, field.to_sym)
       else
         # Fake an edit test by setting the field in question to
@@ -288,7 +307,8 @@ module Hobo
                              Hobo::Undefined.new
                            end)
         rescue Hobo::UndefinedAccessError
-          raise HoboError, "#{object.class.name} does not support undefined assignements, define editable_by(user, field)"
+          raise HoboError, ("#{object.class.name}##{field} does not support undefined assignements, " + 
+                            "define editable_by?(user, field)")
         end
         
         begin
@@ -318,6 +338,12 @@ module Hobo
     # proxy, we don't want to loose the information that the object
     # belongs_to the proxy owner.
     def can_view?(person, object, field=nil)
+      # Field can be a dot separated path
+      if field && field.is_a?(String) && (path = field.split(".")).length > 1
+        _, _, object = get_field_path(object, path[0..-2])
+        field = path.last
+      end
+      
       if field
         field = field.to_sym if field.is_a? String
         return false if object.is_a?(ActiveRecord::Base) and object.class.never_show?(field)
@@ -341,10 +367,10 @@ module Hobo
     
     
     def can_call?(person, object, method)
-      return true if person.respond_to?(:super_user?) && person.super_user?
+      return true if person.has_hobo_method?(:super_user?) && person.super_user?
 
       m = "#{method}_callable_by?"
-      object.respond_to?(m) && object.send(m, person)
+      object.has_hobo_method?(m) && object.send(m, person)
     end 
     
     # --- end permissions -- #
@@ -368,7 +394,7 @@ module Hobo
 
 
     def check_permission(permission, person, object, *args)
-      return true if person.respond_to?(:super_user?) and person.super_user?
+      return true if person.has_hobo_method?(:super_user?) and person.super_user?
       
       return true if permission == :view && !(object.is_a?(ActiveRecord::Base) || object.is_a?(Hobo::CompositeModel))
 
@@ -379,7 +405,7 @@ module Hobo
                    when :edit;   :editable_by?
                    when :view;   :viewable_by?
                    end
-      p = if object.respond_to?(obj_method)
+      p = if object.has_hobo_method?(obj_method)
             begin
               object.send(obj_method, person, *args)
             rescue Hobo::UndefinedAccessError
@@ -389,7 +415,7 @@ module Hobo
             object.class.send(obj_method, person, *args)
           elsif !object.is_a?(Class) # No user fallback for class-level permissions
             person_method = "can_#{permission}?".to_sym
-            if person.respond_to?(person_method)
+            if person.has_hobo_method?(person_method)
               person.send(person_method, object, *args)
             else
               # The object does not define permissions - you can only view it

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

@@ -57,6 +57,7 @@ module Hobo
           validates_uniqueness_of attr, :case_sensitive => false
         end
       end
+      def login_attr; @login_attr; end
 
       # Authenticates a user by their login name and unencrypted password.  Returns the user or nil.
       def authenticate(login, password)
@@ -110,6 +111,10 @@ module Hobo
       save(false)
     end
 
+    def guest?
+      false
+    end
+
     protected
     # Before filter that encrypts the password before having it stored in the database.
     def encrypt_password
@@ -118,11 +123,11 @@ module Hobo
       self.crypted_password = encrypt(password)
     end
 
-    # Is a password required for login? (or do we have an empty password?
+    # Is a password required for login? (or do we have an empty password?)
     def password_required?
       (crypted_password.blank? && password != nil) || !password.blank?
     end
-
+    
   end
 
 end

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

@@ -6,7 +6,8 @@ module Hobo
     def logged_in?
       not current_user.guest?
     end
-
+    
+    
     # Check if the user is authorized.
     #
     # Override this method in your controllers if you want to restrict access
@@ -37,15 +38,15 @@ module Hobo
     #   skip_before_filter :login_required
     #
     def login_required(user_model=nil)
+      auth_model = user_model || UserController.user_models.first
       if current_user.guest? 
-        auth_model = user_model || UserController.user_models.first
         username, passwd = get_auth_data
-        self.current_user = auth_model.authenticate(username, passwd) || :false if username && passwd && auth_model
+        self.current_user = auth_model.authenticate(username, passwd) || nil if username && passwd && auth_model
       end
       if logged_in? && authorized? && (user_model.nil? || current_user.is_a?(user_model))
         true
       else
-        access_denied
+        access_denied(auth_model)
       end
     end
 
@@ -57,11 +58,11 @@ module Hobo
     # 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
+    def access_denied(user_model)
       respond_to do |accepts|
         accepts.html do
           store_location
-          redirect_to login_url
+          redirect_to(login_url(user_model))
         end
         accepts.xml do
           headers["Status"]           = "Unauthorized"

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

@@ -43,6 +43,11 @@ module Hobo
     end
     
     
+    def has_hobo_method?(name)
+      respond_to?(name)
+    end
+    
+    
     def compose_with(object, use=nil)
       self_classes = use ? use.models : self.class.models
       from_self = (self_classes - [object.class.name]).map {|classname| send(classname.underscore)}

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

@@ -83,8 +83,8 @@ module Hobo
 
     def render_tag(tag, options={}, render_options={})
       add_variables_to_assigns
-      render({:text => Hobo::Dryml.render_tag(@template, tag, options),
-               :layout => false }.merge(render_options))
+      text = Hobo::Dryml.render_tag(@template, tag, options)
+      text && render({:text => text, :layout => false }.merge(render_options))
     end
 
 
@@ -98,7 +98,7 @@ module Hobo
         dryml_renderer.send(tag, options.merge(:with => o))
       end.join
       
-      render :text => results + dryml_renderer.part_contexts_js
+      render :text => results + dryml_renderer.part_contexts_storage
     end
 
 
@@ -114,7 +114,7 @@ module Hobo
 
     # Store the given user in the session.
     def current_user=(new_user)
-      session[:user] = (new_user.nil? || new_user.is_a?(Symbol)) ? nil : new_user.typed_id
+      session[:user] = (new_user.nil? || new_user.guest?) ? nil : new_user.typed_id
       @current_user = new_user
     end
 

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

@@ -26,6 +26,7 @@ module Hobo::Dryml
   CORE_TAGLIB = "plugins/hobo/tags/core"
 
   @renderer_classes = {}
+  @tag_page_renderer_classes = {}
 
   class << self
 
@@ -33,7 +34,7 @@ module Hobo::Dryml
     
     def clear_cache
       @renderer_classes = {}
-      @tag_page_renderer_class = nil
+      @tag_page_renderer_classes = {}
     end
 
     def render_tag(view, tag, options={})
@@ -61,10 +62,9 @@ module Hobo::Dryml
                          end
 
       if page == EMPTY_PAGE
-        @tag_page_renderer_class =  make_renderer_class("", EMPTY_PAGE, local_names,
-                                                        [Hobo::HoboHelper, ApplicationHelper], included_taglibs) if
-          @tag_page_renderer_class.nil?
-        @tag_page_renderer_class.new(page, view)
+        @tag_page_renderer_classes[view.controller.class.name] ||= make_renderer_class("", EMPTY_PAGE, local_names,
+                                                        [Hobo::HoboHelper, ApplicationHelper], included_taglibs)
+        @tag_page_renderer_classes[view.controller.class.name].new(page, view)
       else
         page ||= view.instance_variable_get('@hobo_template_path')
         template_path = "app/views/" + page + ".dryml"

data/hobo_files/plugin/lib/hobo/dryml/part_context.rb

@@ -43,9 +43,9 @@ module Hobo
       
       def marshal(session)
         context = [@part_name, @this_id, @locals]
-        puts "STORE: " + context.inspect
         data = Base64.encode64(Marshal.dump(context)).strip
-        "#{data}--#{self.class.generate_digest(data, session)}"
+        digest = self.class.generate_digest(data, session)
+        "#{data}--#{digest}"
       end
         
 
@@ -66,11 +66,8 @@ module Hobo
           raise TamperedWithPartContext unless digest == generate_digest(data, session)
 
           part_name, this_id, locals = Marshal.load(Base64.decode64(data))
-          puts "RESTORE: " + [part_name, this_id, locals].inspect
 
-          x = [part_name, restore_part_this(this_id, this), restore_locals(locals)]
-          puts this_id, x.inspect
-          x
+          [part_name, restore_part_this(this_id, this), restore_locals(locals)]
         end
       
         def restore_part_this(this_id, this)

data/hobo_files/plugin/lib/hobo/dryml/template.rb

@@ -199,9 +199,10 @@ module Hobo::Dryml
 
     def set_element(el)
       assigns = el.attributes.map do |name, value|
-        dryml_exception(el, "invalid name in set") unless name =~ DRYML_NAME_RX
+        dryml_exception(el, "invalid name in set") unless name =~ /^#{DRYML_NAME}(\.#{DRYML_NAME})*$/
         "#{name} = #{attribute_to_ruby(value)}; "
       end.join
+      code = apply_control_attributes("begin; #{assigns}; end", el)
       "<% #{assigns}#{tag_newlines(el)} %>"
     end
     
@@ -373,7 +374,8 @@ module Hobo::Dryml
     
     def default_tagbody_element(el)
       name = el.attributes['for'] || @containing_tag_name
-      "<% #{name}_default_tagbody && #{name}_default_tagbody.call %>"
+      local_name = default_tagbody_name(name)
+      "<% #{local_name} && #{local_name}.call %>"
     end
 
 
@@ -464,7 +466,7 @@ module Hobo::Dryml
              else
                if is_param_default_call
                  # The tag is a proc available in a local variable
-                 "#{name}__default.call(#{attributes}, #{parameters})"
+                 "#{default_parameter_name(name)}.call(#{attributes}, #{parameters})"
                elsif (call_type = polymorphic_call_type(el))
                  "send(find_polymorphic_template(:#{name}, #{call_type}), #{attributes}, #{parameters})"
                else
@@ -532,9 +534,7 @@ module Hobo::Dryml
         dryml_exception("replace attribute must not have a value", el) if repl.has_rhs?
         dryml_exception("replace parameters must not have attributes", el) if el.attributes.length > 1
         
-        default_tag_name = "#{el.dryml_name}__default"
-
-        "proc {|#{default_tag_name}| new_context { %>#{children_to_erb(el)}<% } #{nl}}"
+        "proc {|#{default_parameter_name(el.dryml_name)}| new_context { %>#{children_to_erb(el)}<% } #{nl}}"
       else
         attributes = el.attributes.map do 
           |name, value| ":#{name} => #{attribute_to_ruby(value, el)}" unless name.in?(SPECIAL_ATTRIBUTES)
@@ -550,7 +550,7 @@ module Hobo::Dryml
             body = children_to_erb(el)
             @containing_tag_name = old
 
-            attributes << ":tagbody => proc {|#{el.dryml_name}_default_tagbody| new_context { %>#{body}<% } } " 
+            attributes << ":tagbody => proc {|#{default_tagbody_name(el.dryml_name)}| new_context { %>#{body}<% } } " 
           end
           "proc { {#{attributes * ', '}} #{nl}}"
         end
@@ -558,12 +558,13 @@ module Hobo::Dryml
     end
     
     
-    def default_tag_name(el)
-      if template_call?(el)
-        "Default#{el.dryml_name}"
-      else
-        "default_#{el.dryml_name}"
-      end
+    def default_parameter_name(name)
+      "_#{name}__default"
+    end
+    
+    
+    def default_tagbody_name(name)
+      "_#{name}_default_tagbody"
     end
     
     
@@ -589,7 +590,7 @@ module Hobo::Dryml
                "call_block_tag_parameter(#{to_call}, #{attributes}, all_parameters[#{param_name}])"
              else
                if is_param_default_call
-                 "#{name}__default.call_with_block(#{attributes})"
+                 "#{default_parameter_name(name)}.call_with_block(#{attributes})"
                elsif (call_type = polymorphic_call_type(el))
                  "send(find_polymorphic_tag(:#{name}, #{call_type}), #{attributes})"
                else
@@ -606,7 +607,7 @@ module Hobo::Dryml
         children = children_to_erb(el)
         @containing_tag_name = old
         
-        call_statement = "#{call} do |#{el.dryml_name}_default_tagbody| #{newlines}%>#{children}<% end"
+        call_statement = "#{call} do |#{default_tagbody_name(el.dryml_name)}| #{newlines}%>#{children}<% end"
         call = "<% _output(" + apply_control_attributes(call_statement, el) + ") %>"
         maybe_make_part_call(el, call)
       end