hobo 0.7.5 → 0.8

data/{hobo_files/plugin/lib → lib}/hobo/rapid_helper.rb

@@ -14,7 +14,7 @@ module Hobo::RapidHelper
 
   def options_for_hobo_ajax(options)
     js_options = rapid_build_callbacks(options)
-    
+
     js_options['asynchronous']  = false if options[:type] == :synchronous
     js_options['method']        = method_option_to_s(options[:method]) if options[:method]
     js_options['evalScripts']   = false if options[:script] == false
@@ -25,11 +25,11 @@ module Hobo::RapidHelper
     js_options['refocusForm']   = options[:refocus_form] if options.has_key?(:refocus_form)
     js_options['spinnerNextTo'] = js_str(options[:spinner_next_to]) if options.has_key?(:spinner_next_to)
     js_options['message']       = js_str(options[:message]) if options[:message]
-    
+
     js_options.empty? ? nil : options_for_javascript(js_options)
   end
 
-  
+
   def js_updates(updates)
     return '[]' unless updates
     updates = [updates] unless updates.is_a? Array
@@ -42,8 +42,8 @@ module Hobo::RapidHelper
     end
     "[#{updates * ', '}]"
   end
-  
-  
+
+
   def js_result_updates(updates)
     return '[]' unless updates
     updates = [updates] unless updates.is_a? Array
@@ -55,7 +55,7 @@ module Hobo::RapidHelper
   def ajax_updater(url_or_form, update, options={})
     options ||= {}
     options.symbolize_keys!
-    
+
     target = if url_or_form == :post_form
                target = "this"
              else
@@ -63,9 +63,9 @@ module Hobo::RapidHelper
              end
     js_options = options_for_hobo_ajax(options)
     args = [target, js_updates(update), js_options].compact
-    
+
     confirm = options.delete(:confirm)
-    
+
     func = "Hobo.ajaxRequest(#{args * ', '})"
     if confirm
       "if (confirm(#{js_str(confirm)})) { #{func} }"
@@ -91,26 +91,25 @@ module Hobo::RapidHelper
 
 
 
-  
-  def in_place_editor(behaviour_class, attributes)
+
+  def in_place_editor(attributes)
     blank_message = attributes.delete(:blank_message) || "(click to edit)"
 
-    attributes = add_classes(attributes, behaviour_class)
-    attributes.update(:hobo_model_id => dom_id,
-                      :hobo_blank_message => blank_message,
+    attributes = add_classes(attributes, behaviour_class, model_id_class(this_parent, this_field))
+    attributes.update(:hobo_blank_message => blank_message,
                       :if_blank => blank_message,
                       :no_wrapper => false)
 
     update = attributes.delete(:update)
-    attributes[:hobo_update] = update if update 
-    
+    attributes[:hobo_update] = update if update
+
     view(attributes)
   end
-    
-  
+
+
 
   AJAX_CALLBACKS = [ :before, :success, :failure, :complete ]
-  
+
   AJAX_ATTRS = AJAX_CALLBACKS + [ :type, :method,
                                   :script, :form, :params, :confirm, :message,
                                   :reset_form, :refocus_form, :result_update, :spinner_next_to ]
@@ -121,27 +120,35 @@ module Hobo::RapidHelper
 
 
   def through_collection_names(object=this)
-    object.class.reflections.values.select do |refl| 
+    object.class.reflections.values.select do |refl|
       refl.macro == :has_many && refl.options[:through]
     end.map {|x| x.options[:through]}
   end
 
 
   def primary_collection_name(object=this)
-    dependent_collection_names = object.class.reflections.values.select do |refl| 
+    dependent_collection_names = object.class.reflections.values.select do |refl|
       refl.macro == :has_many && refl.options[:dependent]
     end.*.name
-    
+
     (dependent_collection_names - through_collection_names(object)).first
   end
 
 
   def non_through_collections(object=this)
-    names = object.class.reflections.values.select do |refl| 
+    names = object.class.reflections.values.select do |refl|
       refl.macro == :has_many
     end.*.name
-    
+
     names - through_collection_names
   end
   
+  def standard_fields(model, include_timestamps=false)
+    fields = model.attr_order.*.to_s & model.content_columns.*.name
+    fields -= %w{created_at updated_at created_on updated_on deleted_at} unless include_timestamps
+    debugger if model == User
+    fields.reject! { |f| model.never_show? f }
+    fields
+  end
+
 end

data/{hobo_files/plugin/lib → lib}/hobo/scopes.rb

@@ -1,67 +1,19 @@
 module Hobo
-  
+
   module Scopes
-    
+
     def self.included_in_class(base)
       base.extend(ClassMethods)
-
-      class << base
-        alias_method_chain :has_many, :defined_scopes
-      end
     end
-    
+
     module ClassMethods
-      
+
       include AutomaticScopes
-      
-      include ApplyScopes
-    
-      def defined_scopes
-        @defined_scopes ||= {}
-      end
-      
-      
-      def def_scope(name, scope=nil, &block)
-        defined_scopes[name.to_sym] = block || scope
-        
-        meta_def(name) do |*args|
-          ScopedProxy.new(self, block ? block.call(*args) : scope)
-        end
-      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]
-      end
-      
-      
-      def has_many_with_defined_scopes(name, options={}, &block)
-        if options.has_key?(:extend) || block
-          # Normal has_many
-          has_many_without_defined_scopes(name, options, &block)
-        else
-          options[:extend] = Hobo::Scopes::DefinedScopeProxyExtender
-          has_many_without_defined_scopes(name, options, &block)
-        end
-      end
-      
+      include ApplyScopes
 
       # --- monkey-patches to allow :scope key on has_many, has_one and belongs_to ---
