hobo 0.7.2 → 0.7.3

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

@@ -2,9 +2,19 @@ class ActionController::Routing::RouteSet
   # Monkey patch this method so routes are reloaded on *every*
   # request. Without this Rails checks the mtime of config/routes.rb
   # which doesn't take into account Hobo's auto routing
-  def reload
-    load!
+  #def reload
+  #  # TODO: This can get slow - quicker to stat routes.rb and the
+  #  # controllers and only do a load if there's been a change
+  #  load!
+  #end
+  
+  # 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
   end
+  alias_method_chain :reload, :hobo_assemble
+  
 end
 
 module Hobo
@@ -16,19 +26,27 @@ module Hobo
     class << self
       
       def reset_linkables
-        @linkable = Hash.new {|h, k| h[k] = Hash.new {|h, k| h[k] = {} } }
+        @linkable =Set.new
+      end
+      
+      def linkable_key(klass, action, options)
+        opts = options.map { |k, v| "#{k}=#{v}" unless v.blank? }.compact.join(',')
+        "#{klass.name}/#{action}/#{opts}"
       end
       
-      def linkable(subsite, klass, action)
-        @linkable[subsite][klass.name][action] = true
+      def linkable!(klass, action, options={})
+        options[:method] ||= :get
+        @linkable << linkable_key(klass, action, options)
       end
       
-      def linkable?(subsite, klass, action)
-        @linkable[subsite][klass.name][action]
+      def linkable?(klass, action, options={})
+        options[:method] ||= :get
+        @linkable.member? linkable_key(klass, action, options)
       end
       
       def add_routes(map)
         reset_linkables
+        
         begin 
           ActiveRecord::Base.connection.reconnect! unless ActiveRecord::Base.connection.active?
         rescue
@@ -45,11 +63,15 @@ module Hobo
         # Any directory inside app/controllers defines a subsite
         subsites = Dir["#{APP_ROOT}/controllers/*"].map { |f| File.basename(f) if File.directory?(f) }.compact
         subsites.each { |subsite| add_routes_for(map, subsite) }
+        
+        add_developer_routes(map) if Hobo.developer_features?
       end
       
       
       def add_routes_for(map, subsite)
         module_name = subsite._?.camelize
+        
+        # FIXME: This should go directly to the controllers, not load the models first.
         Hobo.models.each do |model|
           controller_name = "#{model.name.pluralize}Controller"
           is_defined = if subsite 
@@ -59,12 +81,18 @@ module Hobo
                        end
           controller_filename = File.join(*["#{APP_ROOT}/controllers", subsite, "#{controller_name.underscore}.rb"].compact) 
           if is_defined || File.exists?(controller_filename)
-            owner_module = subsite ? module_name.constantize : Object
-            controller = owner_module.const_get(controller_name)
+            controller = (subsite ? "#{module_name}::#{controller_name}" : controller_name).constantize
             ModelRouter.new(map, model, controller, subsite)
           end
         end
       end
+      
+      
+      def add_developer_routes(map)
+        map.dryml_support "dryml/:action", :controller => "hobo/dryml/dryml_support"
+        map.dev_support   "dev/:action",   :controller => "hobo/dev"
+      end
+      
     end
     
 
@@ -111,6 +139,9 @@ module Hobo
     def resource_routes
       # We re-implement resource routing - routes are not created for
       # actions that the controller does not provide
+      
+      # FIX ME -- what about routes with formats (e.g. .xml)?
+      
       linkable_route(plural, plural, :index, :conditions => { :method => :get })
                                                                                                                           
       linkable_route("new_#{singular}",  "#{plural}/new",      :new,  :conditions => { :method => :get })  
@@ -126,49 +157,47 @@ module Hobo
     
     def collection_routes
       controller.collections.each do |collection|
-        new_method = Hobo.simple_has_many_association?(model.reflections[collection])
-        named_route("#{singular}_#{collection}",
-                    "#{plural}/:id/#{collection}",
-                    :action => "show_#{collection}",
-                    :conditions => { :method => :get })
+        linkable_route("#{singular}_#{collection}",
+                       "#{plural}/:id/#{collection}",
+                       collection.to_s,
+                       :conditions => { :method => :get })
 
-        named_route("new_#{singular}_#{collection.to_s.singularize}",
-                    "#{plural}/:id/#{collection}/new",
-                    :action => "new_#{collection.to_s.singularize}",
-                    :conditions => { :method => :get }) if new_method
+        if Hobo.simple_has_many_association?(model.reflections[collection])
+          linkable_route("new_#{singular}_#{collection.to_s.singularize}",
+                         "#{plural}/:id/#{collection}/new",
+                         "new_#{collection.to_s.singularize}",
+                         :conditions => { :method => :get }) 
+        end
       end
     end
     
     
     def web_method_routes
       controller.web_methods.each do |method|
