hobo 0.7.5 → 0.8

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

@@ -1,130 +1,134 @@
-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
-  #  # 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
-    if defined? ::ApplicationController
-      load "#{RAILS_ROOT}/app/assemble.rb" if File.exists? "#{RAILS_ROOT}/app/assemble.rb"
+if defined? ActionController::Routing::RouteSet
+
+  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_with_hobo_routes
+      if Hobo::ModelRouter.reload_routes_on_every_request
+        load!
+      else
+        reload_without_hobo_routes
+      end
+    end
+    alias_method_chain :reload, :hobo_routes
+
+    # temporay hack -- reload assemble.rb whenever routes need reloading
+    def reload_with_hobo_assemble
+      if defined? ::ApplicationController
+        load "#{RAILS_ROOT}/app/assemble.rb" if File.exists? "#{RAILS_ROOT}/app/assemble.rb"
+      end
       reload_without_hobo_assemble
     end
+    alias_method_chain :reload, :hobo_assemble
+
   end
-  alias_method_chain :reload, :hobo_assemble
-  
+
 end
 
 module Hobo
-  
+
   class ModelRouter
-    
-    APP_ROOT = "#{RAILS_ROOT}/app"
-    
+
     class << self
       
+      attr_accessor :reload_routes_on_every_request
+
       def reset_linkables
-        @linkable =Set.new
+        @linkable = Set.new
       end
-      
+
       def linkable_key(klass, action, options)
+        subsite = options[:subsite] || options['subsite']
+        method  = options[:method]  || options['method']
         opts = options.map { |k, v| "#{k}=#{v}" unless v.blank? }.compact.join(',')
-        "#{klass.name}/#{action}/#{opts}"
+        "#{subsite}/#{klass.name}/#{action}/#{method}"
       end
-      
+
       def linkable!(klass, action, options={})
         options[:method] ||= :get
         @linkable << linkable_key(klass, action, options)
       end
-      
+
       def linkable?(klass, action, options={})
         options[:method] ||= :get
         @linkable.member? linkable_key(klass, action, options)
       end
       
+      def called_from_generator?
+        caller[-1] =~ /script[\/\\]generate:\d+$/ || caller[-1] =~ /script[\/\\]destroy:\d+$/
+      end
+
       def add_routes(map)
         # Don't create routes if it's a generator that's running
-        return if caller[-1] =~ /script[\/\\]generate:\d+$/
-        
+        return if called_from_generator?
+
         reset_linkables
-        
-        begin 
+
+        begin
           ActiveRecord::Base.connection.reconnect! unless ActiveRecord::Base.connection.active?
         rescue
           # No database, no routes
           return
         end
 
-        require "#{APP_ROOT}/controllers/application" unless Object.const_defined? :ApplicationController
-        load "#{APP_ROOT}/assemble.rb" if File.exists? "#{APP_ROOT}/assemble.rb"
+        require "#{RAILS_ROOT}/app/controllers/application" unless Object.const_defined? :ApplicationController
 
-        # Add non-subsite routes
-        add_routes_for(map, nil)
+        # Add non-subsite, and all subsite routes
+        [nil, *Hobo.subsites].each { |subsite| add_routes_for(map, subsite) }
 
-        # 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?
-      rescue ActiveRecord::StatementInvalid
+
+        # Run the DRYML generators
+        # TODO: This needs a proper home 
+        Hobo::Dryml::DrymlGenerator.run unless caller[-1] =~ /[\/\\]rake:\d+$/
+      rescue ActiveRecord::StatementInvalid => e
         # Database problem? Just continue without routes
+        ActiveRecord::Base.logger.warn "!! Database exception during Hobo routing -- continuing without routes"
+        ActiveRecord::Base.logger.warn "!! #{e.to_s}"
       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 