-   
+
       def create_has_many_reflection(association_id, options, &extension)
         options.assert_valid_keys(
           :class_name, :table_name, :foreign_key,
@@ -69,44 +21,46 @@ module Hobo
           :select, :conditions, :include, :order, :group, :limit, :offset,
           :as, :through, :source, :source_type,
           :uniq,
-          :finder_sql, :counter_sql, 
-          :before_add, :after_add, :before_remove, :after_remove, 
+          :finder_sql, :counter_sql,
+          :before_add, :after_add, :before_remove, :after_remove,
           :extend,
           :scope
-        ) 
-     
+        )
+
         options[:extend] = create_extension_modules(association_id, extension, options[:extend]) if block_given?
-     
+
         create_reflection(:has_many, association_id, options, self)
       end
-     
+
       def create_has_one_reflection(association_id, options)
         options.assert_valid_keys(
           :class_name, :foreign_key, :remote, :conditions, :order, :include, :dependent, :counter_cache, :extend, :as, :scope
         )
-     
+
         create_reflection(:has_one, association_id, options, self)
       end
-     
+
       def create_belongs_to_reflection(association_id, options)
         options.assert_valid_keys(
-          :class_name, :foreign_key, :foreign_type, :remote, :conditions, :order, :include, :dependent, 
+          :class_name, :foreign_key, :foreign_type, :remote, :conditions, :order, :include, :dependent,
           :counter_cache, :extend, :polymorphic, :scope
         )
-        
+
         reflection = create_reflection(:belongs_to, association_id, options, self)
-     
+
         if options[:polymorphic]
           reflection.options[:foreign_type] ||= reflection.class_name.underscore + "_type"
         end
-     
+
         reflection
       end
 
     end
-  
+
   end
-  
+
 end
 
 ActiveRecord::Associations::AssociationProxy.send(:include, Hobo::Scopes::AssociationProxyExtensions)
+ActiveRecord::Associations::HasManyThroughAssociation.send(:include, Hobo::Scopes::HasManyThroughAssociationExtensions)
+require "hobo/scopes/named_scope_extensions"

data/{hobo_files/plugin/lib → lib}/hobo/scopes/apply_scopes.rb

@@ -1,9 +1,9 @@
 module Hobo
-  
+
   module Scopes
 
     module ApplyScopes
-      
+
       def apply_scopes(scopes)
         result = self
         scopes.each_pair do |scope, arg|
@@ -15,9 +15,9 @@ module Hobo
         end
         result
       end
-      
+
     end
-    
+
   end
