hobo 0.7.2 → 0.7.3

data/hobo_files/plugin/lib/hobo/dryml/template_environment.rb

@@ -52,12 +52,45 @@ module Hobo::Dryml
     attr_accessor 
 
     for attr in [:erb_binding, :part_contexts, :view_name,
-                 :this, :this_parent, :this_field, :this_type,
+                 :this, :this_parent, :this_field,
                  :form_field_path, :form_this, :form_field_names]
       class_eval "def #{attr}; @_#{attr}; end"
     end
     
     
+    # The type of this, or when this is nil, the type that would be expected in the current field
+    def this_type
+      @_this_type ||= if this == false || this == true
+                        Hobo::Boolean
+                      elsif this
+                        this.class
+                      elsif this_parent && this_field && (parent_class = this_parent.class).respond_to?(:attr_type)
+                        type = parent_class.attr_type(this_field)
+                        if type.is_a?(ActiveRecord::Reflection::AssociationReflection)
+                          reflection = type
+                          if reflection.macro == :has_many
+                            Array
+                          elsif reflection.options[:polymorphic]
+                            # All we know is that it will be some active-record type
+                            ActiveRecord::Base
+                          else
+                            reflection.klass
+                          end
+                        else
+                          type
+                        end
+                      else
+                        # Nothing to go on at all 
+                        Object
+                      end
+    end
+    
+    
+    def this_field_reflection
+      this_parent && this_field && this_parent.class.respond_to?(:reflections) && this_parent.class.reflections[this_field.to_sym]
+    end
+    
+    
     def attrs_for(name)
       self.class.tag_attrs[name.to_sym]
     end
@@ -95,51 +128,50 @@ module Hobo::Dryml
     end
 
     
-    def this_field_dom_id
-      if this_parent && this_field
-        Hobo.dom_id(this_parent, this_field)
-      else
-        Hobo.dom_id(this)
+    def dom_id(object=nil, attribute=nil)      
+      if object.nil?
+        # nothing passed -- use context
+        if this_parent && this_field
+          object, attribute = this_parent, this_field
+        else
+          object = this
+        end
       end
-    end
-
-    
-    def context_id
-      if this_parent and this_parent.is_a?(ActiveRecord::Base) and this_field
-        this_field_dom_id
-      elsif this.respond_to?(:typed_id)
-        this.typed_id
-      elsif this.is_a?(Array) and !this.respond_to?(:proxy_reflection)
-        "nil"
+      
+      id = object.try.typed_id
+      if id
+        attribute ? "#{id}_#{attribute}" : id
       else
-        Hobo.dom_id(this)
+        "nil"
       end
     end
-
     
-    def call_part(dom_id, part_name, part_this=nil, *locals)
+    
+    def call_part(part_node_id, part_name, part_this=nil, *locals)
       res = ''
       if part_this
         new_object_context(part_this) do
-          @_part_contexts[dom_id] = PartContext.new(part_name, context_id, locals)
+          @_part_contexts[part_node_id] = PartContext.new(part_name, dom_id, locals)
           res = send("#{part_name}_part", *locals)
         end
       else
         new_context do
-          @_part_contexts[dom_id] = PartContext.new(part_name, context_id, locals)
+          @_part_contexts[part_node_id] = PartContext.new(part_name, dom_id, locals)
           res = send("#{part_name}_part", *locals)
         end
       end
       res
     end
+
     
     def call_polymorphic_tag(name, *args)
+      name = name.to_s.gsub('-', '_')
       type = args.first.is_a?(Class) ? args.shift : nil
       attributes, parameters = args
       
       tag = find_polymorphic_tag(name, type)
       if tag != name
-        send(tag, attributes, parameters || {})
+        send(tag, attributes || {}, parameters || {})
       else
         nil
       end
@@ -147,18 +179,7 @@ module Hobo::Dryml
 
     
     def find_polymorphic_tag(name, call_type=nil)
-      call_type ||= case this_type
-                    when ActiveRecord::Reflection::AssociationReflection
-                      # Don't blow up with non-existent polymorphic types
-                      return name if this_type.options[:polymorphic] && !Object.const_defined?(this_type.class_name)
-                      this_type.klass
-                    when Array
-                      this.member_class
-                    else
-                      this_type
-                    end
-      
-      call_type = TrueClass if call_type == FalseClass
+      call_type ||= (this.is_a?(Array) && this.respond_to?(:member_class) && this.try.member_class) || this_type
 
       while true
         if call_type == ActiveRecord::Base || call_type == Object
