hobo 0.7.5 → 0.8

data/{hobo_files/plugin/lib → lib}/hobo/dryml/template_handler.rb

@@ -1,22 +1,18 @@
 module Hobo::Dryml
 
-  class TemplateHandler
+  class TemplateHandler < ActionView::TemplateHandler
 
-    def initialize(view)
-      @view = view
-    end
-
-    def render(src, local_assigns)
-      renderer = Hobo::Dryml.page_renderer(@view, local_assigns.keys)
-      this = @view.instance_variable_set("@this", @view.controller.send(:dryml_context) || local_assigns[:this])
-      s = renderer.render_page(this, local_assigns) 
+    def render(template)
+      renderer = Hobo::Dryml.page_renderer_for_template(@view, template)
+      this = @view.instance_variable_set("@this", @view.controller.send(:dryml_context) || template.locals[:this])
+      s = renderer.render_page(this, template.locals)
 
       # Important to strip whitespace, or the browser hangs around for ages (FF2)
       s = s.strip
-      
+
       # TODO: Temporary hack to get the dryml metadata comments in the right place
       if RAILS_ENV == "development"
-        s.gsub(/^(.*?)(<!DOCTYPE.*?>).*?(<html.*?>)/m, "\\2\\3\\1") 
+        s.gsub(/^(.*?)(<!DOCTYPE.*?>).*?(<html.*?>)/m, "\\2\\3\\1")
       else
         s
       end
@@ -27,33 +23,32 @@ module Hobo::Dryml
 end
 
 module ActionController
-  
 
   class Base
-    
+
     def dryml_context
       @this
     end
-    
+
     def dryml_fallback_tag(tag_name)
       @dryml_fallback_tag = tag_name
     end
-    
-    
+
+
     def call_dryml_tag(tag, options={})
       add_variables_to_assigns
-      
+
       # TODO: Figure out what this bit is all about :-)
       if options[:with]
         @this = options[:with] unless options[:field]
       else
         options[:with] = dryml_context
       end
-      
+
       Hobo::Dryml.render_tag(@template, tag, options)
     end
-    
-    
+
+
     # TODO: This is namespace polution, should be called render_dryml_tag
     def render_tag(tag, options={}, render_options={})
       text = call_dryml_tag(tag, options)
@@ -61,17 +56,17 @@ module ActionController
     end
 
     def render_for_file_with_dryml(template_path, *args)
-      if template_path !~ /^\// &&                             # not an absolute path (e.g. an exception ERB template)
+      if template_path !~ /^([a-z]:)?\//i &&                   # not an absolute path (e.g. an exception ERB template)
           !template_exists?(template_path) &&                  # no template available in app/views
           tag_name = @dryml_fallback_tag || "#{File.basename(template_path).dasherize}-page"
 
-          # The template was missing, try to use a DRYML <page> tag instead
-          render_tag(tag_name) or raise ActionController::MissingTemplate, "Missing template #{template_path}.html.erb in view path #{RAILS_ROOT}/app/views"
+        # The template was missing, try to use a DRYML <page> tag instead
+        render_tag(tag_name) or raise ActionView::MissingTemplate, "Missing template #{template_path}.html.erb in view path #{RAILS_ROOT}/app/views"
       else
         render_for_file_without_dryml(template_path, *args)
       end
     end
     alias_method_chain :render_for_file, :dryml
-    
+
   end
 end

data/lib/hobo/find_for.rb