-  
+
 end

data/lib/hobo/scopes/association_proxy_extensions.rb

@@ -0,0 +1,47 @@
+# Add support for :scope => :my_scope to has_many and belongs_to
+
+module Hobo
+
+  module Scopes
+
+    AssociationProxyExtensions = classy_module do
+
+      def scope_conditions(reflection)
+        scope_name = reflection.options[:scope] and
+          target_class = reflection.klass and
+          target_class.send(scope_name).scope(:find)[:conditions]
+      end
+
+
+      def combine_conditions(*conditions)
+        parts = conditions.compact.map { |c| "(#{sanitize_sql c})" }
+        parts.empty? ? nil : parts.join(" AND ")
+      end
+
+
+      def conditions_with_hobo_scopes
+        scope_conditions = self.scope_conditions(@reflection)
+        unscoped_conditions = conditions_without_hobo_scopes
+        combine_conditions(scope_conditions, unscoped_conditions)
+      end
+
+      alias_method_chain :conditions, :hobo_scopes
+
+    end
+
+    HasManyThroughAssociationExtensions = classy_module do
+
+      def sql_conditions_with_hobo_scopes
+        scope_conditions         = self.scope_conditions(@reflection)
+        through_scope_conditions = self.scope_conditions(@reflection.through_reflection)
+        unscoped_conditions = sql_conditions_without_hobo_scopes
+        combine_conditions(scope_conditions, through_scope_conditions, unscoped_conditions)
+      end
+
+      alias_method_chain :sql_conditions, :hobo_scopes
+
+    end
+
+  end
+
+end

data/{hobo_files/plugin/lib → lib}/hobo/scopes/automatic_scopes.rb

@@ -1,37 +1,39 @@
 module Hobo
-  
+
   module Scopes
-    
+
     module AutomaticScopes
-      
+
       def create_automatic_scope(name)
         ScopeBuilder.new(self, name).create_scope
-      rescue ActiveRecord::StatementInvalid
+      rescue ActiveRecord::StatementInvalid => e
         # Problem with the database? Don't try to create automatic scopes
+        ActiveRecord::Base.logger.warn "!! Database exception during hobo auto-scope creation -- continuing automatic scopes"
+        ActiveRecord::Base.logger.warn "!! #{e.to_s}"
         false
       end
-      
+
     end
-    
+
     # The methods on this module add scopes to the given class
     class ScopeBuilder
-      
+
       def initialize(klass, name)
         @klass = klass
         @name  = name.to_s
       end
-      
+
       attr_reader :name
-      
+
       def create_scope
         matched_scope = true
-        
-        
+
+
         # --- Association Queries --- #
-        
+
         # with_players(player1, player2)
         if name =~ /^with_(.*)/ && (refl = reflection($1))
-          
+
           def_scope do |*records|
             records = records.flatten.compact.map {|r| find_if_named(refl, r) }
             exists_sql = ([exists_sql_condition(refl)] * records.length).join(" AND ")
@@ -40,16 +42,16 @@ module Hobo
 
         # with_player(a_player)
         elsif name =~ /^with_(.*)/ && (refl = reflection($1.pluralize))
-          
+
           exists_sql = exists_sql_condition(refl)
           def_scope do |record|
             record = find_if_named(refl, record)
             { :conditions => [exists_sql, record] }
           end
-          
+
         # without_players(player1, player2)
         elsif name =~ /^without_(.*)/ && (refl = reflection($1))
-          
+
           def_scope do |*records|
             records = records.flatten.compact.map {|r| find_if_named(refl, r) }
             exists_sql = ([exists_sql_condition(refl)] * records.length).join(" AND ")
@@ -58,7 +60,7 @@ module Hobo
 
         # without_player(a_player)
         elsif name =~ /^without_(.*)/ && (refl = reflection($1.pluralize))
-          
+
           exists_sql = exists_sql_condition(refl)
           def_scope do |record|
             record = find_if_named(refl, record)
@@ -67,7 +69,7 @@ module Hobo
 
         # team_is(a_team)
         elsif name =~ /^(.*)_is$/ && (refl = reflection($1)) && refl.macro.in?([:has_one, :belongs_to])