-        named_route("#{plural.singularize}_#{method}", "#{plural}/:id/#{method}",
-                    :action => method.to_s, :conditions => { :method => :post })
+        linkable_route("#{plural.singularize}_#{method}", "#{plural}/:id/#{method}", method.to_s, :conditions => { :method => :post })
       end
     end
     
     
     def index_action_routes
       controller.index_actions.each do |view|
-        named_route("#{view}_#{plural}", "#{plural}/#{view}",
-                    :action => view.to_s, :conditions => { :method => :get })
+        linkable_route("#{view}_#{plural}", "#{plural}/#{view}", view.to_s, :conditions => { :method => :get })
       end
     end
 
     
     def show_action_routes
       controller.show_actions.each do |view|
-        named_route("#{plural.singularize}_#{view}", "#{plural}/:id/#{view}",
-                    :action => view.to_s, :conditions => { :method => :get })
+        linkable_route("#{plural.singularize}_#{view}", "#{plural}/:id/#{view}", view.to_s, :conditions => { :method => :get })
       end
     end
     
         
     def user_routes
       prefix = plural == "users" ? "" : "#{singular}_"
-      named_route("#{singular}_login",  "#{prefix}login",  :action => 'login')
-      named_route("#{singular}_logout", "#{prefix}logout", :action => 'logout')
-      named_route("#{singular}_signup", "#{prefix}signup", :action => 'signup')
+      linkable_route("#{singular}_login",  "#{prefix}login",  'login')
+      linkable_route("#{singular}_logout", "#{prefix}logout", 'logout')
+      linkable_route("#{singular}_signup", "#{prefix}signup", 'signup')
     end
     
     
@@ -187,8 +216,12 @@ module Hobo
     end
     
     
-    def linkable_route(name, route, action, options)
-      named_route(name, route, options.merge(:action => action.to_s)) and self.class.linkable(subsite, model, action)
+    def linkable_route(name, route, action, options={})
+      named_route(name, route, options.merge(:action => action.to_s)) and 
+        begin
+          linkable_options = { :method => options[:conditions]._?[:method], :subsite => subsite }
+          self.class.linkable!(model, action, linkable_options)
+        end
     end
     
    

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

@@ -1,8 +1,20 @@
 module Hobo::RapidHelper
 
-  def options_for_hobo_ajax(options)
-    js_options = build_callbacks(options)
+  def rapid_build_callbacks(options)
+    callbacks = {}
+    options.each do |callback, code|
+      if AJAX_CALLBACKS.include?(callback.to_sym)
+        name = 'on' + callback.to_s.capitalize
+        callbacks[name] = "function(request){#{code}}"
+      end
+    end
+    callbacks
+  end
+
 
+  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
@@ -11,7 +23,8 @@ module Hobo::RapidHelper
     js_options['resultUpdate']  = js_result_updates(options[:result_update]) if options[:result_update]
     js_options['resetForm']     = options[:reset_form] if options.has_key?(:reset_form)
     js_options['refocusForm']   = options[:refocus_form] if options.has_key?(:refocus_form)
-    js_options['spinnerNextTo'] = options[:spinner_next_to] if options.has_key?(:spinner_next_to)
+    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
@@ -39,7 +52,7 @@ module Hobo::RapidHelper
   end
 
 
-  def ajax_updater(url_or_form, message, update, options={})
+  def ajax_updater(url_or_form, update, options={})
     options ||= {}
     options.symbolize_keys!
     
@@ -49,7 +62,7 @@ module Hobo::RapidHelper
                js_str(url_or_form)
              end
     js_options = options_for_hobo_ajax(options)
-    args = [target, js_str(message || "..."), js_updates(update), js_options].compact
+    args = [target, js_updates(update), js_options].compact
     
     confirm = options.delete(:confirm)
     
@@ -83,7 +96,7 @@ module Hobo::RapidHelper
     blank_message = attributes.delete(:blank_message) || "(click to edit)"
 
     attributes = add_classes(attributes, behaviour_class)