@@ -192,8 +213,9 @@ module Hobo::Dryml
     def new_context
       ctx = [ @_erb_output,
               @_this, @_this_parent, @_this_field, @_this_type,
-              @_form_field_path]
+              @_form_field_path ]
       @_erb_output = ""
+      @_this_type = nil
       res = yield
       @_erb_output, @_this, @_this_parent, @_this_field, @_this_type, @_form_field_path = ctx
       res.to_s
@@ -202,14 +224,7 @@ module Hobo::Dryml
 
     def new_object_context(new_this)
       new_context do
-        @_this_parent,@_this_field,@_this_type = if new_this.respond_to?(:proxy_reflection)
-                                                   refl = new_this.proxy_reflection
-                                                   [new_this.proxy_owner, refl.name, refl]
-                                                 else
-                                                   # In dryml, TrueClass is the 'boolean' class
-                                                   t = new_this.class == FalseClass ? TrueClass : new_this.class
-                                                   [nil, nil, t]
-                                                 end
+        @_this_parent, @_this_field = [new_this.origin, new_this.origin_attribute] if new_this.respond_to?(:origin) 
         @_this = new_this
         yield
       end
@@ -226,17 +241,7 @@ module Hobo::Dryml
                  [field_path]
                end
         parent, field, obj = Hobo.get_field_path(tag_this || this, path)
-
-        type = if parent.class.respond_to?(:field_type) && field_type = parent.class.field_type(field)
-                 field_type
-               elsif obj == false
-                 # In dryml, TrueClass is the 'boolean' class
-                 TrueClass
-               else
-                 obj.class
-               end
-        
-        @_this, @_this_parent, @_this_field, @_this_type = obj, parent, field, type
+        @_this, @_this_parent, @_this_field = obj, parent, field
         @_form_field_path += path if @_form_field_path
         yield
       end
@@ -432,7 +437,14 @@ module Hobo::Dryml
     def render_tag(tag_name, attributes)
       method_name = tag_name.gsub('-', '_')
       if respond_to?(method_name)
-        (send(method_name, attributes) + part_contexts_storage_tag).strip
+        res = (send(method_name, attributes) + part_contexts_storage_tag).strip
+
+        # TODO: Temporary hack to get the dryml metadata comments in the right place
+        if RAILS_ENV == "development"
+          res.gsub(/^(.*?)(<!DOCTYPE.*?>).*?(<html.*?>)/m, "\\2\\3\\1") 
+        else
+          res
+        end
       else
         false
       end

data/hobo_files/plugin/lib/hobo/dryml/template_handler.rb

@@ -8,12 +8,62 @@ module Hobo::Dryml
 
     def render(src, local_assigns)
       renderer = Hobo::Dryml.page_renderer(@view, local_assigns.keys)
-      s = renderer.render_page(@view.assigns["this"] || local_assigns[:this], local_assigns)
-      # Important to strip whitespace, or the browser hangs around for ages (FF2)
+      this = @view.instance_variable_set("@this", @view.controller.send(:dryml_context) || local_assigns[:this])
+      s = renderer.render_page(this, local_assigns) 
 
-      s.strip
+      # 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") 
+      else
+        s
+      end
     end
 
   end
 
 end
+
+module ActionController
+  
+
+  class Base
+    
+    def dryml_context
+      @this
+    end
+    
+    def dryml_fallback_tag(tag_name)
+      @dryml_fallback_tag = tag_name
+    end
+    
+    def render_tag(tag, options={}, render_options={})
+      add_variables_to_assigns
+      
+      if options[:with]
+        @this = options[:with] unless options[:field]
+      else
+        options[:with] = dryml_context
+      end
+      
+      text = Hobo::Dryml.render_tag(@template, tag, options)
+      text && render({:text => text, :layout => false }.merge(render_options))
+    end
+
+    def render_for_file_with_dryml(template_path, *args)
+      if template_path !~ /^\// &&                             # 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"
+      else
+        render_for_file_without_dryml(template_path, *args)
+      end
+    end
+    alias_method_chain :render_for_file, :dryml
+    
+  end
+end

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