-          
+
           if refl.options[:polymorphic]
             def_scope do |record|
               record = find_if_named(refl, record)
@@ -79,10 +81,10 @@ module Hobo
               { :conditions => ["#{foreign_key_column refl} = ?", record] }
             end
           end
-            
-        # team_is(a_team)
+
+        # team_is_not(a_team)
         elsif name =~ /^(.*)_is_not$/ && (refl = reflection($1)) && refl.macro.in?([:has_one, :belongs_to])
-          
+
           if refl.options[:polymorphic]
             def_scope do |record|
               record = find_if_named(refl, record)
@@ -94,87 +96,83 @@ module Hobo
               { :conditions => ["#{foreign_key_column refl} <> ?", record] }
             end
           end
-          
-        
+
+
         # --- Column Queries --- #
-          
+
         # name_is(str)
         elsif name =~ /^(.*)_is$/ && (col = column($1))
 
           def_scope do |str|
             { :conditions => ["#{column_sql(col)} = ?", str] }
           end
-          
+
         # name_is_not(str)
         elsif name =~ /^(.*)_is_not$/ && (col = column($1))
 
           def_scope do |str|
             { :conditions => ["#{column_sql(col)} <> ?", str] }
           end
-          
+
         # name_contains(str)
         elsif name =~ /^(.*)_contains$/ && (col = column($1))
 
           def_scope do |str|
             { :conditions => ["#{column_sql(col)} LIKE ?", "%#{str}%"] }
           end
-          
+
         # name_does_not_contain
         elsif name =~ /^(.*)_does_not_contain$/ && (col = column($1))
 
           def_scope do |str|
             { :conditions => ["#{column_sql(col)} NOT LIKE ?", "%#{str}%"] }
           end
-          
+
         # name_starts(str)
-        elsif name =~ /^(.*)_contains$/ && (col = column($1))
+        elsif name =~ /^(.*)_starts$/ && (col = column($1))
 
           def_scope do |str|
             { :conditions => ["#{column_sql(col)} LIKE ?", "#{str}%"] }
           end
-          
+
         # name_does_not_start
-        elsif name =~ /^(.*)_does_not_contain$/ && (col = column($1))
+        elsif name =~ /^(.*)_does_not_start$/ && (col = column($1))
 
           def_scope do |str|
             { :conditions => ["#{column_sql(col)} NOT LIKE ?", "#{str}%"] }
           end
-          
+
         # name_ends(str)
-        elsif name =~ /^(.*)_contains$/ && (col = column($1))
+        elsif name =~ /^(.*)_ends$/ && (col = column($1))
 
           def_scope do |str|
             { :conditions => ["#{column_sql(col)} LIKE ?", "%#{str}"] }
           end
-          
+
         # name_does_not_end(str)
-        elsif name =~ /^(.*)_does_not_contain$/ && (col = column($1))
+        elsif name =~ /^(.*)_does_not_end$/ && (col = column($1))
 
           def_scope do |str|
             { :conditions => ["#{column_sql(col)} NOT LIKE ?", "%#{str}"] }
           end
-          
-        # published
+
+        # published (a boolean column)
         elsif (col = column(name)) && (col.type == :boolean)
 
-          def_scope do 
-            { :conditions => "#{column_sql(col)}" }
-          end
-        
+          def_scope :conditions => ["#{column_sql(col)} = ?", true]
+
         # not_published
         elsif name =~ /^not_(.*)$/ && (col = column($1)) && (col.type == :boolean)
 
-          def_scope do 
-            { :conditions => "NOT #{column_sql(col)}" }
-          end
-          
+          def_scope :conditions => ["#{column_sql(col)} <> ?", true]
+
         # published_before(time)
         elsif name =~ /^(.*)_before$/ && (col = column("#{$1}_at")) && col.type.in?([:date, :datetime, :time, :timestamp])
 
           def_scope do |time|
             { :conditions => ["#{column_sql(col)} < ?", time] }
           end
-        
+
         # published_after(time)
         elsif name =~ /^(.*)_after$/ && (col = column("#{$1}_at")) && col.type.in?([:date, :datetime, :time, :timestamp])
 