-    attributes.update(:hobo_model_id => this_field_dom_id,
+    attributes.update(:hobo_model_id => dom_id,
                       :hobo_blank_message => blank_message,
                       :if_blank => blank_message,
                       :no_wrapper => false)
@@ -96,12 +109,38 @@ module Hobo::RapidHelper
     
   
 
-  AJAX_ATTRS = [:before, :success, :failure, :complete, :type, :method,
-                :script, :form, :params, :confirm,
-                :reset_form, :refocus_form, :result_update, :spinner_next_to]
+  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 ]
 
 
   def editor_class
   end
 
+
+  def through_collection_names(object=this)
+    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| 
+      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| 
+      refl.macro == :has_many
+    end.*.name
+    
+    names - through_collection_names
+  end
 end

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

@@ -0,0 +1,98 @@
+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
+    
+      def defined_scopes
+        @defined_scopes
+      end
+      
+      
+      def def_scope(name, scope=nil, &block)
+        @defined_scopes ||= {}
+        @defined_scopes[name.to_sym] = block || scope
+        
+        meta_def(name) do |*args|
+          ScopedProxy.new(self, block ? block.call(*args) : scope)
+        end
+      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
+      
+
+      # --- 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,
+          :dependent,
+          :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, 
+          :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, 
+          :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)

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

@@ -0,0 +1,31 @@
+# Add support for :scope => :my_scope to has_many and :belongs_to
+
+module Hobo
+  
+  module Scopes
+    
+    module AssociationProxyExtensions
+      
+      def self.included(base)
+        base.class_eval do 
+          alias_method_chain :conditions, :hobo_scopes
+        end
+      end
+      
+      def conditions_with_hobo_scopes
+        scope_conditions = if (scope_name = @reflection.options[:scope])
+                             target_class = @reflection.klass
+                             target_class.send(scope_name).scope(:find)[:conditions]
+                           end
+        if scope_conditions && conditions_without_hobo_scopes
+          "#{conditions_without_hobo_scopes} AND #{scope_conditions}"
+        else
+          scope_conditions || conditions_without_hobo_scopes
+        end
+      end
+      
+    end
+      
+  end
+  
+end

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

@@ -0,0 +1,282 @@
+module Hobo
+  
+  module Scopes
+    
+    module AutomaticScopes
+      
+      def create_automatic_scope(name)
+        ScopeBuilder.new(self, name).create_scope
+      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 ")
+            { :conditions => [exists_sql] + records }
+          end
+
+        # 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 ")
+            { :conditions => ["NOT (#{exists_sql})"] + records }
+          end
+
+        # 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)
+            { :conditions => ["NOT #{exists_sql}", record] }
+          end
+
+        # 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)
+              { :conditions => ["#{foreign_key_column refl} = ? AND #{$1}_type = ?", record, record.class.name] }
+            end
+          else
+            def_scope do |record|
+              record = find_if_named(refl, record)
+              { :conditions => ["#{foreign_key_column refl} = ?", record] }
+            end
+          end
+            
+        # team_is(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)
+              { :conditions => ["#{foreign_key_column refl} <> ? OR #{name}_type <> ?", record, record.class.name] }
+            end
+          else
+            def_scope do |record|
+              record = find_if_named(refl, record)
+              { :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))
+
+          def_scope do |str|
+            { :conditions => ["#{column_sql(col)} LIKE ?", "#{str}%"] }
+          end
+          
+        # name_does_not_start
+        elsif name =~ /^(.*)_does_not_contain$/ && (col = column($1))
+
+          def_scope do |str|
+            { :conditions => ["#{column_sql(col)} NOT LIKE ?", "#{str}%"] }
+          end
+          
+        # name_ends(str)
+        elsif name =~ /^(.*)_contains$/ && (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))
+
+          def_scope do |str|
+            { :conditions => ["#{column_sql(col)} NOT LIKE ?", "%#{str}"] }
+          end
+          
+        # published
+        elsif (col = column($1)) && (col.type == :boolean)
+
+          def_scope do 
+            { :conditions => "#{column_sql(col)} = 1" }
+          end
+        
+        # not_published
+        elsif (col = column($1)) && (col.type == :boolean)
+
+          def_scope do 
+            { :conditions => "#{column_sql(col)} <> 1" }
+          end
+          
+        # 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])
+
+          def_scope do |time|
+            { :conditions => ["#{column_sql(col)} > ?", time] }
+          end
+
+        # published_between(time1, time2)
+        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] }
+          end
+
+        else
+        
+          case name
+            
+          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 }
+            end
+            
+          when "order_by"
+            def_scope do |*args|
+              field, asc = args
+              { :order => "#{field} #{asc._?.upcase}" }
+            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}"
+        if reflection.options[:through]
+          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} " + 
+            "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} " + 
+            "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
+        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)
+      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