@@ -40,66 +40,51 @@ module Hobo
     def subsite
       params[:controller].match(/([^\/]+)\//)._?[1]
     end
+
+    
+    IMPLICIT_ACTIONS = [:index, :show, :create, :update, :destroy]
      
-     
-    def object_url(*args)
+    def object_url(obj, *args)
       params = args.extract_options!
-      obj, action = args
-      action &&= action.to_s
-      
-      controller_name = controller_for(obj)
-      
-      subsite = params[:subsite] || self.subsite
+      action = args.first._?.to_sym
+      options, params = params.partition_hash([:subsite, :method, :format])
+      options[:subsite] ||= self.subsite
       
-      # TODO - what if you want if_available as a query param?
-      if_available = params.delete(:if_available)
-      return nil if if_available && 
-        ((action.nil? && obj.respond_to?(:typed_id) && !linkable?(obj.class, :show,  :subsite => subsite)) ||
-         (action.nil? && obj.is_a?(Class) &&           !linkable?(obj,       :index, :subsite => subsite)))
-      
-      base = subsite.blank? ? base_url : "/#{subsite}#{base_url}"
-      
-      parts = if obj.is_a? Class
-                [base, controller_name]
-                
-              elsif obj.is_a? Hobo::CompositeModel
-                [base, controller_name, obj.to_param]
-                
-              elsif obj.is_a? ActiveRecord::Base
-                if obj.new_record?
-                  [base, controller_name]
-                else
-                  raise HoboError.new("invalid object url: new for existing object") if action == "new"
-     
-                  klass = obj.class
-                  id = if klass.id_name?
-                         obj.id_name(true)
-                       else
-                         obj.to_param
-                       end
-                  
-                  [base, controller_name, id]
-                end
-                
-              elsif obj.is_a? Array    # warning - this breaks if we use `case/when Array`
-                owner = obj.proxy_owner
-                new_model = obj.proxy_reflection.klass
-                [object_url(owner), obj.proxy_reflection.name]
-                
-              else
-                raise HoboError.new("cannot create url for #{obj.inspect} (#{obj.class})")
-              end
-      url = parts.join("/")
+      if obj.respond_to?(:origin)
+        # Asking for URL of a collection, e.g. category/1/adverts or category/1/adverts/new
+        if action == :new
+          action_path = "#{obj.origin_attribute}/new"
+          action = "new_#{obj.origin_attribute.to_s.singularize}"
+        elsif action.nil?
+          action = obj.origin_attribute
+        end
+        obj = obj.origin
+        
+      else
+        action ||= case options[:method].to_s
+                   when 'put';    :update
+                   when 'post';   :create
+                   when 'delete'; :destroy
+                   else; obj.is_a?(Class) ? :index : :show
+                   end
 
-      case action
-      when nil       # do nothing
-      when "destroy" then params["_method"] = "DELETE"
-      when "update"  then params["_method"] = "PUT"
-      else url += "/#{action}" 
+        if action == :create && obj.try.new_record?
+          # Asking for url to post new record to
+          obj = obj.class
+        end
       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}"
 
-      params = make_params(params - [:subsite])
-      params.blank? ? url : "#{url}?#{params}"
+        url += "/#{action_path || action}" unless action.in?(IMPLICIT_ACTIONS)
+
+        params = make_params(params)
+        params.blank? ? url : "#{url}?#{params}"
+      end
     end
      
      
@@ -127,31 +112,16 @@ module Hobo
       hash.map {|k,v| _as_params(k, v)}.join("&")
     end
      
-     
-    def dom_id(*args)
-      if args.length == 0
-        Hobo.dom_id(this)
-      else
-        Hobo.dom_id(*args)
-      end
-    rescue ArgumentError
-      ""
-    end
-    
     
     def type_id(type=nil)
-      type ||= this.is_a?(Class) ? this : this_type
-      type == NilClass ? "" : Hobo.type_id(type || this.class)
+      type ||= (this.is_a?(Class) && this) || this_type || this.class
+      HoboFields.to_name(type) || type.name.underscore.gsub("/", "__")
     end
-    
+
     
     def type_and_field(*args)
