clevic 0.12.0 → 0.13.0.b1

data/lib/clevic/field_valuer.rb

@@ -0,0 +1,165 @@
+module Clevic
+  # to be included in something that responds to entity and field
+  # used for getting values from the entity based on the definitions
+  # in the field.
+  module FieldValuer
+  
+    # the value for this index
+    # used to be gui_value, but that wasn't right
+    def raw_value
+      field.value_for( entity )
+    end
+    
+    def display_value
+      field.do_format( raw_value ) unless raw_value.nil?
+    end
+    
+    def edit_value
+      field.do_edit_format( raw_value ) unless raw_value.nil?
+    end
+    
+    # Set the value from an editable text representation
+    # of the value
+    def edit_value=( value )
+      # translate the value from the ui to something that
+      # the model will understand
+      self.attribute_value =
+      case
+        # allow flexibility in entering dates. For example
+        # 16jun, 16-jun, 16 jun, 16 jun 2007 would be accepted here
+        # TODO need to be cleverer about which year to use
+        # for when you're entering 16dec and you're in the next
+        # year
+        when [:date,:datetime].include?( field.meta.type ) && value =~ %r{^(\d{1,2})[ /-]?(\w{3})$}
+          Date.parse( "#$1 #$2 #{Time.now.year.to_s}" )
+        
+        # if a digit only is entered, fetch month and year from
+        # previous row
+        when [:date,:datetime].include?( field.meta.type ) && value =~ %r{^(\d{1,2})$}
+          # year,month,day
+          prev_date = prev.attribute_value
+          if prev_date
+            Date.new( prev_date.year, prev_date.month, $1.to_i )
+          else
+            value
+          end
+        
+        # this one is mostly to fix date strings that have come
+        # out of the db and been formatted
+        when [:date,:datetime].include?( field.meta.type ) && value =~ %r{^(\d{2})[ /-](\w{3})[ /-](\d{2})$}
+          Date.parse( "#$1 #$2 20#$3" )
+        
+        # allow lots of flexibility in entering times
+        # 01:17, 0117, 117, 1 17, are all accepted
+        when field.meta.type == :time && value =~ %r{^(\d{1,2}).?(\d{2})$}
+          Time.parse( "#$1:#$2" )
+        
+        # remove thousand separators, allow for space and comma
+        # instead of . as a decimal separator
+        when field.meta.type == :decimal
+          # do various transforms
+          case
+            # accept a space or a comma instead of a . for floats
+            when value =~ /(.*?)(\d)[ ,](\d{2})$/
+              "#$1#$2.#$3"
+            else
+              value
+          end.gsub( ',', '' ) # strip remaining commas
+        
+        else
+          value
+      end
+    end
+    
+    def find_related( attribute, value )
+      candidates = field.related_class.adaptor.find( :all, :conditions => {attribute => value} )
+      if candidates.size != 1
+        raise "#{candidates.size} != 1 candidates for #{value}: #{candidates.inspect}"
+      end
+      candidates.first
+    end
+  
+    # set the field value from a value that could be
+    # a text representation a-la edit_value, or possible
+    # a name from a related entity
+    def text_value=( value )
+      case field.display
+      when Symbol
+        # we have a related class of some kind, 
+        self.attribute_value = find_related( field.display, value )
+      
+      when NilClass
+        self.edit_value = value
+      
+      when String
+        # allow plain strings, but not dotted paths
+        if field.display['.']
+          raise "display (#{field.display}) is a dotted path"
+        else
+          self.attribute_value = find_related( field.display.to_sym, value )
+        end
+      
+      else
+        raise "display is a not a symbol or nil: #{display.inspect}"
+      end
+    end
+    
+    # fetch the value of the attribute, without following
+    # the full path. This will return a related entity for
+    # belongs_to or has_one relationships, or a plain value
+    # for model attributes
+    def attribute_value
+      entity.send( field.attribute )
+    end
+    
+    # cache the writer method name since it's not likely to change
+    def writer
+      @writer ||= "#{field.attribute.to_s}="
+    end
+    
+    # set the value of the attribute, without following the
+    # full path.
+    # TODO remove need to constantly recalculate the attribute writer
+    def attribute_value=( value )
+      entity.send( writer, value )
+    end
+    
+    def tooltip
+      case
+        # show validation errors
+        when has_errors?
+          errors.join("\n")
+          
+        # provide a tooltip when an empty relational field is encountered
+        # TODO should be part of field definition
+        when field.meta.type == :association
+          field.delegate.if_empty_message
+        
+        # read-only field
+        when field.read_only?
+          field.tooltip_for( entity ) || 'Read-only'
+          
+        else
+          field.tooltip_for( entity )
+      end
+    end
+    
+    class Valuer
+      include FieldValuer
+      attr_accessor :field, :entity
+      def initialize( field, entity )
+        @field, @entity = field, entity
+      end
+    end
+    
+    def self.valuer( field, entity )
+      Valuer.new(field,entity)
+    end
+  end
+  
+  # Provides the minimum necessary for valuing, ie for irb testing
+  module SimpleFieldValuer
+    include FieldValuer
+    attr_accessor :field, :entity
+  end
+end