@@ -0,0 +1,95 @@
+module Hobo
+  
+  # FIXME: should be FindByBelongsTo maybe
+  module FindFor
+    
+    def self.included(base)
+      base.alias_method_chain :method_missing, :find_for
+    end
+    
+    def method_missing_with_find_for(name, *args, &block)
+      if name.to_s =~ /(.*)_by_(.*)/
+        # name matches the general form
+        
+        collection_name = $1.to_sym
+        anchor_association_name = $2.to_sym
+        if (refl = self.class.reflections[collection_name]) && refl.macro == :has_many
+          # the association name matches (e.g. comment_for_...)
+          
+          if (anchor_refl = refl.klass.reflections[anchor_association_name]) && anchor_refl.macro == :belongs_to
+            # the whole thing matches (e.g. comment_for_user)
+            
+            
+            #self.class.class_eval %{
+            #  def #{name}(anchor)
+            #    result = if #{collection_name}.loaded?
+            #               #{collection_name}.detect { |x| x.#{anchor_association_name}_is?(anchor) }
+            #             else
+            #               #{collection_name}.#{anchor_association_name}_is(anchor).first
+            #             end
+            #    result ||= #{collection_name}.new(:#{anchor_association_name} => anchor)
+            #    result.origin = self
+            #    result.origin_attribute = "#{name}.'#{anchor_id_expr}'"
+            #    result
+            #  end
+            #}
+            
+            self.class.class_eval %{
+              def #{name}
+                Hobo::FindFor::Finder.new(self, '#{name}', :#{collection_name}, :#{anchor_association_name})
+              end
+            }
+            
+            return send(name, *args)
+          end
+        end
+      end
+      
+      method_missing_without_find_for(name, *args, &block)
+    end
+    
+    class Finder
+      
+      def initialize(owner, name, collection, anchor_association)
+        @association = owner.send(collection)
+        @anchor_reflection = @association.member_class.reflections[anchor_association]
+        @name = name
+      end
+      
+      def origin
+        @association.proxy_owner
+      end
+      
+      def origin_attribute
+        @name
+      end
+      
+      def [](anchor_or_id)
+        anchor = if anchor_or_id.is_a?(String)
+                   id, klass = anchor_or_id.split(':')
+                   (klass.constantize || @anchor_reflection.klass).find(id)
+                 else
+                   anchor_or_id
+                 end
+        result = if @association.loaded?
+                   @association.detect { |x| x.send("#{@anchor_reflection.name}_is?", anchor) }
+                else
+                   @association.send("#{@anchor_reflection.name}_is", anchor).first
+                end
+        result ||= @association.new(@anchor_reflection.name => anchor)
+
+
+        result.origin = self
+        result.origin_attribute = if @anchor_reflection.options[:polymorphic]
+                                    "#{anchor.id}:#{anchor.class.name}"
+                                  else
+                                    "#{anchor.id}"
+                                  end
+        result
+      end
+
+    end
+
+  end
+
+end

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

@@ -1,4 +1,5 @@
-require 'find' 
+require 'find'
+require "rails_generator"
 
 class Hobo::Generator < Rails::Generator::Base
 

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

@@ -1,9 +1,9 @@
-module Hobo 
+module Hobo
 
   class Guest
-    
+
     alias_method :has_hobo_method?, :respond_to?
-    
+
     def to_s
       "Guest"
     end
@@ -12,14 +12,22 @@ module Hobo
       true
     end
 
+    def signed_up?
+      false
+    end
+
     def super_user?
       false
     end
-    
+
     def administrator?
       false
     end
 
+    def login
+      "Guest"
+    end
+
   end
 
 end

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

@@ -1,21 +1,21 @@
 module Hobo
-  
+
   module HoboHelper
-  
+
     def self.add_to_controller(controller)
       controller.send(:include, self)
       controller.hide_action(self.instance_methods)
     end
-     
+
     protected
-    
-    
+
+
     def uid
       @hobo_uid ||= 0
       @hobo_uid += 1
     end
-    
-     
+
+
     def current_user
       # simple one-hit-per-request cache
       @current_user ||= begin
@@ -23,18 +23,18 @@ module Hobo
                           (id && Hobo.object_from_dom_id(id) rescue nil) || ::Guest.new
                         end
     end
-     
-     
+
+
     def logged_in?
       !current_user.guest?
     end
-      
-      
+
+
     def base_url
       request.relative_url_root
     end
-     
-     
+
+
     def controller_for(obj)
       if obj.is_a? Class
         obj.name.underscore.pluralize
@@ -42,31 +42,39 @@ module Hobo
         obj.class.name.underscore.pluralize
       end
     end
-    
-    
+
+
     def subsite
       params[:controller].match(/([^\/]+)\//)._?[1]
     end
 
-    
+
     IMPLICIT_ACTIONS = [:index, :show, :create, :update, :destroy]
-     
+
     def object_url(obj, *args)
       params = args.extract_options!
       action = args.first._?.to_sym
       options, params = params.partition_hash([:subsite, :method, :format])
       options[:subsite] ||= self.subsite
-      
-      if obj.respond_to?(:origin)
+      subsite, method = options.get :subsite, :method
+
+      if obj.respond_to?(:member_class)
         # Asking for URL of a collection, e.g. category/1/adverts or category/1/adverts/new
+        
+        owner_name = obj.origin.class.reverse_reflection(obj.origin_attribute).name.to_s
         if action == :new
           action_path = "#{obj.origin_attribute}/new"
-          action = "new_#{obj.origin_attribute.to_s.singularize}"
+          action = :"new_for_#{owner_name}"
         elsif action.nil?
-          action = obj.origin_attribute
+          action_path = obj.origin_attribute
+          if method.to_s == 'post'
+            action = :"create_for_#{owner_name}"
+          else
+            action = :"index_for_#{owner_name}"
+          end
         end
+        klass = obj.member_class
         obj = obj.origin
-        
       else
         action ||= case options[:method].to_s
                    when 'put';    :update
@@ -75,26 +83,31 @@ module Hobo
                    else; obj.is_a?(Class) ? :index : :show
                    end
 
-        if action == :create && obj.try.new_record?
+        if options[:method].to_s == 'post' && obj.try.new_record?
           # Asking for url to post new record to
           obj = obj.class
         end
+        
+        klass = obj.is_a?(Class) ? obj : obj.class
       end
-    
-      klass = obj.is_a?(Class) ? obj : obj.class
-      if Hobo::ModelRouter.linkable?(klass, action, options)
 
-        path = obj.to_url_path or HoboError.new("cannot create url for #{obj.inspect} (#{obj.class})")
-        url = "#{base_url}#{'/' + subsite unless subsite.blank?}/#{path}"
+      if Hobo::ModelRouter.linkable?(klass, action, options)
 
+        url = base_url_for(obj, subsite, action)
         url += "/#{action_path || action}" unless action.in?(IMPLICIT_ACTIONS)
 
         params = make_params(params)
         params.blank? ? url : "#{url}?#{params}"
       end
     end
-     
-     
+
+
+    def base_url_for(object, subsite, action)
+      path = object.to_url_path or HoboError.new("cannot create url for #{object.inspect} (#{object.class})")
+      "#{base_url}#{'/' + subsite unless subsite.blank?}/#{path}"
+    end
+
+
     def _as_params(name, obj)
       if obj.is_a? Array
         obj.map {|x| _as_params("#{name}[]", x)}.join("&")
@@ -111,43 +124,56 @@ module Hobo
         "#{name}=#{v}"
       end
     end
-     
-     
+
+
     def make_params(*hashes)
       hash = {}
       hashes.each {|h| hash.update(h) if h}
       hash.map {|k,v| _as_params(k, v)}.join("&")
     end
-     
-    
+
+
     def type_id(type=nil)
       type ||= (this.is_a?(Class) && this) || this_type || this.class
       HoboFields.to_name(type) || type.name.underscore.gsub("/", "__")
     end
 
-    
+
     def type_and_field(*args)
       type, field = args.empty? ? [this_parent.class, this_field] : args
       "#{type.typed_id}_#{field}" if type.respond_to?(:typed_id)
     end
-     
-     
-    def map_this
+
+
+    def model_id_class(object=this, attribute=nil)
+      object.respond_to?(:typed_id) ? "model:#{dom_id(object, attribute).dasherize}" : ""
+    end
+
+
+    def context_map(enum = this)
       res = []
       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 } }
