hobo 0.5.3

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

@@ -0,0 +1,7 @@
+class Hobo::MarkdownString < String
+  
+  def to_html
+    self.blank? ? "" : BlueCloth.new(self).to_html
+  end
+
+end

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

@@ -0,0 +1,391 @@
+module Hobo
+
+  module Model
+    
+    def self.included(base)
+      Hobo.register_model(base)
+      base.extend(ClassMethods)
+      base.set_field_type({})
+      class << base
+        alias_method_chain :has_many, :defined_scopes
+      end
+    end
+
+    module ClassMethods
+      
+      # include methods also shared by CompositeModel
+      include ModelSupport::ClassMethods
+      
+      def method_added(name)
+        # avoid error when running model generators before
+        # db exists
+        return unless connected? 
+        
+        aliased_name = "#{name}_without_hobo_type"
+        return if name.to_s.ends_with?('without_hobo_type') or aliased_name.in?(instance_methods)
+        
+        type_wrapper = self.field_type(name)
+        if type_wrapper && type_wrapper.is_a?(Class) && type_wrapper < String
+          aliased_name = "#{name}_without_hobo_type"
+          alias_method aliased_name, name
+          define_method name do
+            res = send(aliased_name)
+            if res.nil?
+              nil
+            elsif res.respond_to?(:hobo_undefined?) && res.hobo_undefined?
+              res
+            else
+              type_wrapper.new(res)
+            end
+          end
+        end
+      end
+      
+      def set_field_type(types)
+        types.each_pair do |field, type|
+          
+          # TODO: Make this extensible
+          type_class = case type
+                       when :html; HtmlString
+                       when :markdown; MarkdownString
+                       when :textile; TextileString
+                       when :password; PasswordString
+                       else type
+                       end
+          
+          field_types[field] = type_class
+        end
+      end
+      
+      
+      def field_types
+        @hobo_field_types ||= superclass.respond_to?(:field_types) ? superclass.field_types : {}
+      end
+      
+      
+      def set_default_order(order)
+        @default_order = order
+      end
+      
+      inheriting_attr_accessor :default_order, :id_name_options
+
+
+      def never_show(*fields)
+        @hobo_never_show ||= []
+        @hobo_never_show.concat(fields.omap{to_sym})
+      end
+
+
+      def never_show?(field)
+        @hobo_never_show and field.to_sym.in?(@hobo_never_show)
+      end
+
+      def set_creator_attr(attr)
+        class_eval %{
+          def creator
+            #{attr};
+          end
+          def creator=(x)
+            self.#{attr} = x;
+          end
+        }
+      end 
+
+      def set_search_columns(*columns)
+        class_eval %{
+          def self.search_columns
+            %w{#{columns.omap{to_s} * ' '}}
+          end
+        }
+      end
+      
+
+      def id_name(*args)
+        @id_name_options = [] + args
+        
+        underscore = args.delete(:underscore)
+        insenstive = args.delete(:case_insensitive)
+        id_name_field = args.first || :name
+        @id_name_column = id_name_field.to_s
+
+        if underscore
+          class_eval %{
+            def id_name(underscore=false)
+              underscore ? #{id_name_field}.gsub(' ', '_') : #{id_name_field}
+            end
+          }
+        else
+          class_eval %{
+            def id_name(underscore=false)
+              #{id_name_field}
+            end
+          }
+        end
+
+        key = "id_name#{if underscore; ".gsub('_', ' ')"; end}"
+        finder = if insenstive
+          "find(:first, :conditions => ['lower(#{id_name_field}) = ?', #{key}.downcase])"
+        else
+          "find_by_#{id_name_field}(#{key})"
+        end
+
+        class_eval %{
+          def self.find_by_id_name(id_name)
+            #{finder}
+          end
+        }
+
+        model = self
+        validate do
+          erros.add id_name_field, "is taken" if model.find_by_id_name(name)
+        end
+        validates_format_of id_name_field, :with => /^[^_]+$/, :message => "cannot contain underscores" if
+          underscore
+      end
+
+
+      def id_name?
+        respond_to?(:find_by_id_name)
+      end
+
+
+      attr_reader :id_name_column
+
+      
+      
+      def field_type(name)
+        name = name.to_sym
+        field_types[name] or
+          reflections[name] or
+          ((col = columns.find {|c| c.name == name.to_s}) and case col.type
+                                                              when :boolean
+                                                                TrueClass
+                                                              when :text
+                                                                Hobo::Text
+                                                              else
+                                                                col.klass
+                                                              end)
+      end
+      
+      
+      def conditions(&b)
+        ModelQueries.new(self).instance_eval(&b).to_sql
+      end
+
+
+      def find(*args, &b)
+        if args.first.in?([:all, :first])
+          if args.last.is_a? Hash
+            options = args.last
+            args[-1] = options = options.merge(:order => default_order) if options[:order] == :default
+          else
+            options = {}
+          end
+          
+          if b
+            super(args.first, options.merge(:conditions => conditions(&b)))
+          else
+            super(*args)
+          end
+        else
+          super(*args)
+        end
+      end
+      
+      
+      def count(*args, &b)
+        if b
+          sql = ModelQueries.new(self).instance_eval(&b).to_sql
+          options = extract_options_from_args!(args)
+          super(*args + [options.merge(:conditions => sql)])
+        else
+          super(*args)
+        end
+      end
+
+
+      def subclass_associations(association, *subclass_associations)
+        refl = reflections[association]
+        for assoc in subclass_associations
+          class_name = assoc.to_s.classify
+          options = { :class_name => class_name, :conditions => "type = '#{class_name}'" }
+          options[:source] = refl.source_reflection.name if refl.source_reflection
+          has_many(assoc, refl.options.merge(options))
+        end
+      end
+
+      def has_creator?
+        instance_methods.include?('creator=') and instance_methods.include?('creator')
+      end
+
+      def search_columns
+        cols = columns.omap{name}
+        %w{name title body content}.select{|c| c.in?(cols) }
+      end
+      
+      # This should really be a method on AssociationReflection
+      def reverse_reflection(association_name)
+        refl = reflections[association_name]
+        return nil if refl.options[:conditions]
+        
+        reverse_macro = if refl.macro == :has_many
+                          :belongs_to
+                        elsif refl.macro == :belongs_to
+                          :has_many
+                        end
+        refl.klass.reflections.values.find do |r|
+          r.macro == reverse_macro and
+            r.klass == self and 
+            !r.options[:conditions] and
+            r.primary_key_name == refl.primary_key_name
+        end
+      end
+      
+      
+      class ScopedProxy
+        def initialize(klass, scope={})
+          @klass, @scope = klass, scope
+        end
+        
+        def method_missing(name, *args, &block)
+          klass.with_scope(@scope) do
+            @klass.send(name, *args, &block)
+          end
+        end
+      end
+      (Object.instance_methods + 
+       Object.private_instance_methods +
+       Object.protected_instance_methods).each do |m|
+        ScopedProxy.send(:undef_method, m) unless
+          m.in?(%w{initialize method_missing}) || m.starts_with?('_')
+      end
+      
+      attr_accessor :defined_scopes
+
+      
+      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
+      
+      
+      module DefinedScopeProxyExtender
+        
+        attr_accessor :reflections
+        
+        def method_missing(name, *args, &block)
+          scopes = proxy_reflection.klass.defined_scopes
+          scope = scopes && scopes[name.to_sym]
+          if scope
+            scope = scope.call(*args) if scope.is_a?(Proc)
+            
+            # Calling directly causes self to get loaded
+            assoc = Kernel.instance_method(:instance_variable_get).bind(self).call("@#{name}")
+            unless assoc
+              options = proxy_reflection.options
+              has_many_conditions = options.has_key?(:condition)
+              scope_conditions = scope.delete(:conditions)
+              conditions = if has_many_conditions && scope_conditions
+                             "(#{scope_conditions}) AND (#{has_many_conditions})"
+                           else
+                             scope_conditions || has_many_conditions
+                           end
+              
+              options = options.merge(scope).update(:conditions => conditions,
+                                                    :class_name => proxy_reflection.klass.name,
+                                                    :foreign_key => proxy_reflection.primary_key_name)
+              r = ActiveRecord::Reflection::AssociationReflection.new(:has_many,
+                                                                      name,
+                                                                      options,
+                                                                      proxy_reflection.klass)
+              @reflections ||= {}
+              @reflections[name] = r
+              
+              assoc = if options.has_key?(:through)
+                        ActiveRecord::Associations::HasManyThroughAssociation
+                      else
+                        ActiveRecord::Associations::HasManyAssociation
+                      end.new(self.proxy_owner, r)
+              
+              # Calling directly causes self to get loaded
+              Kernel.instance_method(:instance_variable_set).bind(self).call("@#{name}", assoc)
+            end
+            assoc
+          else
+            super
+          end
+        end
+        
+      end
+      
+      
+      def has_many_with_defined_scopes(name, *args, &block)
+        options = extract_options_from_args!(args)
+        if options.has_key?(:extend) || block
+          # Normal has_many
+          has_many_without_defined_scopes(name, *args + [options], &block)
+        else
+          options[:extend] = DefinedScopeProxyExtender
+          has_many_without_defined_scopes(name, *args + [options], &block)
+        end
+      end
+    end
+    
+    
+    def method_missing(name, *args, &b)
+      val = super
+      if val.nil?
+        nil
+      else
+        type_wrapper = self.class.field_type(name)
+        (type_wrapper && type_wrapper.is_a?(Class) && type_wrapper < String) ? type_wrapper.new(val) : val
+      end
+    end
+
+
+    def created_by(user)
+      self.creator ||= user if self.class.has_creator? and not user.guest?
+    end
+
+
+    def duplicate
+      res = self.class.new
+      res.instance_variable_set("@attributes", @attributes.dup)
+      res.instance_variable_set("@new_record", nil) unless new_record?
+      
+      # Shallow copy of belongs_to associations
+      for refl in self.class.reflections.values
+        if refl.macro == :belongs_to and (target = self.send(refl.name))
+          bta = ActiveRecord::Associations::BelongsToAssociation.new(res, refl)
+          bta.replace(target)
+          res.instance_variable_set("@#{refl.name}", bta)
+        end
+      end
+      res
+    end
+
+
+    def same_fields?(other, *fields)
+      fields.all?{|f| self.send(f) == other.send(f)}
+    end
+    
+    def changed_fields?(other, *fields)
+      fields.all?{|f| self.send(f) != other.send(f)}
+    end
+    
+    def compose_with(object, use=nil)
+      CompositeModel.new_for([self, object])
+    end
+    
+    
+    def typed_id
+      id ? "#{self.class.name.underscore}_#{self.id}" : nil
+    end
+    
+  end
+end
+

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

@@ -0,0 +1,676 @@
+module Hobo
+
+  module ModelController
+
+    include Hobo::Controller
+
+    class PermissionDeniedError < RuntimeError; end
+
+    VIEWLIB_DIR = "hobolib"
+    
+    GENERIC_PAGE_TAGS = [:index, :show, :new, :edit, :show_collection, :new_in_collection]
+
+    class << self
+
+      def included(base)
+        base.extend(ClassMethods)
+        base.helper_method(:find_partial, :model, :current_user)
+
+        Hobo::ControllerHelpers.public_instance_methods.each {|m| base.hide_action(m)}
+
+        for collection in base.collections
+          add_collection_actions(base, collection.to_sym)
+        end
+
+        base.before_filter :set_no_cache_headers
+
+        base.class_eval do
+          alias_method_chain :redirect_to, :object_url
+        end
+      end
+
+      def find_partial(klass, as)
+        find_model_template(klass, as, true)
+      end
+
+
+      def template_path(dir, name, is_partial)
+        fileRx = is_partial ? /^_#{name}\.[^.]+/ : /^#{name}\.[^.]+/
+        unless Dir.entries("#{RAILS_ROOT}/app/views/#{dir}").grep(fileRx).empty?
+          return "#{dir}/#{name}"
+        end
+      end
+
+
+      def find_model_template(klass, name, is_partial=false)
+        while klass and klass != ActiveRecord::Base
+          dir = klass.name.underscore.pluralize
+          path = template_path(dir, name, is_partial)
+          return path if path
+
+          klass = klass.superclass
+        end
+        nil
+      end
+      
+      
+      def add_collection_actions(controller_class, name)
+        defined_methods = controller_class.instance_methods
+        
+        show_collection_method = "show_#{name}".to_sym
+        unless show_collection_method.in?(defined_methods)
+          controller_class.send(:define_method, show_collection_method) do
+            hobo_show_collection(name)
+          end  
+        end
+          
+        if Hobo.simple_has_many_association?(controller_class.model.reflections[name])
+          new_method = "new_#{name.to_s.singularize}"
+          if new_method.not_in?(defined_methods)
+            controller_class.send(:define_method, new_method) do
+              hobo_new_in_collection(name)
+            end
+          end
+        end
+      end
+      
+    end
+
+    module ClassMethods
+
+      attr_writer :model
+      
+      def web_methods
+        @web_methods ||= superclass.respond_to?(:web_methods) ? superclass.web_methods : []
+      end
+      
+      def show_actions
+        @show_actions ||= superclass.respond_to?(:show_actions) ? superclass.show_actions : []
+      end
+      
+      def collections
+        # By default, all has_many associations are published
+        @collections ||= if superclass.respond_to?(:collections)
+                           superclass.collections
+                         else
+                           model.reflections.values.map {|r| r.name if r.macro == :has_many}.compact
+                         end
+      end
+
+      def model
+        @model ||= name.sub(/Controller$/, "").singularize.constantize
+      end
+
+
+      def autocomplete_for(attr, options={})
+        opts = { :limit => 15 }.update(options)
+        @completers ||= {}
+        @completers[attr.to_sym] = opts
+      end
+
+
+      def autocompleter(name)
+        (@completers && @completers[name]) ||
+          (superclass.respond_to?(:autocompleter) && superclass.autocompleter(name))
+      end
+
+
+      def def_data_filter(name, &b)
+        @data_filters ||= {}
+        @data_filters[name] = b
+      end
+      
+      
+      def web_method(web_name, method_name=nil)
+        method_name ||= web_name
+        web_methods << web_name.to_sym
+        before_filter(:only => [web_name]) {|controller| controller.send(:prepare_web_method, method_name)}
+      end
+      
+      
+      def show_action(*names)
+        show_actions.concat(names)
+        for name in names
+          class_eval "def #{name}; show; end"
+        end
+      end
+      
+      
+      def publish_collection(*names)
+        collections.concat(names)
+        names.each {|n| ModelController.add_collection_actions(self, n)}
+      end
+      
+      
+      def data_filter(name)
+        (@data_filters && @data_filters[name]) ||
+          (superclass.respond_to?(:data_filter) && superclass.data_filter(name))
+      end
+
+
+      def find_instance(id)
+        if model.id_name? and id !~ /^\d+$/
+          model.find_by_id_name(id)
+        else
+          model.find(id)
+        end
+      end
+
+    end
+
+    # --- ACTIONS --- #
+
+    def index;   hobo_index; end
+    def show;    hobo_show; end
+    def new;     hobo_new; end
+    def create;  hobo_create; end
+    def edit;    hobo_edit; end
+    def update;  hobo_update; end
+    def destroy; hobo_destroy; end
+    
+    def completions
+      attr = params[:for]
+      opts = attr && self.class.autocompleter(attr.to_sym)
+      if opts
+        q = params[:query]
+        items = find_with_data_filter(opts) { send("#{attr}_contains", q) }
+
+        render :text => "<ul>\n" + items.map {|i| "<li>#{i.send(attr)}</li>\n"}.join + "</ul>"
+      else
+        render :text => "No completer for #{attr}", :status => 404
+      end
+    end
+
+
+    ###### END OF ACTIONS ######
+
+    protected
+    
+    def overridable_response(options, key)
+      if options.has_key?(key)
+        options[key]
+        true
+      else
+        yield if block_given?
+        false
+      end
+    end
+    
+    # --- action implementations --- #
+    
+    def hobo_index(options = {})
+      options = LazyHash.new(options)
+      @model = model
+      @this = options[:collection] || paginated_find
+
+      instance_variable_set("@#{@model.name.pluralize.underscore}", @this)
+      if block_given?
+        yield
+      else
+        hobo_render
+      end
+    end
+    
+
+    def paginated_find(*args, &b)
+      options = extract_options_from_args!(args)
+      
+      total_number = options.delete(:total_number)
+      if args.empty?
+        total_number ||= count_with_data_filter
+      else
+        owner, collection_name = args
+        @association = collection_name.to_s.split(".").inject(owner) { |m, name| m.send(name) }
+        total_number ||= @association.size
+        @reflection = @association.proxy_reflection
+      end
+      
+      page_size = options.delete(:page_size) || 20
+      page = options.delete(:page) || params[:page]
+      @pages = ::ActionController::Pagination::Paginator.new(self, total_number, page_size, page)
+
+      options = {
+        :limit  => @pages.items_per_page,
+        :offset => @pages.current.offset,
+      }.merge(options)
+      
+      if @association
+        @association.find(:all, options, &b)
+      else
+        options[:order] = :default
+        find_with_data_filter(options, &b)
+      end
+    end
+    
+    
+    def find_instance_or_not_found(options, this_option)
+      x = begin
+            options[this_option] || find_instance
+          rescue ActiveRecord::RecordNotFound
+            nil
+          end
+      
+      not_found unless x
+      x
+    end
+    
+    
+    def hobo_show(options={})
+      options = LazyHash.new(options)
+      
+      @this = find_instance_or_not_found(options, :this)
+      if @this
+        if Hobo.can_view?(current_user, @this)
+          set_named_this!
+          block_given? ? yield : hobo_render
+        else
+          permission_denied(options)
+        end
+      end
+    end
+
+
+    def hobo_new(options={})
+      options = LazyHash.new(options)
+      @this = options[:this] || model.new
+      @this.created_by(current_user) unless options.has_key?(:set_creator) && !options[:set_creator]
+      
+      if Hobo.can_create?(current_user, @this)
+        set_named_this!
+        block_given? ? yield : hobo_render
+      else
+        permission_denied(options)
+      end
+    end
+    
+    
+    def hobo_create(options={})
+      options = LazyHash.new(options)
+      
+      @this = (options[:this] || 
+               begin
+                 attributes = params[model.name.underscore]
+                 type_attr = params['type']
+                 create_model = if 'type'.in?(model.column_names) and 
+                                    type_attr and type_attr.in?(model.send(:subclasses).omap{name})
+                                  type_attr.constantize
+                                else
+                                  model
+                                end
+                 this = create_model.new
+                 @check_create_permission = [this]
+                 initialize_from_params(this, attributes)
+                 for obj in @check_create_permission
+                   permission_denied(options) and return unless Hobo.can_create?(current_user, obj)
+                 end
+                 @check_create_permission = nil
+                 this
+               end)
+
+      set_named_this!
+      if @this.save
+        if block_given?
+          yield 
+        else
+          respond_to do |wants|
+            wants.html { overridable_response(options, :html_response)  || redirect_to(object_url(@this)) }
+            wants.js   { overridable_response(options, :js_response) || hobo_ajax_response || render(:text => "") }
+          end
+        end
+      else
+        # Validation errors
+        unless options[:invalid_response]
+          respond_to do |wants|
+            wants.html { overridable_response(options, :invalid_html_response) || hobo_render(:new) }
+            wants.js do
+              (overridable_response(options, :invalid_js_response) ||
+               render(:status => 500,
+                      :text => ("There was a problem creating that #{create_model.name}.\n" +
+                                @this.errors.full_messages.join("\n"))))
+            end
+          end
+        end
+      end
+    end
+    
+    def hobo_edit(options={})
+      hobo_show(options)
+    end    
+    
+    
+    def hobo_update(options={})
+      options = LazyHash.new(options)
+      
+      @this = find_instance_or_not_found(options, :this)
+      return unless @this
+      
+      original = @this.duplicate
+      
+      changes = params[model.name.underscore]
+      
+      if changes
+        # The 'duplicate' call above can set these, but they can
+        # conflict with the changes so we clear them
+        @this.send(:clear_aggregation_cache)
+        @this.send(:clear_association_cache)
+        
+        update_with_params(@this, changes)
+        permission_denied(options) and return unless Hobo.can_update?(current_user, original, @this)
+      end
+      
+      set_named_this!
+      if changes.nil? || @this.save
+        # Ensure current_user isn't out of date
+        @current_user = @this if @this == current_user
+        
+        if block_given?
+          yield
+        else
+          respond_to do |wants|
+            wants.html do
+              overridable_response(options, :html_response) || redirect_to(object_url(@this))
+            end
+
+            wants.js do
+              overridable_response(options, :js_response) do
+                if changes.size == 1
+                  # Decreasingly hacky support for the scriptaculous in-place-editor
+                  new_val = Hobo::Dryml.render_tag(@template, "show",
+                                                   :obj => @this, :attr => changes.keys.first, :no_span => true)
+                  hobo_ajax_response(@this, :new_field_value => new_val)
+                else
+                  hobo_ajax_response(@this)
+                end
+                
+                # Maybe no ajax requests were made
+                render :nothing => true unless performed?
+              end
+            end
+          end
+        end
+          
+      else
+        # Validation errors
+        respond_to do |wants|
+          wants.html do
+            overridable_response(options, :invalid_html_response) || render(:action => :edit)
+          end
+
+          wants.js do
+            overridable_response(options, :invalid_js_response) do
+              render(:status => 500,
+                     :text => ("There was a problem with that change.\n" +
+                               @this.errors.full_messages.join("\n")))
+            end
+          end
+        end
+      end
+    end
+    
+    
+    def hobo_destroy(options={})
+      options = LazyHash.new(options)
+      @this = find_instance_or_not_found(options, :this)
+      return unless @this
+      
+      set_named_this!
+      permission_denied(options) and return unless Hobo.can_delete?(current_user, @this)
+
+      @this.destroy
+
+      if block_given?
+        yield
+      else
+        respond_to do |wants|
+          wants.html { overridable_response(options, :html_response) || redirect_to(:action => "index") }
+          wants.js   { overridable_response(options, :js_response) || hobo_ajax_response || render(:text => "") }
+        end
+      end
+    end
+
+    def hobo_show_collection(collection, options={})
+      options = LazyHash.new(options)
+      
+      @owner = find_instance_or_not_found(options, :owner)
+      return unless @owner
+      
+      toplevel_collection = collection.to_s.split(".").first
+      if Hobo.can_view?(current_user, @owner, toplevel_collection)
+        @this = options[:collection] || @this = paginated_find(@owner, collection, options)
+        
+        if block_given?
+          yield
+        else
+          hobo_render(params[:action]) or hobo_render(:show_collection, @reflection.klass)
+        end
+      else
+        permission_denied(options)
+      end
+    end
+    
+    
+    def hobo_new_in_collection(collection, options={})
+      options = LazyHash.new(options)
+      @owner = find_instance_or_not_found(options, :owner)
+      return unless @owner
+      
+      permission_denied(options) and return unless Hobo.can_view?(current_user, @owner, collection)
+      
+      @association = options[:collection] || @owner.send(collection)
+      @this = options[:this] || @association.new_without_appending
+      @this.created_by(current_user) unless options.has_key?(:set_creator) && !options[:set_creator]
+
+      permission_denied(options) and return unless Hobo.can_create?(current_user, @this)
+      
+      if block_given?
+        yield
+      else
+        hobo_render("new_#{collection.to_s.singularize}") or hobo_render(:new_in_collection, @this.class)
+      end
+    end
+    
+    
+    # --- end action implementations --- #
+
+    # --- filters --- #
+    
+    def prepare_web_method(method)
+      @this = find_instance
+      permission_denied unless Hobo.can_call?(current_user, @this, method)
+    end
+    
+    # --- end filters --- #
+    
+
+    def set_no_cache_headers
+      headers["Pragma"] = "no-cache"
+      #headers["Cache-Control"] = ["must-revalidate", "no-cache", "no-store"]
+      #headers["Cache-Control"] = "no-cache"
+      headers["Cache-Control"] = "no-store"
+      headers["Expires"] ='0'
+    end
+
+
+    def permission_denied(options=nil)
+      if options and options[:permission_denied_response]
+        # do nothing (callback handled by LazyHash)
+      elsif respond_to? :permission_denied_response
+        permission_denied_response
+      else
+        render :text => "Permission Denied", :status => 403
+      end
+    end
+    
+    def not_found(options=nil)
+      if options && options[:not_found_response]
+        # do nothing (callback handled by LazyHash)
+      elsif respond_to? :not_found_response
+        not_found_response
+      else
+        render(:text => "Can't find #{model.name.titleize}: #{params[:id]}", :status => 404)
+      end
+    end
+
+    def find_instance(id=nil)
+      res = self.class.find_instance(id || params[:id])
+      instance_variable_set("@#{model.name.underscore}", res)
+      res
+    end
+    
+    def set_named_this!
+      instance_variable_set("@#{model.name.underscore}", @this)      
+    end
+
+
+    def hobo_render(page_kind = nil, page_model=nil)
+      page_kind ||= params[:action].to_sym
+      page_model ||= model
+      
+      template = Hobo::ModelController.find_model_template(page_model, page_kind)
+
+      if template
+        render :template => template
+        true
+      else
+        if page_kind.in? GENERIC_PAGE_TAGS
+          render_tag("#{page_kind}_page", :obj => @this)
+          true
+        else
+          false
+        end
+      end
+    end
+
+
+    def model
+      self.class.model
+    end
+
+
+    def find_template
+      Hobo::ModelController.find_model_template(model, params[:action])
+    end
+
+
+    def with_data_filter(operation, *args, &block)
+      filter_param = params.keys.ofind {starts_with? "where_"}
+      proc = filter_param && self.class.data_filter(filter_param[6..-1].to_sym)
+      if proc
+        filter_args = params[filter_param]
+        filter_args = [filter_args] unless filter_args.is_a? Array
+        model.send(operation, *args) do
+          if block
+            instance_eval(&block) & instance_exec(*filter_args, &proc)
+          else
+            instance_exec(*filter_args, &proc)
+          end
+        end
+      else
+        if block
+          model.send(operation, *args) { instance_eval(&block) }
+        else
+          model.send(operation, *args)
+        end
+      end
+    end
+    
+    def find_with_data_filter(opts={}, &b)
+      with_data_filter(:find, :all, opts, &b)
+    end
+    
+    
+    def count_with_data_filter(opts={}, &b)
+      with_data_filter(:count, opts, &b)
+    end
+    
+
+    def initialize_from_params(obj, params)
+      update_with_params(obj, params)
+      obj.created_by(current_user)
+      (@check_create_permission ||= []) << obj
+      obj
+    end
+
+
+    def update_with_params(object, params)
+      return unless params
+
+      params.each_pair do |field,value|
+        field = field.to_sym
+        refl = object.class.reflections[field]
+        ar_value = if refl
+                     if refl.macro == :belongs_to
+                       associated_record(object, refl, value)
+
+                     elsif Hobo.simple_has_many_association?(refl) and object.new_record?
+                       # only populate has_many relationships for new records. For existing
+                       # records, AR updates the DB immediately, bypassing Hobo's permission check
+                       if value.is_a? Array
+                         value.map {|x| associated_record(object, refl, x) }
+                       else
+                         value.keys.every(:to_i).sort.map{|i| associated_record(object, refl, value[i.to_s]) }
+                       end
+                     else
+                       raise HoboError.new("association #{refl.name} is not settable via parameters")
+                     end
+                   else
+                     param_to_value(object.class.field_type(field), value)
+                   end
+        object.send("#{field}=".to_sym, ar_value)
+      end
+    end
+
+    
+    def parse_datetime(s)
+      defined?(Chronic) ? Chronic.parse(s) : Time.parse(s)
+    end
+
+
+    def param_to_value(field_type, value)
+      if field_type <= Date
+        if value.is_a? Hash
+          Date.new(*(%w{year month day}.map{|s| value[s].to_i}))
+        elsif value.is_a? String
+          dt = parse_datetime(value)
+          dt && dt.to_date
+        end
+      elsif field_type <= Time
+        if value.is_a? Hash
+          Time.local(*(%w{year month day hour minute}.map{|s| value[s].to_i}))
+        elsif value.is_a? String
+          parse_datetime(value)
+        end
+      else
+        # primitive field
+        value
+      end
+    end
+
+    def associated_record(owner, refl, value)
+      if value.is_a? String
+        if value.starts_with?('@')
+          Hobo.object_from_dom_id(value[1..-1])
+        elsif refl.klass.id_name?
+          refl.klass.find_by_id_name(value)
+        else
+          nil
+        end
+      else
+        if refl.macro == :belongs_to
+          new_from_params(refl.klass, value)
+        else
+          obj = owner.send(refl.name).new
+          initialize_from_params(obj, value)
+          obj
+        end
+      end
+    end
+
+
+    def object_from_param(param)
+      Hobo.object_from_dom_id(param)
+    end
+
+  end
+
+end