-                         Object.const_defined?(module_name) && module_name.constantize.const_defined?(controller_name)
-                       else
-                         Object.const_defined?(controller_name)
-                       end
-          controller_filename = File.join(*["#{APP_ROOT}/controllers", subsite, "#{controller_name.underscore}.rb"].compact) 
-          if is_defined || File.exists?(controller_filename)
-            controller = (subsite ? "#{module_name}::#{controller_name}" : controller_name).constantize
-            ModelRouter.new(map, model, controller, subsite)
-          end
-        end
+        Hobo::ModelController.all_controllers(subsite, :force).each { |controller| ModelRouter.new(map, controller, subsite) }
       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
-    
 
-    def initialize(map, model, controller, subsite)
+
+    def initialize(map, controller, subsite)
       @map = map
-      @model = model
       @controller = controller
       @subsite = subsite
       add_routes
     end
-    
+
 
     attr_reader :map, :model, :controller, :subsite
     
     
+    def model
+      controller.model
+    end
+
+
     def plural
       model.name.underscore.pluralize
     end
-    
-    
+
+
     def singular
       model.name.underscore
     end
-    
-    
+
+
     def add_routes
       # Simple support for composite models, we might later need a CompositeModelController
       if model < Hobo::CompositeModel
@@ -133,122 +137,149 @@ module Hobo
       elsif controller < Hobo::ModelController
         # index routes need to be first so the index names don't get
         # taken as IDs
-        index_action_routes 
+        index_action_routes
+        lifecycle_routes if defined? model::Lifecycle
         resource_routes
-        collection_routes
+        owner_routes
         web_method_routes
         show_action_routes
-        reorder_route
 
-        lifecycle_routes if defined? model::Lifecycle
+        reorder_route
         user_routes      if controller < Hobo::UserController
       end
     end
-    
-    
+
+
     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 })  
-      linkable_route("edit_#{singular}", "#{plural}/:id/edit", :edit, :conditions => { :method => :get })  
-      
+
+      linkable_route("new_#{singular}",  "#{plural}/new",      :new,  :conditions => { :method => :get })
+      linkable_route("edit_#{singular}", "#{plural}/:id/edit", :edit, :conditions => { :method => :get })
+
       linkable_route(singular, "#{plural}/:id", :show, :conditions => { :method => :get })
-                                                                                                                          
+
       linkable_route("create_#{singular}",  plural,          :create,  :conditions => { :method => :post })
-      linkable_route("update_#{singular}",  "#{plural}/:id", :update,  :conditions => { :method => :put }) 
+      linkable_route("update_#{singular}",  "#{plural}/:id", :update,  :conditions => { :method => :put })
       linkable_route("destroy_#{singular}", "#{plural}/:id", :destroy, :conditions => { :method => :delete })
     end
-    
-    
-    def collection_routes
-      controller.collections.each do |collection|
-        linkable_route("#{singular}_#{collection}",
-                       "#{plural}/:id/#{collection}",
-                       collection.to_s,
-                       :conditions => { :method => :get })
-
-        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 }) 
+
+
+    def owner_routes
+      controller.owner_actions.each_pair do |owner, actions|
+        collection     = model.reverse_reflection(owner).name
+        owner_singular = model.reflections[owner].klass.name.underscore
+        owner_plural   = owner_singular.pluralize
+        
+        actions.each do |action| 
+          case action
+          when :index
+            linkable_route("#{plural}_for_#{owner}",
+                           "#{owner_plural}/:#{owner_singular}_id/#{collection}",
+                           "index_for_#{owner}",
+                           :conditions => { :method => :get })
+          when :new
+            linkable_route("new_#{singular}_for_#{owner}",
+                           "#{owner_plural}/:#{owner_singular}_id/#{collection}/new",
+                           "new_for_#{owner}",
+                           :conditions => { :method => :get })
+          when :create
+            linkable_route("create_#{singular}_for_#{owner}",
+                           "#{owner_plural}/:#{owner_singular}_id/#{collection}",
+                           "create_for_#{owner}",
+                           :conditions => { :method => :post })
+          end
         end
       end
-    end
-    
-    
+    end 
+
     def web_method_routes
       controller.web_methods.each do |method|
         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|
         linkable_route("#{view}_#{plural}", "#{plural}/#{view}", view.to_s, :conditions => { :method => :get })
       end
     end
 