data/lib/clevic/filter_command.rb

@@ -7,18 +7,14 @@ module Clevic
       
       # Better make the status message now, before the indexes become invalid
       @status_message =
-      begin
-        "Filtered on #{filter_indexes.first.field.label} = #{filter_indexes.first.gui_value}"
-      rescue
-        "Filtered"
-      end
+      "Filtered on #{filter_indexes.first.field.label} = #{filter_indexes.first.display_value}"
     end
     
     # Do the filtering. Return true if successful, false otherwise.
     def doit
       begin
         # store current AR conditions
-        @stored_conditions = @table_view.model.cache_table.options
+        @stored_conditions = @table_view.model.cache_table.find_options
         
         # store auto_new
         @auto_new = @table_view.model.auto_new

data/lib/clevic/generic_format.rb

@@ -0,0 +1,52 @@
+module Clevic
+
+#includers must provide meta and display
+module GenericFormat
+  # Return true if the field is a date, datetime, time or timestamp.
+  # If display is nil, the value is calculated, so we need
+  # to check the value. Otherwise use the field metadata.
+  # Cache the result for the first non-nil value.
+  def is_date_time?( value )
+    if value.nil?
+      false
+    else
+      @is_date_time ||=
+      if display.nil?
+        [:time, :date, :datetime, :timestamp].include?( meta.type )
+      else
+        # it's a virtual field, so we need to use the value
+        value.is_a?( Date ) || value.is_a?( Time )
+      end
+    end
+  end
+  
+  # apply format to value. Use strftime for date_time types, or % for everything else.
+  # If format is a proc, pass value to it.
+  def do_generic_format( format, value )
+    begin
+      unless format.nil?
+        if format.is_a? Proc
+          format.call( value )
+        else
+          if is_date_time?( value )
+            value.strftime( format )
+          else
+            format % value
+          end
+        end
+      else
+        value
+      end
+    rescue Exception => e
+      puts "format: #{format.inspect}"
+      puts "value.class: #{value.class.inspect}"
+      puts "value: #{value.inspect}"
+      puts e.message
+      puts e.backtrace
+      nil
+    end
+  end
+  
+end
+
+end

data/lib/clevic/many_field.rb

@@ -0,0 +1,7 @@
+module Clevic
+
+# Field for the other end of a one-to-many, or maybe also a many-to-many.
+class ManyField < Field
+end
+
+end

data/lib/clevic/model_builder.rb

@@ -1,9 +1,7 @@
-require 'activerecord'
-require 'facets/dictionary'
+# TODO not needed for 1.9
+require 'hashery/orderedhash'
 
 require 'clevic/table_model.rb'
-require 'clevic/delegates.rb'
-require 'clevic/text_delegate.rb'
 require 'clevic/cache_table.rb'
 require 'clevic/field.rb'
 
@@ -21,99 +19,187 @@ you need it.
 
 To that end, there are 2 ways to define UIs:
 