-      if args.empty?
-        this_parent && this_field && "#{Hobo.type_id(this_parent.class)}_#{this_field}"
-      else
-        type, field = args
-        "#{Hobo.type_id(type)}_#{field}"
-      end
+      type, field = args.empty? ? [this_parent.class, this_field] : args
+      "#{type.typed_id}_#{field}" if type.respond_to?(:typed_id)
     end
      
      
@@ -203,8 +173,8 @@ module Hobo
       else
         object, field = args.length == 2 ? args : [this, args.first]
         
-        if !field and object.respond_to?(:proxy_reflection)
-          Hobo.can_edit?(current_user, object.proxy_owner, object.proxy_reflection.name)
+        if !field && object.respond_to?(:origin)
+          Hobo.can_edit?(current_user, object.origin, object.origin_attribute)
         else
           Hobo.can_edit?(current_user, object, field)
         end
@@ -225,12 +195,14 @@ module Hobo
           object = this
         end
       end
-      
-      if !field and object.respond_to?(:proxy_reflection)
-        Hobo.can_view?(current_user, object.proxy_owner, object.proxy_reflection.name)
-      else
-        Hobo.can_view?(current_user, object, field)
-      end
+
+      @can_view_cache ||= {}
+      @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
      
      
@@ -272,8 +244,8 @@ module Hobo
      
     def param_name_for_this(foreign_key=false)
       return "" unless form_this
-      name = if foreign_key and this_type.respond_to?(:macro) and this_type.macro == :belongs_to
-               param_name_for(form_this, form_field_path[0..-2] + [this_type.primary_key_name])
+      name = if foreign_key && (refl = this_field_reflection) && refl.macro == :belongs_to
+               param_name_for(form_this, form_field_path[0..-2] + [refl.primary_key_name])
              else
                param_name_for(form_this, form_field_path)
              end
@@ -282,21 +254,10 @@ module Hobo
     end
      
      
-    def selector_type
-      if this.is_a? ActiveRecord::Base
-        this.class
-      elsif this.respond_to? :member_class
-        this.member_class
-      elsif this == @this
-        @model
-      end
-    end
-     
-     
     def transpose_with_field(field, collection=nil)
       collection ||= this
       matrix = collection.map {|obj| obj.send(field) }
-      max_length = matrix.every(:length).max
+      max_length = matrix.*.length.max
       matrix = matrix.map do |a|
         a + [nil] * (max_length - a.length)
       end
@@ -306,9 +267,7 @@ module Hobo
      
     def new_for_current_user(model_or_assoc=nil)
       model_or_assoc ||= this
-      record = model_or_assoc.new
-      record.set_creator(current_user)
-      record
+      model_or_assoc.user_new(current_user)
     end
     
     
@@ -338,8 +297,12 @@ module Hobo
     
 
     # Sign-up url for a given user record or user class
-    def signup_url(user_or_class)
-      c = user_or_class.is_a?(Class) ? user_or_class : user_or_class.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
     
@@ -366,23 +329,28 @@ module Hobo
       target = args.empty? || args.first.is_a?(Symbol) ? this : args.shift
       action = args.first
 
-      if target.is_a?(Class)
+      if (origin = target.try.origin)
+        klass = origin.class
+        action = if action == :new
+                   "new_#{target.origin_attribute.to_s.singularize}" 
+                 elsif action.nil?
+                   target.origin_attribute
+                 end
+      elsif target.is_a?(Class)
         klass = target
         action ||= :index
-      elsif target.respond_to?(:member_class)
-        klass = target.member_class
-        action ||= :show
       else
         klass = target.class
         action ||= :show
       end      
       
-      Hobo::ModelRouter.linkable?(subsite, klass, action.to_sym)
+      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)}
     end
@@ -398,7 +366,7 @@ module Hobo
     def log_debug(*args)
       logger.debug("\n### DRYML Debug ###")
       logger.debug(args.map {|a| PP.pp(a, "")}.join("-------\n"))
-      logger.debug("DRYML THIS = #{Hobo.dom_id(this) rescue this.inspect}")
+      logger.debug("DRYML THIS = #{this.typed_id rescue this.inspect}")
       logger.debug("###################\n")
       args.first unless args.empty?
     end