hobo 0.7.3 → 0.7.4

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

@@ -130,6 +130,8 @@ module Hobo
       empty = true
       if this.respond_to?(:each_index)
         this.each_index {|i| empty = false; new_field_context(i) { res << yield } }
+      elsif this.is_a?(Hash)
+        this.map {|key, value| empty = false; self.this_key = key; new_object_context(value) { res << yield } }
       else
         this.map {|e| empty = false; new_object_context(e) { res << yield } }
       end
@@ -346,7 +348,7 @@ module Hobo
       
       Hobo::ModelRouter.linkable?(klass, action, options.reverse_merge(:subsite => subsite))
     end
-   
+    
     
     # Convenience helper for the default app
     

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

@@ -26,11 +26,13 @@ module Hobo
       
       class << base
         alias_method_chain :has_many,   :defined_scopes
+        alias_method_chain :has_many,   :join_record_management
         alias_method_chain :belongs_to, :creator_metadata
         
         alias_method_chain :has_one, :new_method
         
         def inherited(klass)
+          super
           fields do
             Hobo.register_model(klass)
             field(klass.inheritance_column, :string)
@@ -92,7 +94,7 @@ module Hobo
       
       def user_find(user, *args)
         record = find(*args)
-        raise PermissionDeniedError unless Hobo.can_view?(user, self)
+        raise PermissionDeniedError unless Hobo.can_view?(user, record)
         record
       end
       
@@ -121,6 +123,11 @@ module Hobo
       end
       
       
+      def user_update(user, id, attributes={})
+        find(id).user_save_changes(user, attributes)
+      end
+      
+      
       def name_attribute
         @name_attribute ||= begin
                               cols = columns.*.name
@@ -232,7 +239,7 @@ module Hobo
       # FIXME: This should really be a method on AssociationReflection
       def reverse_reflection(association_name)
         refl = reflections[association_name]
-        return nil if refl.options[:conditions]
+        return nil if refl.options[:conditions] || refl.options[:polymorphic]
         
         reverse_macro = if refl.macro == :has_many
                           :belongs_to
@@ -277,9 +284,36 @@ module Hobo
         "#{name.underscore.pluralize}"
       end
       
+      
       def typed_id
         HoboFields.to_name(self) || name.underscore.gsub("/", "__")
       end
+      
+      
+      def manage_join_records(association)
+        through = reflections[association].through_reflection
+        source  = reflections[association].source_reflection
+        
+        method = "manage_join_records_for_#{association}"
+        after_save method
+        class_eval %{
+          def #{method}
+            current = #{through.name}.*.#{source.name}
+            to_delete = current - #{association}
+            to_add    = #{association} - current
+            #{through.klass.name}.delete_all(["#{through.primary_key_name} = ? and #{source.primary_key_name} in (?)", 
+                                             self.id, to_delete.*.id]) if to_delete.any?
+            to_add.each { |record| #{association} << record }
+          end
+        }
+      end
+      
+      def has_many_with_join_record_management(name, options={}, &b)
+        manage = options.delete(:managed)
+        returning (has_many_without_join_record_management(name, options, &b)) do 
+          manage_join_records(name) if manage
+        end
+      end
 
     end # --- of ClassMethods --- #
     
@@ -441,16 +475,12 @@ module Hobo
 
     
     def convert_type_for_mass_assignment(field_type, value)
-      if field_type.is_a?(ActiveRecord::Reflection::AssociationReflection) &&
-          field_type.macro.in?([:belongs_to, :has_one])
-        if value.is_a?(String) && value.starts_with?('@')
-          # TODO: This @foo_1 feature is rarely (never?) used - get rid of it
-          Hobo.object_from_dom_id(value[1..-1])
-        else
-          value
-        end
+      if field_type.is_a?(ActiveRecord::Reflection::AssociationReflection)
+        convert_associated_records_for_mass_assignment(field_type, value)
+        
       elsif !field_type.is_a?(Class)
         value
+        
       elsif field_type <= Date
         if value.is_a? Hash
           Date.new(*(%w{year month day}.map{|s| value[s].to_i}))