-- an Embedded View as part of the ActiveRecord object (which is useful if you 
+- an Embedded View as part of the model (Sequel::Model) object (which is useful if you 
   want minimal framework overhead). Just show me the data, dammit.
 
 - a Separate View in a separate class (which is useful when you want several 
   diffent views of the same underlying table). I want a neato-nifty UI that does
   (relatively) complex things.
 
-I've tried to consistently refer to an instance of an ActiveRecord::Base subclass
-as an 'entity'.
+I've tried to consistently refer to an instance of an Sequel::Model subclass as an 'entity'.
 
 ==Embedded View
 Minimal embedded definition is
 
-  class Position < ActiveRecord::Base
+  class Position < Sequel::Model
     include Clevic::Record
   end
 
 which will build a fairly sensible default UI from the
 entity's metadata. Obviously you can use open classes to do
 
+  class Position < Sequel::Model
+    one_to_many :transactions
+    many_to_one :account
+  end
+
   class Position
     include Clevic::Record
   end
 
-where Position is previously defined to inherit from ActiveRecord::Base.
-
 A full-featured UI for an entity called Entry (part of an accounting database)
 could be defined like this:
 
-  class Entry < ActiveRecord::Base
+  class Entry < Sequel::Model
+    belongs_to :invoice
+    belongs_to :activity
+    belongs_to :project
+    
     include Clevic::Record
     
-    # ActiveRecord foreign key definition
-    belongs_to :debit, :class_name => 'Account', :foreign_key => 'debit_id'
-    # ActiveRecord foreign key definition
-    belongs_to :credit, :class_name => 'Account', :foreign_key => 'credit_id'
-
+    # spans of time more than 8 ours are coloured violet
+    # because they're often the result of typos.
+    def time_color
+      return if self.end.nil? || start.nil?
+      'darkviolet' if self.end - start > 8.hours
+    end
+    
+    # tooltip for spans of time > 8 hours
+    def time_tooltip
+      return if self.end.nil? || start.nil?
+      'Time interval greater than 8 hours' if self.end - start > 8.hours
+    end
+    
     define_ui do
-      # :format and :edit_format are optional, in fact these are the defaults
-      plain       :date, :format => '%d-%h-%y', :edit_format => '%d-%h-%Y'
-      plain       :start, :format => '%H:%M'
-      plain       :amount, :format => '%.2f'
-      # :set is mandatory for a restricted field
-      restricted  :vat, :label => 'VAT', :set => %w{ yes no all }, :tooltip => 'Is VAT included?'
+      plain       :date, :sample => '28-Dec-08'
       
-      # alternately with a block for readability
-      restricted :vat do
-        label   'VAT'
-        set     %w{ yes no all }
-        tooltip 'Is VAT included?'
+      # The project field
+      relational  :project do |field|
+        field.display = 'project'
+        field.conditions = 'active = true'
+        field.order = 'lower(project)'
+        
+        # handle data changed events. In this case,
+        # auto-fill-in the invoice field.
+        field.notify_data_changed do |entity_view, table_view, model_index|
+          if model_index.entity.invoice.nil?
+            entity_view.invoice_from_project( table_view, model_index ) do
+              # move here next if the invoice was changed
+              table_view.override_next_index model_index.choppy( :column => :start )
+            end
+          end
+        end
       end
       
-      # distinct will retrieve from the table all other values for this field
-      # and display them in the combo.
-      distinct    :description, :conditions => 'now() - date <= interval( 1 year )'
-
-      # this is a read-only field
-      plain       :origin, :read_only => true
+      relational  :invoice, :display => 'invoice_number', :conditions => "status = 'not sent'", :order => 'invoice_number'
       
-      # :format is an attribute on the related
-      # ActiveRecord entity, in this case an instance of Account
-      # :order is an ActiveRecord option to find, defining the order in which related entries will be displayed.
-      # :conditions is an ActiveRecord option to find, defining the subset of related entries to be displayed.
-      relational  :debit, :format => 'name', :conditions => 'active = true', :order => 'lower(name)'
-      relational  :credit, :format => 'name', :conditions => 'active = true', :order => 'lower(name)'
+      # call time_color method for foreground color value
+      plain       :start, :foreground => :time_color, :tooltip => :time_tooltip
       
-      # or like this to have an on-the-fly transform. item will be an instance of Account.
-      # This also takes a block parameter
-      relational :credit do |field|
-        field.format = lambda {|item| item.name.downcase}
-        field.conditions = 'active = true'
-        field.order = 'lower(name)'
+      # another way to call time_color method for foreground color value
+      plain       :end, :foreground => lambda{|x| x.time_color}, :tooltip => :time_tooltip
+      
+      # multiline text
+      text        :description, :sample => 'This is a long string designed to hold lots of data and description'
+      
+      relational :activity do
+        display    'activity'
+        order      'lower(activity)'
+        sample     'Troubleshooting'
+        conditions 'active = true'
       end
       
-      # this is a read-only display field from a related table
-      # the Entry class should then define a method called currency
-      # which returns an object that responds to 'short'.
-      # You can also use a Proc for :display
-      plain :currency, :display => 'short', :label => 'Currency'
+      distinct    :module, :tooltip => 'Module or sub-project'
+      plain       :charge, :tooltip => 'Is this time billable?'
+      distinct    :person, :default => 'John', :tooltip => 'The person who did the work'
       
-      # this is a read-only display field from a related table
-      # the Entry class should then define a method called currency
-      # which returns an object that responds to 'currency', which
-      # returns an object that responds to 'rate'.
-      # You can also use a Proc for :display
-      plain :some_field, :display => 'currency.rate', :label => 'Exchange Rate'
+      records     :order => 'date, start, id'
+    end
+
+    def self.define_actions( view, action_builder )
+      action_builder.action :smart_copy, 'Smart Copy', :shortcut => 'Ctrl+"' do
+        smart_copy( view )
+      end
       
-      # this is optional. By default all records in id order will be displayed.
-      records :order => 'date,start'
+      action_builder.action :invoice_from_project, 'Invoice from Project', :shortcut => 'Ctrl+Shift+I' do
+        invoice_from_project( view, view.current_index ) do
+          # execute the block if the invoice is changed
+          
+          # save this before selection model is cleared
+          current_index = view.current_index
+          view.selection_model.clear
+          view.current_index = current_index.choppy( :column => :start )
+        end
+      end
+    end
+    
+    # do a smart copy from the previous line
+    def self.smart_copy( view )
+      view.sanity_check_read_only
+      view.sanity_check_ditto
       
-      # could also be like this, where a..e are instances of Entry
-      records [ a,b,c,d,e ]
+      # need a reference to current_index here, because selection_model.clear will
+      # invalidate view.current_index. And anyway, its shorter and easier to read.
+      current_index = view.current_index
+      if current_index.row >= 1
+        # fetch previous item
+        previous_item = view.model.collection[current_index.row - 1]
+        
+        # copy the relevant fields
+        current_index.entity.date = previous_item.date if current_index.entity.date.blank?
+        # depends on previous line
+        current_index.entity.start = previous_item.end if current_index.entity.date == previous_item.date
+        
+        # copy rest of fields
+        [:project, :invoice, :activity, :module, :charge, :person].each do |attr|
+          current_index.entity.send( "#{attr.to_s}=", previous_item.send( attr ) )
+        end
+        
+        # tell view to update
+        view.model.data_changed do |change|
+          change.top_left = current_index.choppy( :column => 0 )
+          change.bottom_right = current_index.choppy( :column => view.model.fields.size - 1 )
+        end
+        
+        # move to the first empty time field
+        next_field =
+        if current_index.entity.start.blank?
+          :start
+        else
+          :end
+        end
+        
+        # next cursor location
+        view.selection_model.clear
+        view.current_index = current_index.choppy( :column => next_field )
+      end
+    end
+
+    # Auto-complete invoice number field from project.
+    # &block will be executed if an invoice was assigned
+    # If block takes one parameter, pass the new invoice.
+    def self.invoice_from_project( table_view, current_index, &block )
+      if current_index.entity.project != nil
+        # most recent entry, ordered in reverse
+        invoice = current_index.entity.project.latest_invoice
+        unless invoice.nil?
+          # make a reference to the invoice
+          current_index.entity.invoice = invoice
+          
+          # update view from top_left to bottom_right
+          table_view.model.data_changed( current_index.choppy( :column => :invoice ) )
+          
+          unless block.nil?
+            if block.arity == 1
+              block.call( invoice )
+            else
+              block.call
+            end
+          end
+        end
+      end
     end
+    
   end
 
 == Separate View
@@ -121,7 +207,7 @@ could be defined like this:
 To define a separate ui class, do something like this:
   class Prospect < Clevic::View
     
-    # This is the ActiveRecord::Base descendant
+    # This is the Sequel::Model descendant
     entity_class Position
     
     # This must return a ModelBuilder instance, which is made easier
@@ -136,6 +222,8 @@ To define a separate ui class, do something like this:
         # use the define_ui block from Position
         mb.exec_ui_block( Position )
         
+        # any other ModelBuilder code can go here too
+        
         # use a different recordset
         mb.records :conditions => "status in ('prospect','open')", :order => 'date desc,code'
       end
@@ -174,6 +262,9 @@ can use DSL-style acessors (no assignment =) or assignment statement.
   plain
 is an ordinary editable field. Boolean values are displayed as checkboxes.
 
+  text
+is a multiline editable field.
+
   relational
 displays a set of values pulled from a belongs_to (many-to-one) relationship.
 In other words all the possible related entities that this one could belong_to. Some
@@ -198,7 +289,7 @@ definition from somewhere else. It may go away and be replaced by remove.
 The attribute symbol is required, and is the first parameter after the field type. It must refer
 to a method already defined in the entity. In other words any of:
 - a db column
-- a relationship (belongs_to, has_many, etc)
+- a relationship (one_to_many, etc)
 - a plain method that takes no parameters.
 
 will work. Named scopes might also work, but I haven't tried them yet.
@@ -223,7 +314,7 @@ See Clevic::Field properties for available options.
 
 === Menu Items
 
-You can define view/model specific actions ( an Action is Qt talk for menu items and shortcuts).
+You can define view/model specific menu items.
 These will be added to the Edit menu, show up on context-click in the table
 display, and can have optional keyboard shortcuts:
 
@@ -242,17 +333,20 @@ display, and can have optional keyboard shortcuts:
   
 === Notifications
 
-The following method will be called whenever data is changed, ie a field edit is completed:
-
-  def notify_data_changed( table_view, top_left_model_index, bottom_right_model_index )
-  end
-  
 Key presses will be sent here:
 
+  # may also be defined as class methods on an entity class.
   def notify_key_press( table_view, key_press_event, current_model_index )
   end
 
-The above may also be defined as class methods on an entity class.
+Fields have a property called notify_data_changed, which is called whenever
+the field value changes. There is also an view method:
+
+  def notify_data_changed( table_view, top_left_model_index, bottom_right_model_index )
+  end
+
+But note that this will override the delegation to the field notify_data_changed
+unless super is called.
 
 === Tab Order
 
@@ -271,11 +365,14 @@ class ModelBuilder
   
   # Create a definition for entity_view (subclass of Clevic::View).
   # Then execute block using self.instance_eval.
+  # entity_view must respond to entity_class, and if title is called, it
+  # must respond to title.
   def initialize( entity_view, &block )
     @entity_view = entity_view
     @auto_new = true
     @read_only = false
-    @fields = Dictionary.new
+    # TODO not needed for 1.9
+    @fields = OrderedHash.new
     exec_ui_block( &block )
   end
   
@@ -304,7 +401,8 @@ class ModelBuilder
   # The collection of Clevic::Field instances where visible == true.
   # the visible may go away.
   def fields
-    @fields.reject{|id,field| !field.visible}
+    #~ @fields.reject{|id,field| !field.visible}
+    @fields
   end
   
   # return the index of the named field in the collection of fields.
@@ -314,7 +412,7 @@ class ModelBuilder
     retval
   end
   
-  # The ActiveRecord::Base subclass
+  # The ORM class
   def entity_class
     @entity_view.entity_class
   end
@@ -331,18 +429,29 @@ class ModelBuilder
   
   # should this table automatically show a new blank record?
   def auto_new?; @auto_new; end
+  
+  # DSL for changing the title
+  def title( value )
+    entity_view.title = value
+  end
 
   # an ordinary field, edited in place with a text box
   def plain( attribute, options = {}, &block )
     read_only_default!( attribute, options )
-    @fields[attribute] = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
+    field = @fields[attribute] = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
+    field.delegate = 
+    if field.meta.type == :boolean
+      BooleanDelegate.new( field )
+    else
+      TextDelegate.new( field )
+    end
   end
   
   # an ordinary field like plain, except that a larger edit area can be used
   def text( attribute, options = {}, &block )
     read_only_default!( attribute, options )
     field = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
-    field.delegate = TextDelegate.new( nil, field )
+    field.delegate = TextAreaDelegate.new( field )
     @fields[attribute] = field
   end
   
@@ -350,7 +459,7 @@ class ModelBuilder
   # a combo box containing all values for this field from the table.
   def distinct( attribute, options = {}, &block )
     field = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
-    field.delegate = DistinctDelegate.new( nil, field )
+    field.delegate = DistinctDelegate.new( field )
     @fields[attribute] = field
   end
   
@@ -364,7 +473,7 @@ class ModelBuilder
       field.format ||= lambda{|x| field.set[x]}
     end
     
-    field.delegate = SetDelegate.new( nil, field )
+    field.delegate = SetDelegate.new( field )
     @fields[attribute] = field
   end
 
@@ -373,23 +482,37 @@ class ModelBuilder
     options[:restricted] = true
     combo( attribute, options, &block )
   end
-
-  # for foreign keys. Edited with a combo box using values from the specified
+  
+  # For many_to_one relationships.
+  # Edited with a combo box using values from the specified
   # path on the foreign key model object
   # if options[:format] has a value, it's used either as a block
   # or as a dotted path
   def relational( attribute, options = {}, &block )
     field = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
-    if field.class_name.nil?
-      field.class_name = entity_class.reflections[attribute].class_name || attribute.to_s.classify
-    end
+    field.delegate = RelationalDelegate.new( field )
+    @fields[attribute] = field
+  end
+  
+  def tags( attribute, options = {}, &block )
+    field = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
     
-    # check after all possible options have been collected
-    raise ":display must be specified" if field.display.nil?
-    field.delegate = RelationalDelegate.new( nil, field )
+    # build a collection setter if necessary
+    unless entity_class.instance_methods.include? "#{attribute}="
+      raise NotImplementedError, "Need to build a collection setter for '#{attribute}='"
+    end
+  
+    field.delegate = TagDelegate.new( field )
     @fields[attribute] = field
   end
 
+  # force a checkbox
+  def check( attribute, options = {}, &block )
+    read_only_default!( attribute, options )
+    field = @fields[attribute] = Clevic::Field.new( attribute.to_sym, entity_class, options, &block )
+    field.delegate = BooleanDelegate.new( field )
+  end
+  
   # mostly used in the new block to define the set of records
   # for the TableModel, but may also be
   # used as an accessor for records.
@@ -411,7 +534,7 @@ class ModelBuilder
   # as editable in the table. Any belongs_to relations are used to build
   # combo boxes. Default ordering is the primary key.
   # Subscriber is already defined elsewhere as a subclass
-  # of ActiveRecord::Base:
+  # of an ORM class ie Sequel::Model:
   #   class Subscriber
   #     include Clevic::Record
   #     define_ui do
@@ -427,51 +550,26 @@ class ModelBuilder
   # * :name
   # * :title
   # * :username
+  # * :to_s
   def default_ui
-    # combine reflections and attributes into one set
-    reflections = entity_class.reflections.keys.map{|x| x.to_s}
-    ui_columns = entity_class.columns.reject{|x| x.name == entity_class.primary_key }.map do |column|
-      # TODO there must be a better way to do this
-      att = column.name.gsub( /_id$/, '' )
-      if reflections.include?( att )
-        att
-      else
-        column.name
-      end
-    end
-    
     # don't create an empty record, because sometimes there are
     # validations that will cause trouble
     auto_new false
     
     # build columns
-    ui_columns.each do |column|
-      if entity_class.reflections.has_key?( column.to_sym )
-        begin
-          reflection = entity_class.reflections[column.to_sym]
-          if reflection.class == ActiveRecord::Reflection::AssociationReflection
-            related_class = reflection.class_name.constantize
-            
-            # try to find a sensible display class. Default to to_s
-            display_method =
-            %w{#{entity_class.name} name title username}.find( lambda{ 'to_s' } ) do |m|
-              related_class.column_names.include?( m ) || related_class.instance_methods.include?( m )
-            end
-            
-            # set the display method
-            relational column.to_sym, :display => display_method
-          else
-            plain column.to_sym
-          end
-        rescue
-          puts $!.message
-          puts $!.backtrace
-          # just do a plain
-          puts "Doing plain for #{entity_class}.#{column}"
-          plain column.to_sym
+    entity_class.attributes.each do |column,model_column|
+      begin
+        if model_column.association?
+          relational column
+        else
+          plain column
         end
-      else
-        plain column.to_sym
+      rescue
+        puts $!.message
+        puts $!.backtrace
+        # just do a plain
+        puts "Doing plain for #{entity_class}.#{column}"
+        plain column
       end
     end
     records :order => entity_class.primary_key
@@ -484,22 +582,27 @@ class ModelBuilder
   
   # This takes all the information collected
   # by the other methods, and returns a new TableModel
-  # with the given table_view as its parent.
-  def build( table_view )
+  # with the given parent (usually a TableView) as its parent.
+  def build( parent )
     # build the model with all it's collections
     # using @model here because otherwise the view's
     # reference to this very same model is garbage collected.
-    @model = Clevic::TableModel.new( table_view )
+    @model = Clevic::TableModel.new
     @model.builder = self
     @model.entity_view = entity_view
     @model.fields = @fields.values
     @model.read_only = @read_only
     @model.auto_new = auto_new?
     
-    # setup model
-    table_view.object_name = @object_name
-    # set parent for all delegates
-    fields.each {|id,field| field.delegate.parent = table_view unless field.delegate.nil? }
+    # set view name
+    parent.object_name = @object_name if parent.respond_to? :object_name
+    
+    # set UI parent for all delegates
+    # and model for each field
+    fields.each do |id,field|
+      field.delegate.parent = parent unless field.delegate.nil?
+      field.model = @model
+    end
     
     # the data
     @model.collection = records
@@ -509,19 +612,6 @@ class ModelBuilder
   
 protected
 
-  # Add ActiveRecord :include options for foreign keys, but it takes up too much memory,
-  # and actually takes longer to load a data set.
-  #--
-  # TODO ActiveRecord-2.1 has smarter includes
-  def add_include_options
-    fields.each do |id,field|
-      if field.delegate.class == RelationalDelegate
-        @options[:include] ||= []
-        @options[:include] << field.attribute
-      end
-    end
-  end
-
   # set a sensible read-only value if it isn't already specified in options
   def read_only_default!( attribute, options )
     # sensible defaults for read-only-ness
@@ -537,8 +627,7 @@ protected
         
       when entity_class.reflections.include?( attribute )
         # one-to-one relationships can be edited. many-to-one certainly can't
-        reflection = entity_class.reflections[attribute]
-        reflection.macro != :has_one
+        entity_class.meta[attribute].type != :many_to_one
         
       when entity_class.instance_methods.include?( attribute.to_s )
         # read-only if there's no setter for the attribute
@@ -566,7 +655,6 @@ protected
   # Called by records( *args )
   def get_records
     if @records.nil?
-      #~ add_include_options
       @records = CacheTable.new( entity_class, @find_options )
     end
     @records