@@ -186,19 +184,46 @@ module Hobo
         elsif name =~ /^(.*)_between$/ && (col = column("#{$1}_at")) && col.type.in?([:date, :datetime, :time, :timestamp])
 
           def_scope do |time1, time2|
-            { :conditions => ["#{column_sql(col)} >= ? AND #{column_sql(col)} =< ?", time1, time2] }
+            { :conditions => ["#{column_sql(col)} >= ? AND #{column_sql(col)} <= ?", time1, time2] }
+          end
+
+         # active (a lifecycle state)
+        elsif @klass.has_lifecycle? && name.in?(@klass::Lifecycle.state_names)
+
+          if @klass::Lifecycle.state_names.length == 1
+            # nothing to check for - create a dummy scope
+            def_scope :conditions => ""
+            true
+          else
+            def_scope :conditions => ["#{@klass.table_name}.#{@klass::Lifecycle.state_field} = ?", name]
+          end
+
+        # self is / is not
+        elsif name == "is"
+
+          def_scope do |record|
+            { :conditions => ["#{@klass.table_name}.#{@klass.primary_key} = ?", record] }
+          end
+
+        elsif name == "is_not"
+
+          def_scope do |record|
+            { :conditions => ["#{@klass.table_name}.#{@klass.primary_key} <> ?", record] }
           end
 
         else
-        
+
           case name
             
+          when "by_most_recent"
+            def_scope :order => "#{@klass.table_name}.created_at DESC"
+
           when "recent"
             def_scope do |*args|
               count = args.first || 3
               { :limit => count, :order => "#{@klass.table_name}.created_at DESC" }
             end
-            
+
           when "limit"
             def_scope do |count|
               { :limit => count }
@@ -217,40 +242,40 @@ module Hobo
               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 = []              
+              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 }              
+
+              { :conditions => [word_queries.join(" AND ")] + args }
             end
-            
+
           else
             matched_scope = false
           end
-          
+
         end
         matched_scope
       end
-      
-      
+
+
       def column_sql(column)
         "#{@klass.table_name}.#{column.name}"
       end
-      
-      
+
+
       def exists_sql_condition(reflection)
         owner = @klass
         owner_primary_key = "#{owner.table_name}.#{owner.primary_key}"
@@ -258,55 +283,55 @@ module Hobo
           join_table   = reflection.through_reflection.klass.table_name
           source_fkey  = reflection.source_reflection.primary_key_name
           owner_fkey   = reflection.through_reflection.primary_key_name
-          "EXISTS (SELECT * FROM #{join_table} " + 
+          "EXISTS (SELECT * FROM #{join_table} " +
             "WHERE #{join_table}.#{source_fkey} = ? AND #{join_table}.#{owner_fkey} = #{owner_primary_key})"
         else
           related     = reflection.klass
           foreign_key = reflection.primary_key_name
-          
-          "EXISTS (SELECT * FROM #{related.table_name} " + 
+
+          "EXISTS (SELECT * FROM #{related.table_name} " +
             "WHERE #{related.table_name}.#{foreign_key} = #{owner_primary_key} AND " +
             "#{related.table_name}.#{related.primary_key} = ?)"
         end
       end
-              
-      
+
+
       def find_if_named(reflection, string_or_record)
         if string_or_record.is_a?(String)
           name = string_or_record
           reflection.klass.named(name)
         else
-          string_or_record
+          string_or_record # a record
         end
       end
-      
-      
+
+
       def column(name)
         @klass.column(name)
       end
-      
-      
+
+
       def reflection(name)
         @klass.reflections[name.to_sym]
       end
-      
-      
+
+
       def def_scope(options={}, &block)
-        @klass.send(:def_scope, name, options, &block)
+        @klass.named_scope(name.to_sym, block || options)
       end
 
-      
+
       def primary_key_column(refl)
         "#{refl.klass.table_name}.#{refl.klass.primary_key}"
       end
-      
-      
+
+
       def foreign_key_column(refl)
         "#{@klass.table_name}.#{refl.primary_key_name}"
       end
-            
+
     end
-    
+
   end
-  
+
 end