@@ -460,6 +490,7 @@ module Hobo
         else
           value
         end
+        
       elsif field_type <= Time
         if value.is_a? Hash
           Time.local(*(%w{year month day hour minute}.map{|s| value[s].to_i}))
@@ -468,13 +499,42 @@ module Hobo
         else
           value
         end
+        
       elsif field_type <= Hobo::Boolean
         (value.is_a?(String) && value.strip.downcase.in?(['0', 'false']) || value.blank?) ? false : true
+        
       else
         # primitive field
         value
       end
     end
+    
+    def convert_associated_records_for_mass_assignment(reflection, value)
+      if reflection.macro.in?([:belongs_to, :has_one])
+        if value.is_a?(String) && value.starts_with?('@')
+          # TODO: This @foo_1 feature is rarely (never?) used - get rid of it
+          Hobo.object_from_dom_id(value[1..-1])
+        else
+          value
+        end
+      elsif reflection.macro == :has_many
+        if reflection.klass.try.name_attribute
+          value.map do |x| 
+            if x.is_a?(String) 
+              reflection.klass[x] unless x.blank?
+            else
+              x
+            end
+          end.compact
+        else
+          value
+        end
+        
+      else
+        # unknown kind of accociation - no conversion
+        value
+      end
+    end
         
   end
   

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

@@ -138,9 +138,11 @@ module Hobo
           def destroy; hobo_destroy end if include_action?(:destroy) 
           
           def completions; hobo_completions end if include_action?(:completions)
+          
+          def reorder; hobo_reorder end if include_action?(:reorder) 
         end
 
-        collections.each { |c| def_collection_actions(c.to_sym) } 
+        collections.each { |c| def_collection_actions(c.to_sym) }
       end
       
       
@@ -205,7 +207,10 @@ module Hobo
       
       
       def available_auto_actions
-        READ_ONLY_ACTIONS + WRITE_ONLY_ACTIONS + FORM_ACTIONS + available_auto_collection_actions
+        (available_auto_read_actions +
+         available_auto_write_actions + 
+         FORM_ACTIONS + 
+         available_auto_collection_actions).uniq
       end
       
       
@@ -215,7 +220,11 @@ module Hobo
       
       
       def available_auto_write_actions
-        WRITE_ONLY_ACTIONS
+        if "position_column".in?(model.instance_methods)
+          WRITE_ONLY_ACTIONS + [:reorder]
+        else
+          WRITE_ONLY_ACTIONS
+        end
       end
       
       
@@ -229,38 +238,17 @@ module Hobo
     protected
     
     
-    def filter_by(*args)
-      filters = args.extract_options!
-      finder = args.first || self.model
-      
-      filters.each_pair do |scope, arg|
-        dont_filter = arg.is_a?(Array) ? arg.compact.empty? : arg.nil?
-        finder = finder.send(scope, arg) unless dont_filter
-      end
-      finder
-    end
-    
-    
-    def sort_fields(*args)
-      finder = args.first.is_a?(Class) ? args.shift : model
-      
+    def parse_sort_param(*sort_fields)
       _, desc, field = *params[:sort]._?.match(/^(-)?([a-z_]+(?:\.[a-z_]+)?)$/)
 
       if field
-        fields = args.*.to_s
-        if field.in?(fields)
+        if field.in?(sort_fields.*.to_s)
           @sort_field = field
           @sort_direction = desc ? "desc" : "asc"
         
-          table, column = if field =~ /^(.*)\.(.*)$/
-                            [$1.camelize.constantize.table_name, $2]
-                          else
-                            [finder.table_name, field]
-                          end
-          finder = finder.order("#{table}.#{column}", @sort_direction)
+          [@sort_field, @sort_direction]
         end
       end
-      finder
     end
     
     
@@ -301,7 +289,7 @@ module Hobo
         object_url(@this) || 
         
         # Then the show page of the 'owning' object if there is one
-        (@this.class.default_dependent_on && object_url(@this.class.default_dependent_on)) ||
+        (@this.class.default_dependent_on && object_url(@this.send(@this.class.default_dependent_on))) ||
         
         # Last try - the index page for this model
         object_url(@this.class) ||
