clevic 0.7.0 → 0.8.0

data/lib/clevic/cache_table.rb

@@ -130,11 +130,12 @@ class CacheTable < Array
     # build case statement, including recusion
     st = <<-EOF
 case
-  when #{quote_column attribute} #{operator} :#{attribute} then #{sql_boolean true}
-  when #{quote_column attribute} = :#{attribute} then #{build_recursive_comparison( operator, index+1 )}
+  when #{model_class.table_name}.#{quote_column attribute} #{operator} :#{attribute} then #{sql_boolean true}
+  when #{model_class.table_name}.#{quote_column attribute} = :#{attribute} then #{build_recursive_comparison( operator, index+1 )}
   else #{sql_boolean false}
 end
 EOF
+    # indent
     st.gsub!( /^/, '  ' * index )
   end
   
@@ -168,8 +169,12 @@ EOF
   end
   
   # add an id to options[:order] if it's not in there
-  # also create @order_attributes
+  # also create @order_attributes, and @auto_new
   def sanitise_options( options )
+    # save this for later
+    @auto_new = options[:auto_new]
+    options.delete :auto_new
+    
     options[:order] ||= ''
     @order_attributes = options[:order].split( /, */ ).map{|x| OrderAttribute.new(@model_class, x)}
     
@@ -281,9 +286,14 @@ EOF
     end
   end
   
+  def auto_new?
+    @auto_new
+  end
+  
+  # make sure there's always at least one empty record
   def delete_at( index )
     retval = super
-    if self.size == 0
+    if self.size == 0 && auto_new?
       self << @model_class.new
     end
     retval

data/lib/clevic/db_options.rb

@@ -12,8 +12,8 @@ connection to a particular database. Like this:
   end
 
 When the block ends, a check is done to see that the :database key
-exists. If not and exception is thrown. Finally the relevant calls to
-ActiveRecord are performed.
+exists. If not, an exception is thrown. Finally the relevant calls to
+establish the ActiveRecord connection are performed.
 
 Method calls are translated to insertions into a hash with the same
 key as the method being called. The hash is initialised
@@ -25,9 +25,10 @@ class DbOptions
   
   def initialize( options = nil )
     @options = options || {}
+    
     # make sure the relevant entries exist, so method_missing works
     @options[:adapter] ||= ''
-    @options[:host] ||= ''
+    @options[:host] ||= 'localhost'
     @options[:username] ||= ''
     @options[:password] ||= ''
     @options[:database] ||= ''
@@ -61,6 +62,7 @@ class DbOptions
   #   end
   # the block is evaluated in the context of the a new DbOptions
   # object.
+  # TODO use instance_eval
   def self.connect( args = nil, &block )
     inst = self.new( args )
     # using the Rails implementation, included in Qt
@@ -87,10 +89,13 @@ end
 
 end
 
-# workaround for the date freeze issue
-class Date
-  def freeze
-    self
+# workaround for the date freeze issue, if it exists
+begin
+  Date.new.freeze.to_s
+rescue TypeError
+  class Date
+    def freeze
+      self
+    end
   end
 end
-

data/lib/clevic/delegates.rb

@@ -365,7 +365,9 @@ class RelationalDelegate < ComboDelegate
   # send data to the editor
   def setEditorData( editor, model_index )
     if is_combo?( editor )
-      editor.current_index = editor.find_data( model_index.attribute_value.id.to_variant )
+      unless model_index.attribute_value.nil?
+        editor.current_index = editor.find_data( model_index.attribute_value.id.to_variant )
+      end
       editor.line_edit.select_all
     end
   end

data/lib/clevic/extensions.rb

@@ -132,6 +132,22 @@ module Qt
     
     attr_writer :entity
     
+    # return true if validation failed for this indexes field
+    def has_errors?
+      # virtual fields don't have metadata
+      if metadata.nil?
+        false
+      else
+        entity.errors.invalid?( field_name.to_sym )
+      end
+    end
+    
+    # return a collection of errors. Unlike AR, this
+    # will always return an array that will have zero, one
+    # or many elements.
+    def errors
+      [ entity.errors[field_name.to_sym] ].flatten
+    end
   end
 
 end

data/lib/clevic/field.rb

@@ -1,5 +1,7 @@
 require 'qtext/flags.rb'
 
+require 'clevic/field_builder.rb'
+
 module Clevic
 
 =begin rdoc