-    
+
     def show_action_routes
       controller.show_actions.each do |view|
         linkable_route("#{plural.singularize}_#{view}", "#{plural}/:id/#{view}", view.to_s, :conditions => { :method => :get })
       end
     end
-    
-    
+
+
     def reorder_route
       linkable_route("reorder_#{plural}", "#{plural}/reorder", 'reorder', :conditions => { :method => :post })
     end
-    
-        
+
+
+    def lifecycle_routes
+      model::Lifecycle.creators.values.where.publishable?.*.name.each do |creator|
+        linkable_route("do_#{singular}_#{creator}", "#{plural}/#{creator}", "do_#{creator}",
+                       :conditions => { :method => :post }, :format => false, :linkable_action => creator)
+        linkable_route("#{singular}_#{creator}",    "#{plural}/#{creator}", creator,  :conditions => { :method => :get },  :format => false)
+      end
+      model::Lifecycle.transitions.where.publishable?.*.name.each do |transition|
+        linkable_route("do_#{singular}_#{transition}", "#{plural}/:id/#{transition}", "do_#{transition}",
+                       :conditions => { :method => :put }, :format => false, :linkable_action => transition)
+        linkable_route("#{singular}_#{transition}", "#{plural}/:id/#{transition}", transition,
+                       :conditions => { :method => :get }, :format => false)
+      end
+    end
+
+
     def user_routes
       prefix = plural == "users" ? "" : "#{singular}_"
       linkable_route("#{singular}_login",  "#{prefix}login",  'login')
       linkable_route("#{singular}_logout", "#{prefix}logout", 'logout')
-      linkable_route("#{singular}_signup", "#{prefix}signup", 'signup')
+      linkable_route("#{singular}_forgot_password", "#{prefix}forgot_password", 'forgot_password')
     end
-    
-    
+
+
     def named_route(name, route, options={})
       if controller.public_instance_methods.include?(options[:action].to_s)
         options.reverse_merge!(:controller => route_with_subsite(plural))
         name = name_with_subsite(name)
         route = route_with_subsite(route)
-        map.named_route(name, route, options)
         format_route = options.delete(:format) != false
+        map.named_route(name, route, options)
         map.named_route("formatted_#{name}", "#{route}.:format", options) if format_route
         true
       else
         false
       end
     end
-    
-    
+
+
     def linkable_route(name, route, action, options={})
-      named_route(name, route, options.merge(:action => action.to_s)) and 
+      linkable_action = options.delete(:linkable_action) || action
+      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)
+          self.class.linkable!(model, linkable_action, linkable_options)
         end
     end
-    
-   
+
+
     def name_with_subsite(name)
-      subsite ? "#{subsite}_#{name}" : name 
+      subsite ? "#{subsite}_#{name}" : name
     end
-    
-    
+
+
     def route_with_subsite(route)
       subsite ? "#{subsite}/#{route}" : route
     end
-        
+
   end
-  
+
 end

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

@@ -1,15 +1,15 @@
 module Hobo
-  
+
   module ModelSupport
-    
+
     # This module provides methods common to both Hobo::Model and Hobo::CompositeModel
-    
+
     def self.included(base)
       base.extend(ClassMethods) if base.is_a? Class
     end
-    
+
     module ClassMethods
-      
+
       def delegate_and_compose(*methods)
         options = methods.pop
         unless options.is_a?(Hash) && to = options[:to]
@@ -17,14 +17,14 @@ module Hobo
                                 "with a :to key as the last argument (e.g. delegate :hello, :to => :greeter).")
         end
         use = options[:use]
-    
+
         methods.each do |method|
           module_eval(<<-EOS, "(__COMPOSED_DELEGATION__)", 1)
             def #{method}
               @__#{method}_result__ ||= begin
                                           obj = #{to}.__send__(#{method.inspect})
                                           return nil if obj.nil?
-                                           
+
                                           if obj.nil?
                                             nil
                                           elsif obj.is_a?(Array)
@@ -37,8 +37,8 @@ module Hobo
           EOS
         end
       end
-        
+
     end
-    
+
   end
 end