@@ -322,8 +310,18 @@ module Hobo
       end
     end
     
+    
+    def request_requires_pagination?
+      # Internet explorer has a penchant for saying it would mostly
+      # like an image, if you clicked on an image link
+      request.format.in?(PAGINATE_FORMATS) || request.format.to_s =~ %r(image/)
+    end
+    
+    
     def find_or_paginate(finder, options)
-      do_pagination = options.delete(:paginate) != false && request.format.in?(PAGINATE_FORMATS)
+      options = options.reverse_merge(:paginate => request_requires_pagination?)
+      do_pagination = options.delete(:paginate)
+      
       if do_pagination && !finder.respond_to?(:paginate)
         do_pagination = false
         logger.warn "Hobo::ModelController: Pagination is not available. To enable, please install will_paginate or a duck-type compatible paginator"
@@ -419,7 +417,7 @@ module Hobo
     
     
     def update_response(in_place_edit_field=nil, &b)
-      flash[:notice] = "Changes to the #{@this.class.name.humanize.downcase} were saved" if !request.xhr? && valid?
+      flash[:notice] = "Changes to the #{@this.class.name.titleize.downcase} were saved" if !request.xhr? && valid?
       
       response_block(&b) or 
         if valid?
@@ -464,7 +462,7 @@ module Hobo
       response_block(&b) or
         respond_to do |wants|
           wants.html { redirect_to(:action => "index") }
-          wants.js   { hobo_ajax_response || render(:text => "") }
+          wants.js   { hobo_ajax_response || render(:nothing => true) }
         end
     end
  
@@ -498,6 +496,14 @@ module Hobo
     end
     
     
+    def hobo_reorder
+      params["#{model.name.underscore}_ordering"].each_with_index do |id, position|
+        model.user_update(current_user, id, :position => position+1)
+      end
+      hobo_ajax_response || render(:nothing => true)
+    end
+    
+    
     
     # --- Response helpers --- #
 
@@ -505,10 +511,19 @@ module Hobo
     def permission_denied(error)
       if respond_to? :permission_denied_response
         permission_denied_response
-      elsif render_tag("permission-denied-page", { }, :status => 403)
-        # job done
       else
-        render :text => "Permission Denied", :status => 403
+        respond_to do |wants|
+          wants.html do
+            if render_tag("permission-denied-page", { }, :status => 403)
+              # job done
+            else
+              render :text => "Permission Denied", :status => 403
+            end
+          end
+          wants.js do 
+            render :text => "Permission Denied", :status => 403
+          end
+        end
       end
     end
     

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

@@ -10,8 +10,10 @@ class ActionController::Routing::RouteSet
   
   # temporay hack -- reload assemble.rb whenever routes need reloading
   def reload_with_hobo_assemble
-    load "#{RAILS_ROOT}/app/assemble.rb" if File.exists? "#{RAILS_ROOT}/app/assemble.rb"
-    reload_without_hobo_assemble
+    if defined? ::ApplicationController
+      load "#{RAILS_ROOT}/app/assemble.rb" if File.exists? "#{RAILS_ROOT}/app/assemble.rb"
+      reload_without_hobo_assemble
+    end
   end
   alias_method_chain :reload, :hobo_assemble
   
@@ -131,6 +133,7 @@ module Hobo
         collection_routes
         web_method_routes
         show_action_routes
+        reorder_route
         user_routes if controller < Hobo::UserController
       end
     end
@@ -192,6 +195,11 @@ module Hobo
       end
     end
     
+    
+    def reorder_route
+      linkable_route("reorder_#{plural}", "#{plural}/reorder", 'reorder', :conditions => { :method => :post })
+    end
+    
         
     def user_routes
       prefix = plural == "users" ? "" : "#{singular}_"

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

@@ -143,4 +143,5 @@ module Hobo::RapidHelper
     
     names - through_collection_names
   end
+  
 end

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

@@ -13,6 +13,8 @@ module Hobo
     module ClassMethods
       
       include AutomaticScopes