+      if enum.respond_to?(:each_pair)
+        enum.each_pair do |key, value|
+          empty = false;
+          self.this_key = key;
+          new_object_context(value) { res << yield }
+        end
       else
-        this.map {|e| empty = false; new_object_context(e) { res << yield } }
+        enum.each do |e|
+          empty = false;
+          if e.respond_to?(:new_record?) && !e.new_record?
+            new_field_context(e.id.to_s, e) { res << yield }
+          else
+            new_object_context(e) { res << yield }
+          end
+        end
       end
       Dryml.last_if = !empty
       res
     end
-    alias_method :collect_this, :map_this
-     
-     
+
+
     def comma_split(x)
       case x
       when nil
@@ -155,47 +181,49 @@ module Hobo
       when Symbol
         x.to_s
       when String
-        x.split(/\s*[, ]\s*/)
+        x.strip.split(/\s*,\s*/)
       else
         x.compact.map{|e| comma_split(e)}.flatten
       end
     end
-     
-     
-    def can_create?(object=nil)
-      Hobo.can_create?(current_user, object || this)
+
+
+    def can_create?(object=this)
+      Hobo.can_create?(current_user, object)
     end
-     
-     
+
+
     def can_update?(object, new)
       Hobo.can_update?(current_user, object, new)
     end