@@ -10,6 +12,8 @@ class Field
   
   attr_accessor :attribute, :path, :label, :delegate, :class_name
   attr_accessor :alignment, :format, :tooltip, :path_block
+  attr_accessor :visible
+  
   attr_writer :sample, :read_only
   
   # attribute is the symbol for the attribute on the model_class
@@ -26,6 +30,7 @@ EOF
     # set values
     @attribute = attribute
     @model_class = model_class
+    @visible = true
     
     options.each do |key,value|
       self.send( "#{key}=", value ) if respond_to?( "#{key}=" )
@@ -61,9 +66,8 @@ EOF
     end
   end
   
-  # Return the attribute value for the given entity, which may
+  # Return the attribute value for the given entity, which will probably
   # be an ActiveRecord instance
-  # entity is an ActiveRecord instance
   def value_for( entity )
     return nil if entity.nil?
     transform_attribute( entity.send( attribute ) )
@@ -86,6 +90,11 @@ EOF
     end
   end
   
+  # return true if this is a field for a related table, false otherwise.
+  def is_association?
+    meta.type == ActiveRecord::Reflection::AssociationReflection
+  end
+  
   # return true if it's a date, a time or a datetime
   # cache result because the type won't change in the lifetime of the field
   def is_date_time?
@@ -93,7 +102,8 @@ EOF
   end
   
   # return ActiveRecord::Base.columns_hash[attribute]
-  # in other words an ActiveRecord::ConnectionAdapters::Column object
+  # in other words an ActiveRecord::ConnectionAdapters::Column object,
+  # or an ActiveRecord::Reflection::AssociationReflection object
   def meta
     @model_class.columns_hash[attribute.to_s] || @model_class.reflections[attribute]
   end

data/lib/clevic/field_builder.rb