+      
+      include ApplyScopes
     
       def defined_scopes
         @defined_scopes
@@ -29,6 +31,19 @@ module Hobo
       end
       
       
+      def apply_scopes(scopes)
+        result = self
+        scopes.each_pair do |scope, arg|
+          if arg.is_a?(Array)
+            result = result.send(scope, *arg) unless arg.first.blank?
+          else
+            result = result.send(scope, arg) unless arg.blank?
+          end
+        end
+        result
+      end
+            
+      
       def alias_scope(new_name, old_name)
         metaclass.send(:alias_method, new_name, old_name)
         defined_scopes[new_name] = defined_scopes[old_name]

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

@@ -0,0 +1,23 @@
+module Hobo
+  
+  module Scopes
+
+    module ApplyScopes
+      
+      def apply_scopes(scopes)
+        result = self
+        scopes.each_pair do |scope, arg|
+          if arg.is_a?(Array)
+            result = result.send(scope, *arg) unless arg.first.blank?
+          else
+            result = result.send(scope, arg) unless arg.blank?
+          end
+        end
+        result
+      end
+      
+    end
+    
+  end
+  
+end

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

@@ -18,9 +18,11 @@ module Hobo
                              target_class.send(scope_name).scope(:find)[:conditions]
                            end
         if scope_conditions && conditions_without_hobo_scopes
-          "#{conditions_without_hobo_scopes} AND #{scope_conditions}"
+          "(#{sanitize_sql conditions_without_hobo_scopes}) AND (#{sanitize_sql scope_conditions})"
+        elsif scope_conditions
+          sanitize_sql scope_conditions
         else
-          scope_conditions || conditions_without_hobo_scopes
+          conditions_without_hobo_scopes
         end
       end
       

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

@@ -152,17 +152,17 @@ module Hobo
           end
           
         # published
-        elsif (col = column($1)) && (col.type == :boolean)
+        elsif (col = column(name)) && (col.type == :boolean)
 
           def_scope do 
-            { :conditions => "#{column_sql(col)} = 1" }
+            { :conditions => "#{column_sql(col)}" }
           end
         
         # not_published
-        elsif (col = column($1)) && (col.type == :boolean)
+        elsif name =~ /^not_(.*)$/ && (col = column($1)) && (col.type == :boolean)
 
           def_scope do 
-            { :conditions => "#{column_sql(col)} <> 1" }
+            { :conditions => "NOT #{column_sql(col)}" }
           end
           
         # published_before(time)
@@ -200,11 +200,38 @@ module Hobo
             def_scope do |count|
               { :limit => count }
             end
-            
+
           when "order_by"
+            klass = @klass
             def_scope do |*args|
               field, asc = args
-              { :order => "#{field} #{asc._?.upcase}" }
+              type = klass.attr_type(field)
+              if type.respond_to?(:table_name) && (name = type.name_attribute)
+                include = field
+                colspec = "#{type.table_name}.#{name}"
+              else
+                colspec = "#{klass.table_name}.#{field}"
+              end
+              { :order => "#{colspec} #{asc._?.upcase}", :include => include }
+            end
+            
+
+          when "include"
+            def_scope do |inclusions|
+              { :include => inclusions }
+            end
+            
+          when "search"
+            def_scope do |query, *fields|
+              words = query.split
+              args = []              
+              word_queries = words.map do |word|
+                field_query = '(' + fields.map { |field| "(#{@klass.table_name}.#{field} like ?)" }.join(" OR ") + ')'
+                args += ["%#{word}%"] * fields.length
+                field_query
+              end
+              
+              { :conditions => [word_queries.join(" OR ")] + args }              
             end
             
           else
@@ -236,7 +263,7 @@ module Hobo
           
           "EXISTS (SELECT * FROM #{related.table_name} " + 
             "WHERE #{related.table_name}.#{foreign_key} = #{owner_primary_key} AND " +
-            "#{related.table_name}.#{related.primary_key} = ?"
+            "#{related.table_name}.#{related.primary_key} = ?)"
         end
       end