-     
-     
+
+
     def can_edit?(*args)
       if args.empty?
-        if this_parent && this_field
+        if this.respond_to?(:updatable_by?) && !this_field_reflection
+          can_edit?(this, nil)
+        elsif this_parent && this_field
           can_edit?(this_parent, this_field)
         else
           can_edit?(this, nil)
         end
       else
         object, field = args.length == 2 ? args : [this, args.first]
-        
-        if !field && object.respond_to?(:origin)
-          Hobo.can_edit?(current_user, object.origin, object.origin_attribute)
+
+        if !field && (origin = object.try.origin)
+          Hobo.can_edit?(current_user, origin, object.origin_attribute)
         else
           Hobo.can_edit?(current_user, object, field)
         end
       end
     end
-     
-     
+
+
     def can_delete?(object=nil)
       Hobo.can_delete?(current_user, object || this)
     end
-     
-     
+
+
     def can_view?(object=nil, field=nil)
       if object.nil? && field.nil?
         if this_parent && this_field
@@ -206,25 +234,25 @@ module Hobo
       end
 
       @can_view_cache ||= {}
-      @can_view_cache[ [object, field] ] ||= 
+      @can_view_cache[ [object, field] ] ||=
         if !field && object.respond_to?(:origin)
           Hobo.can_view?(current_user, object.origin, object.origin_attribute)
         else
           Hobo.can_view?(current_user, object, field)
         end
     end
-     
-     
-    def select_viewable(collection)
+
+
+    def select_viewable(collection=this)
       collection.select {|x| can_view?(x)}
     end
-     
-     
+
+
     def theme_asset(path)
       theme_path = Hobo.current_theme ? "hobothemes/#{Hobo.current_theme}/" : ""
       "#{base_url}/#{theme_path}#{path}"
     end
-     
+
     def js_str(s)
       if s.is_a? Hobo::RawJs
         s.to_s
@@ -232,25 +260,25 @@ module Hobo
         "'" + s.to_s.gsub("'"){"\\'"} + "'"
       end
     end
-     
-     
+
+
     def make_params_js(*args)
       ("'" + make_params(*args) + "'").sub(/ \+ ''$/,'')
     end
-     
-     
+
+
     def nl_to_br(s)
       s.to_s.gsub("\n", "<br/>") if s
     end
-     
-     
+
+
     def param_name_for(object, field_path)
       field_path = field_path.to_s.split(".") if field_path.is_a?(String, Symbol)
       attrs = field_path.map{|part| "[#{part.to_s.sub /\?$/, ''}]"}.join
       "#{object.class.name.underscore}#{attrs}"
     end
-     
-     
+
+
     def param_name_for_this(foreign_key=false)
       return "" unless form_this
       name = if foreign_key && (refl = this_field_reflection) && refl.macro == :belongs_to
@@ -261,8 +289,8 @@ module Hobo
       register_form_field(name)
       name
     end