@@ -0,0 +1,42 @@
+module Clevic
+
+  class BlankSlate
+    keep_methods = %w( __send__ __id__ send class inspect instance_eval instance_variables )
+    instance_methods.each do |m|
+      undef_method(m) unless keep_methods.include?(m)
+    end
+  end
+
+  class FieldBuilder < BlankSlate
+    def initialize( hash = {} )
+      @hash = hash
+    end
+    
+    # modified from Jim Freeze's article
+    def self.dsl_accessor(*symbols)
+      symbols.each do |sym|
+        line, st = __LINE__, <<EOF
+          def #{sym}(*val)
+            if val.empty?
+              @hash[#{sym.to_sym.inspect}]
+            else
+              @hash[#{sym.to_sym.inspect}] = val.size == 1 ? val[0] : val
+            end
+          end
+EOF
+        class_eval st, __FILE__, line + 1
+      end
+    end
+    
+    # originally from Jim Freeze's article
+    def method_missing(sym, *args)
+      self.class.dsl_accessor sym
+      send(sym, *args)
+    end
+    
+    def to_hash
+      @hash
+    end
+  end
+
+end

data/lib/clevic/model_builder.rb

@@ -9,67 +9,110 @@ module Clevic
 
 =begin rdoc
 This is used to define a set of fields in a UI, any related tables,
-restrictions on data entry, formatting and that kind of thing.
+restrictions on data entry, formatting and that kind of thing. Essentially it
+defines a DSL for building a TableModel.
 
 Optional specifiers are:
 * :sample is used to size the columns. Will default to some hopefully sensible value from the db.
 * :format is something that can be understood by strftime (for time and date
-  fields) or understood by % (for everything else)
+  fields) or understood by % (for everything else). It can also be a Proc
+  that has one parameter - the current entity.
 * :alignment is one of Qt::TextAlignmentRole, ie Qt::AlignRight, Qt::AlignLeft, Qt::AlignCenter
 * :set is the set of strings that are accepted by a RestrictedDelegate
 
 In the case of relational fields, all other options are passed to ActiveRecord::Base#find
 
-For example, a the UI for a model called Entry would be defined like this:
+For example, the UI for a model called Entry could be defined like this:
 
-  Clevic::TableView.new( Entry, parent ).create_model do
-    # :format is optional
-    plain       :date, :format => '%d-%h-%y'
-    plain       :start, :format => '%H:%M'
-    plain       :amount, :format => '%.2f'
-    # :set is mandatory
-    restricted  :vat, :label => 'VAT', :set => %w{ yes no all }, :tooltip => 'Is VAT included?'
-    distinct    :description, :conditions => 'now() - date <= interval( 1 year )'
-    
-    # this is a read-only field
-    plain       :origin, :read_only => true
-    
-    # for these, :format will be a dotted attribute accessor for the related
-    # ActiveRecord entity, in this case an instance of Account
-    relational  :debit, :format => 'name', :class_name => 'Account', :conditions => 'active = true', :order => 'lower(name)'
-    relational  :credit, :format => 'name', :class_name => 'Account', :conditions => 'active = true', :order => 'lower(name)'
-    
-    # or like this to have an on-the-fly transform
-    # item will be an instance of Account
-    relational  :credit, :format => lambda {|item| item.name.downcase}, :class_name => 'Account', :conditions => 'active = true', :order => 'lower(name)', :sample => 'Leilani Member Loan'
-    
-    # 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'
-    
-    # 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'
-    
-    # this is optional
-    records :order => 'date,start'
-    
-    # could also be like this, where a..e are instances of Entry
-    records [ a,b,c,d,e ]
+  # inherit from Clevic::Record, which itself inherits from ActiveRecord::Base
+  class Entry < Clevic::Record
+    belongs_to :debit, :class_name => 'Account', :foreign_key => 'debit_id'
+    belongs_to :credit, :class_name => 'Account', :foreign_key => 'credit_id'
+
+    define_ui do
+      # :format is optional
+      plain       :date, :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?'
+      
+      # alternately with a block for readability
+      restricted :vat do
+        label   'VAT'
+        set     %w{ yes no all }
+        tooltip 'Is VAT included?'
+      end
+      
+      # distinct will show other values for this field in the combo
+      distinct    :description, :conditions => 'now() - date <= interval( 1 year )'
+
+      # this is a read-only field
+      plain       :origin, :read_only => true
+      
+      # for these, :format will be a dotted attribute accessor for the related
+      # ActiveRecord entity, in this case an instance of Account
+      relational  :debit, :format => 'name', :class_name => 'Account', :conditions => 'active = true', :order => 'lower(name)'
+      relational  :credit, :format => 'name', :class_name => 'Account', :conditions => 'active = true', :order => 'lower(name)'
+      
+      # or like this to have an on-the-fly transform
+      # item will be an instance of Account
+      relational  :credit, :format => lambda {|item| item.name.downcase}, :class_name => 'Account', :conditions => 'active = true', :order => 'lower(name)', :sample => 'Leilani Member Loan'
+      
+      # 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'
+      
+      # 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'
+      
+      # this is optional
+      records :order => 'date,start'
+      
+      # could also be like this, where a..e are instances of Entry
+      records [ a,b,c,d,e ]
+    end
   end
+  
+For ActiveRecord::Base classes, ModelBuilder knows how to build a
+fairly sensible default UI. For small tweaks, something like this
+can be used (where Subscriber is already defined elsewhere as a subclass
+of ActiveRecord::Base):
+  class Subscriber
+    post_default_ui do
+      plain :password # this field does not exist in the DB
+      hide :password_salt # these should be hidden
+      hide :password_hash
+    end
+  end
+
+Subclasses of Clevic::Record may also implement <tt>self.key_press_event( event, current_index, view )</tt>
+and <tt>self.data_changed( top_left_index, bottom_right_index, view )</tt> methods so that
+they can respond to editing events and do Neat Stuff.
 =end
 class ModelBuilder
-  # The collection of Clevic::Field objects
-  attr_reader :fields
   
-  def initialize( table_view )
-    @table_view = table_view
+  # Create a definition for model_class (subclass of ActiveRecord::Base
+  # or Clevic::Record). Then execute block using self.instance_eval.
+  # The builder will construct a default TableModel from the model_class
+  # unless can_build_default == false
+  def initialize( model_class, can_build_default = true, &block )
+    @model_class = model_class
+    @auto_new = true
+    @read_only = false
     @fields = []
+    init_from_model( model_class, can_build_default, &block )
+  end
+  
+  # The collection of visible Clevic::Field objects
+  def fields
+    @fields.reject{|x| !x.visible}
   end
   
   # return the index of the named field
@@ -79,29 +122,48 @@ class ModelBuilder
     retval
   end
   
-  # the AR class for this table
-  def model_class
-    @table_view.model_class
+  # the ActiveRecord::Base or Clevic::Record class
+  attr_reader :model_class
+  
+  # set read_only to true
+  def read_only!
+    @read_only = true
+  end
+  
+  # should this table automatically show a new blank record?
+  def auto_new( bool )
+    @auto_new = bool
   end
+  
+  def auto_new?; @auto_new; end
 
   # an ordinary field, edited in place with a text box
-  def plain( attribute, options = {} )
-    options[:read_only] = true if options.has_key?( :display )
+  def plain( attribute, options = {}, &block )
+    # get values from block, if it's there
+    options = gather_block( options, &block )
+    
+    read_only_default( attribute, options )
     @fields << Clevic::Field.new( attribute.to_sym, model_class, options )
   end
   
   # edited with a combo box containing all previous entries in this field
-  def distinct( attribute, options = {} )
+  def distinct( attribute, options = {}, &block )
+    # get values from block, if it's there
+    options = gather_block( options, &block )
+    
     field = Clevic::Field.new( attribute.to_sym, model_class, options )
-    field.delegate = DistinctDelegate.new( @table_view, attribute, @table_view.model_class, options )
+    field.delegate = DistinctDelegate.new( nil, attribute, model_class, options )
     @fields << field
   end
 
   # edited with a combo box, but restricted to a specified set
-  def restricted( attribute, options = {} )
+  def restricted( attribute, options = {}, &block )
+    # get values from block, if it's there
+    options = gather_block( options, &block )
+    
     raise "restricted must have a set" unless options.has_key?( :set )
     field = Clevic::Field.new( attribute.to_sym, model_class, options )
-    field.delegate = RestrictedDelegate.new( @table_view, attribute, @table_view.model_class, options )
+    field.delegate = RestrictedDelegate.new( nil, attribute, model_class, options )
     @fields << field
   end
 
@@ -110,29 +172,24 @@ class ModelBuilder
   # if options[:format] has a value, it's used either as a block
   # or as a dotted path
   def relational( attribute, options = {}, &block )
-    options[:display] ||= 'to_s'
     unless options.has_key? :class_name
       options[:class_name] = model_class.reflections[attribute].class_name || attribute.to_s.classify
     end
-    field = Clevic::Field.new( attribute.to_sym, model_class, options )
     
-    field.delegate = RelationalDelegate.new( @table_view, field.attribute_path, options )
+    # get values from block, if it's there
+    options = gather_block( options, &block )
+    
+    # check after all possible options have been collected
+    raise ":display must be specified" if options[:display].nil?
+    
+    field = Clevic::Field.new( attribute.to_sym, model_class, options )
+    field.delegate = RelationalDelegate.new( nil, field.attribute_path, options )
     @fields << field
   end
 
-  # add AR :include options for foreign keys, but it takes up too much memory,
-  # and actually takes longer to load a data set
-  def add_include_options
-    @fields.each do |field|
-      if field.delegate.class == RelationalDelegate
-        @options[:include] ||= []
-        @options[:include] << field.attribute
-      end
-    end
-  end
-
-  # mostly used in the create_model block, but may also be
-  # used as an accessor for records
+  # 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.
   def records( *args )
     if args.size == 0
       get_records
@@ -141,37 +198,159 @@ class ModelBuilder
     end
   end
 
-  # This is intended to be called from the view class which instantiated
-  # this builder object.
-  def build
+  # make sure this field doesn't show up
+  # mainly intended to be called after default_ui has been called
+  def hide( attribute )
+    field( attribute ).visible = false
+  end
+
+  # Build a default UI. All fields except the primary key are displayed
+  # as editable in the table. Any belongs_to relations are used to build
+  # combo boxes.
+  # Try to use a sensible :display option for the related class. In order:
+  # the name of the class, name, title, username
+  # order by the primary key. The class can use post_default_ui( &block )
+  # to do small tweaks.
+  def default_ui
+    # combine reflections and attributes into one set
+    reflections = model_class.reflections.keys.map{|x| x.to_s}
+    ui_columns = model_class.columns.reject{|x| x.name == model_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 model_class.reflections.has_key?( column.to_sym )
+        begin
+          reflection = model_class.reflections[column.to_sym]
+          if reflection.class == ActiveRecord::Reflection::AssociationReflection
+            # try to find a sensible display class. Default to to_s
+            related_class = reflection.class_name.constantize
+            display_method =
+            %w{#{model_class.name} name title username}.find( lambda{ 'to_s' } ) do |m|
+              related_class.column_names.include?( m ) || related_class.instance_methods.include?( m )
+            end
+            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 #{model_class}.#{column}"
+          plain column.to_sym
+        end
+      else
+        plain column.to_sym
+      end
+    end
+    records :order => model_class.primary_key
+  end
+  
+  # return the named Clevic::Field object
+  def field( attribute )
+    @fields.find {|x| x.attribute == attribute }
+  end
+  
+  # This takes all the information collected
+  # by the other methods, and returns the new TableModel
+  def build( table_view )
     # 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.
-    # TODO put @fields into TableModel, and access from there?
-    @model = Clevic::TableModel.new( self )
-    @model.object_name = @table_view.model_class.name
-    @model.dots = @fields.map {|x| x.column }
-    @model.labels = @fields.map {|x| x.label }
-    @model.attributes = @fields.map {|x| x.attribute }
-    @model.attribute_paths = @fields.map { |x| x.attribute_path }
+    @model = Clevic::TableModel.new( table_view )
+    @model.object_name = model_class.name
+    @model.model_class = model_class
+    @model.fields = @fields
+    @model.read_only = @read_only
+    @model.auto_new = auto_new?
+    
+    # set parent for all delegates
+    fields.each {|x| x.delegate.parent = table_view unless x.delegate.nil? }
     
     # the data
     @model.collection = records
-    # fill in an empty record for data entry
-    @model.collection << model_class.new if @model.collection.size == 0
     
-    # now set delegates
-    @table_view.item_delegate = Clevic::ItemDelegate.new( @table_view )
-    @fields.each_with_index do |field, index|
-      @table_view.set_item_delegate_for_column( index, field.delegate )
+    @model
+  end
+  
+private
+
+  def init_from_model( model_class, can_build_default, &block )
+    if model_class.respond_to?( :build_table_model )
+      # call build_table_model
+      method = model_class.method :build_table_model
+      method.call( builder )
+    elsif !model_class.define_ui_block.nil?
+      #define_ui is used, so use that block
+      instance_eval( &model_class.define_ui_block )
+    elsif can_build_default
+      # build a default UI
+      default_ui
+      
+      # allow for smallish changes to a default build
+      instance_eval( &model_class.post_default_ui_block ) unless model_class.post_default_ui_block.nil?
+    end
+
+    # the local block adds to the previous definitions
+    unless block.nil?
+      if block.arity == 0
+        instance_eval( &block )
+      else
+        yield( builder )
+      end
+    end
+  end
+  
+  # add AR :include options for foreign keys, but it takes up too much memory,
+  # and actually takes longer to load a data set
+  def add_include_options
+    fields.each do |field|
+      if field.delegate.class == RelationalDelegate
+        @options[:include] ||= []
+        @options[:include] << field.attribute
+      end
     end
-    
-    # give the built model back to the view class
-    # see above comment about @model
-    @table_view.model = @model
   end
 
-private
+  # set a sensible read-only value if it isn't already
+  # specified in options doesn't alread
+  def read_only_default( attribute, options )
+    # sensible defaults for read-only-ness
+    options[:read_only] ||= 
+    case
+      when options[:display].respond_to?( :call )
+        # it's a Proc or a Method, so we can't set it
+        true
+        
+      when model_class.column_names.include?( options[:display].to_s )
+        # it's a DB column, so it's not read only
+        false
+        
+      when model_class.reflections.include?( attribute )
+        # one-to-one relationships can be edited. many-to-one certainly can't
+        reflection = model_class.reflections[attribute]
+        reflection.macro != :has_one
+        
+      when model_class.instance_methods.include?( attribute.to_s )
+        # read-only if there's no setter for the attribute
+        !model_class.instance_methods.include?( "#{attribute.to_s}=" )
+      else
+        # default to not read-only
+        false
+    end
+  end
 
   # The collection of model objects to display in a table
   # arg can either be a Hash, in which case a new CacheTable
@@ -191,10 +370,24 @@ private
   def get_records
     if @records.nil?
       #~ add_include_options
+      @options[:auto_new] = auto_new?
       @records = CacheTable.new( model_class, @options )
     end
     @records
   end
+  # update options with the values in block, using FieldBuilder
+  # to evaluate block
+
+  def gather_block( options, &block )
+    unless block.nil?
+      fb = FieldBuilder.new( options )
+      fb.instance_eval( &block )
+      fb.to_hash
+    else
+      options
+    end
+  end
+  
 end
 
 end