-     
-     
+
+
     def transpose_with_field(field, collection=nil)
       collection ||= this
       matrix = collection.map {|obj| obj.send(field) }
@@ -272,25 +300,36 @@ module Hobo
       end
       matrix.transpose
     end
-     
-     
+
+
     def new_for_current_user(model_or_assoc=nil)
       model_or_assoc ||= this
       model_or_assoc.user_new(current_user)
     end
-    
-    
+
+
     def defined_route?(r)
       @view.respond_to?("#{r}_url")
     end
-     
-     
+
+
     # Login url for a given user record or user class
-    def login_url(user_or_class)
-      c = user_or_class.is_a?(Class) ? user_or_class : user_or_class.class
-      send("#{c.name.underscore}_login_url") rescue nil
+    def forgot_password_url(user_class=Hobo::User.default_user_model)
+      send("#{user_class.name.underscore}_forgot_password_url") rescue nil
     end
-    
+
+
+    # Login url for a given user record or user class
+    def login_url(user_class=Hobo::User.default_user_model)
+      send("#{user_class.name.underscore}_login_url") rescue nil
+    end
+
+
+    # Sign-up url for a given user record or user class
+    def signup_url(user_class=Hobo::User.default_user_model)
+      send("#{user_class.name.underscore}_signup_url") rescue nil
+    end
+
 
     # Login url for a given user record or user class
     def logout_url(user_or_class=nil)
@@ -303,28 +342,18 @@ module Hobo
           end
       send("#{c.name.underscore}_logout_url") rescue nil
     end
-    
 
-    # Sign-up url for a given user record or user class
-    def signup_url(user_or_class=nil)
-      c = case user_or_class
-          when Class; user_or_class
-          when nil;   Hobo::User.default_user_model
-          else user_or_class
-          end
-      send("#{c.name.underscore}_signup_url") rescue nil
-    end
-    
+
     def current_page_url
       request.request_uri.match(/^([^?]*)/)._?[1]
     end
 
     def query_params
-      query = request.request_uri.match(/(?:\?(.+))/)._?[1]
+      query = request.request_uri.match(/(?:\?([^?]+))/)._?[1]
       if query
         params = query.split('&')
         pairs = params.map do |param|
-          pair = param.split('=')
+          pair = param.split('=', 2)
           pair.length == 1 ? pair + [''] : pair
         end
         HashWithIndifferentAccess[*pairs.flatten]
@@ -332,7 +361,7 @@ module Hobo
         HashWithIndifferentAccess.new
       end
     end
-    
+
     def linkable?(*args)
       options = args.extract_options!
       target = args.empty? || args.first.is_a?(Symbol) ? this : args.shift
@@ -341,7 +370,7 @@ module Hobo
       if (origin = target.try.origin)
         klass = origin.class
         action = if action == :new
-                   "new_#{target.origin_attribute.to_s.singularize}" 
+                   "new_#{target.origin_attribute.to_s.singularize}"
                  elsif action.nil?
                    target.origin_attribute
                  end
@@ -351,27 +380,27 @@ module Hobo
       else
         klass = target.class
         action ||= :show
-      end      
-      
+      end
+
       Hobo::ModelRouter.linkable?(klass, action, options.reverse_merge(:subsite => subsite))
     end
-    
-    
+
+
     # Convenience helper for the default app
-    
+
     # FIXME: this should interrogate the routes to find index methods, not the models
     def front_models
-      Hobo.models.select {|m| linkable?(m) && !(m < Hobo::User)}
+      Hobo::Model.all_models.select {|m| linkable?(m) }
     end
-    
-    
-    
+
+
+
     # debugging support
-     
+
     def abort_with(*args)
       raise args.map{|arg| PP.pp(arg, "")}.join("-------\n")
     end
-     
+
     def log_debug(*args)
       logger.debug("\n### DRYML Debug ###")
       logger.debug(args.map {|a| PP.pp(a, "")}.join("-------\n"))
@@ -379,7 +408,7 @@ module Hobo
       logger.debug("###################\n")
       args.first unless args.empty?
     end
-    
+
   end
 
 end