clevic 0.8.0 → 0.11.1

data/lib/clevic/table_searcher.rb

@@ -0,0 +1,165 @@
+require 'clevic/sql_dialects.rb'
+
+module Clevic
+
+# TODO possibly use AR scopes for this?
+class TableSearcher
+  attr_reader :entity_class, :order_attributes, :search_criteria, :field
+  
+  # entity_class is a descendant of ActiveRecord::Base
+  # order_attributes is a collection of OrderAttribute objects
+  # - field is an instance of Clevic::Field
+  # - search_criteria responds to from_start?, direction, whole_words? and search_text
+  def initialize( entity_class, order_attributes, search_criteria, field )
+    raise "there must be at least one order_attribute" if order_attributes.nil? or order_attributes.empty?
+    raise "field must be specified" if field.nil?
+    raise "unknown order #{search_criteria.direction}" unless [:forwards, :backwards].include?( search_criteria.direction )
+    @entity_class = entity_class
+    @order_attributes = order_attributes
+    @search_criteria = search_criteria
+    @field = field
+  end
+  
+  # start_entity is the entity to start from, ie any record found after it will qualify
+  def search( start_entity = nil )
+    search_field_name = 
+    if field.is_association?
+      # for related tables
+      unless [String,Symbol].include?( field.display.class )
+        raise( "search field #{field.inspect} cannot have a complex display" ) 
+      end
+      
+      # TODO this will only work with a path value with no dots
+      # otherwise the SQL gets complicated with joins etc
+      field.display
+    else
+      # for this table
+      entity_class.connection.quote_column_name( field.attribute.to_s )
+    end
+    
+    # do the conditions for the search value
+    @conditions = search_clause( search_field_name )
+    
+    # if we're not searching from the start, we need
+    # to find the next match. Which is complicated from an SQL point of view.
+    unless search_criteria.from_start?
+      raise "start_entity cannot be nil when from_start is false" if start_entity.nil?
+      # build up the ordering conditions
+      find_from!( start_entity )
+    end
+    
+    # otherwise ActiveRecord thinks that the % in the string
+    # is for interpolations instead of treating it a the like wildcard
+    conditions_value =
+    if !@params.nil? and @params.size > 0
+      [ @conditions, @params ]
+    else
+      @conditions
+    end
+    
+    # find the first match
+    entity_class.find(
+      :first,
+      :conditions => conditions_value,
+      :order => order,
+      :joins => ( field.meta.name if field.is_association? )
+    )
+  end
+
+protected
+  include SqlDialects
+  
+  def quote_column( field_name )
+    entity_class.connection.quote_column_name( field_name )
+  end
+  
+  def quote( value )
+    entity_class.connection.quote( value )
+  end
+  
+  # recursively create a case statement to do the comparison
+  # because and ... and ... and filters on *each* one rather than
+  # consecutively.
+  # operator is either '<' or '>'
+  def build_recursive_comparison( operator, index = 0 )
+    # end recursion
+    return sql_boolean( false ) if index == order_attributes.size
+    
+    # fetch the current attribute
+    attribute = order_attributes[index]
+    
+    # build case statement, including recusion
+    st = <<-EOF
+case
+  when #{entity_class.table_name}.#{quote_column attribute} #{operator} :#{attribute} then #{sql_boolean true}
+  when #{entity_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
+  
+  # Add the relevant conditions to use start_entity as the
+  # entity where the search starts, ie the first one after it is found
+  # start_entity is an AR model instance
+  # sets @params and @conditions
+  def find_from!( start_entity )
+    operator =
+    case search_criteria.direction
+      when :forwards; '>'
+      when :backwards; '<'
+    end
+    
+    # build the sql comparison where clause fragment
+    comparison_sql = build_recursive_comparison( operator )
+    
+    # only Postgres seems to understand real booleans
+    # everything else needs the big case statement to be compared
+    # to something
+    unless entity_class.connection.adapter_name == 'PostgreSQL'
+      comparison_sql += " = #{sql_boolean true}"
+    end
+    
+    # build parameter values
+    @params ||= {}
+    order_attributes.each {|x| @params[x.to_sym] = start_entity.send( x.attribute )}
+    
+    @conditions += " and " + comparison_sql
+  end
+  
+  # get the search value parameter, in SQL format
+  def search_clause( field_name )
+    if search_criteria.whole_words?
+      <<-EOF
+      (
+        #{field_name} #{like_operator} #{quote "% #{search_criteria.search_text} %"}
+        or
+        #{field_name} #{like_operator} #{quote "#{search_criteria.search_text} %"}
+        or
+        #{field_name} #{like_operator} #{quote "% #{search_criteria.search_text}"}
+      )
+      EOF
+    else
+      "#{field_name} #{like_operator} #{quote "%#{search_criteria.search_text}%"}"
+    end
+  end
+  
+  def ascending_order
+    order_attributes.map{|x| x.to_sql}.join(',')
+  end
+  
+  def descending_order
+    order_attributes.map{|x| x.to_reverse_sql}.join(',')
+  end
+  
+  def order
+    case search_criteria.direction
+      when :forwards; ascending_order
+      when :backwards; descending_order
+    end
+  end
+  
+end
+
+end

data/lib/clevic/table_view.rb

@@ -6,41 +6,48 @@ require 'qtext/action_builder.rb'
 
 module Clevic
 
-# The view class, implementing neat shortcuts and other pleasantness
+# The view class
 class TableView < Qt::TableView
   include ActionBuilder
   
-  attr_reader :model_class
   # whether the model is currently filtered
   # TODO better in QAbstractSortFilter?
   attr_accessor :filtered
   def filtered?; self.filtered; end
   
   # status_text is emitted when this object was to display something in the status bar
+  # error_test is emitted when an error of some kind must be displayed to the user.
   # filter_status is emitted when the filtering changes. Param is true for filtered, false for not filtered.
   signals 'status_text(QString)', 'filter_status(bool)'
   
   # model_builder_record is:
-  # - a subclass of Clevic::Record or ActiveRecord::Base
-  # - an instance of ModelBuilder
+  # - an ActiveRecord::Base subclass that includes Clevic::Record
+  # - an instance of Clevic::View
   # - an instance of TableModel
-  def initialize( model_builder_record, parent, &block )
+  def initialize( arg, parent = nil, &block )
     # need the empty block here, otherwise Qt bindings grab &block
     super( parent ) {}
     
-    # the model/model_class/builder
+    # the model/entity_class/builder
     case 
-      when model_builder_record.kind_of?( TableModel )
-        self.model = model_builder_record
+      when arg.kind_of?( TableModel )
+        self.model = arg
+        init_actions( arg.entity_view )
       
-      when model_builder_record.ancestors.include?( ActiveRecord::Base )
-        with_record( model_builder_record, &block )
-      
-      when model_builder_record.kind_of?( Clevic::ModelBuilder )
-        with_builder( model_builder_record, &block )
-        
       else
-        raise "Don't know what to do with #{model_builder_record}"
+        # arg is a subclass of Clevic::View
+        model_builder = arg.define_ui
+        model_builder.exec_ui_block( &block )
+        
+        # make sure the TableView has a fully-populated TableModel
+        # self.model is necessary to invoke the Qt layer
+        self.model = model_builder.build( self )
+        self.object_name = arg.widget_name
+        
+        # connect data_changed signals for the entity_class to respond
+        connect_view_signals( arg )
+        
+        init_actions( arg )
     end
       
     # see closeEditor
@@ -54,38 +61,24 @@ class TableView < Qt::TableView
     self.sorting_enabled = false
     @filtered = false
     
-    # turn off "Object#type deprecated" messages
-    $VERBOSE = nil
-    
-    init_actions
     self.context_menu_policy = Qt::ActionsContextMenu
   end
   
-  def with_builder( model_builder, &block )
-    model_builder.instance_eval( &block ) unless block.nil?
-    
-    # make sure the TableView has a fully-populated TableModel
-    self.model = model_builder.build( self )
-    
-    # connect data_changed signals for the model_class to respond
-    connect_model_class_signals( model_class )
-  end
-  
-  def with_record( model_class, &block )
-    builder = ModelBuilder.new( model_class )
-    with_builder( builder, &block )
+  def title
+    @title ||= model.entity_view.title
   end
   
-  def connect_model_class_signals( model_class )
-    # this is only here because model_class.data_changed needs the view.
-    # Should probably fix that.
-    if model_class.respond_to?( :data_changed )
-      model.connect SIGNAL( 'dataChanged ( const QModelIndex &, const QModelIndex & )' ) do |top_left, bottom_right|
-        model_class.data_changed( top_left, bottom_right, self )
-      end
+  def connect_view_signals( entity_view )
+    model.connect SIGNAL( 'dataChanged ( const QModelIndex &, const QModelIndex & )' ) do |top_left, bottom_right|
+      entity_view.notify_data_changed( self, top_left, bottom_right )
     end
   end
   
+  # find the row index for the given field
+  def field_column( field )
+    model.fields.each_with_index {|x,i| return i if x.attribute == field }
+  end
+    
   # return menu actions for the model, or an empty array if there aren't any
   def model_actions
     @model_actions ||= []
@@ -94,23 +87,27 @@ class TableView < Qt::TableView
   # hook for the sanity_check_xxx methods
   # called for the actions set up by ActionBuilder
   # it just wraps the action block/method in a catch
-  # block for :insane
+  # block for :insane. Will also catch exceptions thrown in actions to make
+  # core application more robust to model & view errors.
   def action_triggered( &block )
-    catch :insane do
-      yield
+    begin
+      catch :insane do
+        yield
+      end
+    rescue Exception => e
+      puts e.message
+      puts e.backtrace
     end
   end
   
-  def init_actions
+  def init_actions( entity_view )
     # add model actions, if they're defined
-    if model_class.respond_to?( :actions )
-      list( :model ) do |ab|
-        model_class.actions( self, ab )
-      end
-      separator
+    list( :model ) do |ab|
+      entity_view.define_actions( self, ab )
     end
+    separator
     
-    # list of actions called edit
+    # list of actions in the edit menu
     list( :edit ) do
       #~ new_action :action_cut, 'Cu&t', :shortcut => Qt::KeySequence::Cut
       action :action_copy, '&Copy', :shortcut => Qt::KeySequence::Copy, :method => :copy_current_selection
@@ -216,7 +213,7 @@ class TableView < Qt::TableView
   def ditto
     sanity_check_ditto
     sanity_check_read_only
-    one_up_index = model.create_index( current_index.row - 1, current_index.column )
+    one_up_index = current_index.choppy { |i| i.row -= 1 }
     previous_value = one_up_index.attribute_value
     if current_index.attribute_value != previous_value
       current_index.attribute_value = previous_value
@@ -224,14 +221,24 @@ class TableView < Qt::TableView
     end
   end
   
+  # from and to are ModelIndex instances. Throws :insane if
+  # their fields don't have the same attribute_type.
+  def sanity_check_types( from, to )
+    unless from.field.attribute_type == to.field.attribute_type
+      emit status_text( 'Incompatible data' )
+      throw :insane
+    end
+  end
+  
   def ditto_right
     sanity_check_ditto
     sanity_check_read_only
-    unless current_index.column < model.column_count
+    if current_index.column >= model.column_count - 1
       emit status_text( 'No column to the right' )
     else
-      one_up_right_index = model.create_index( current_index.row - 1, current_index.column + 1 )
-      current_index.attribute_value = one_up_right_index.attribute_value
+      one_up_right = current_index.choppy {|i| i.row -= 1; i.column += 1 }
+      sanity_check_types( one_up_right, current_index )
+      current_index.attribute_value = one_up_right.attribute_value
       emit model.dataChanged( current_index, current_index )
     end
   end
@@ -242,8 +249,9 @@ class TableView < Qt::TableView
     unless current_index.column > 0
       emit status_text( 'No column to the left' )
     else
-      one_up_left_index = model.create_index( current_index.row - 1, current_index.column - 1 )
-      current_index.attribute_value = one_up_left_index.attribute_value
+      one_up_left = current_index.choppy { |i| i.row -= 1; i.column -= 1 }
+      sanity_check_types( one_up_left, current_index )
+      current_index.attribute_value = one_up_left.attribute_value
       emit model.dataChanged( current_index, current_index )
     end
   end
@@ -260,16 +268,20 @@ class TableView < Qt::TableView
     delegate.full_edit
   end
   
+  # Add a new row and move to it, provided we're not in a read-only view.
   def new_row
     sanity_check_read_only_table
     model.add_new_item
-    new_row_index = model.index( model.collection.size - 1, 0 )
+    new_row_index = model.index( model.row_count - 1, 0 )
     currentChanged( new_row_index, current_index )
     selection_model.clear
     self.current_index = new_row_index
   end
   
-  def deleted_selection
+  # Delete the current selection. If it's a set of rows, just delete
+  # them. If it's a rectangular selection, set the cells to nil.
+  # TODO make sure all affected rows are saved.
+  def delete_selection
     sanity_check_read_only
 
     # translate from ModelIndex objects to row indices
@@ -346,13 +358,13 @@ class TableView < Qt::TableView
     
     # fetch font size
     fnt = font
-    #~ fnt.bold = true
+    fnt.bold = true
     opt.fontMetrics = Qt::FontMetrics.new( fnt )
     
-    # set data 
+    # set data
     opt.text = data.to_s
     
-    # icon size. Not needed
+    # icon size. Not needed 
     #~ variant = d->model->headerData(logicalIndex, d->orientation, Qt::DecorationRole);
     #~ opt.icon = qvariant_cast<QIcon>(variant);
     #~ if (opt.icon.isNull())
@@ -396,7 +408,7 @@ class TableView < Qt::TableView
     super
     
     # set delegates
-    self.item_delegate = Clevic::ItemDelegate.new( self )
+    #~ self.item_delegate = Clevic::ItemDelegate.new( self, field )
     model.fields.each_with_index do |field, index|
       set_item_delegate_for_column( index, field.delegate )
     end
@@ -429,25 +441,40 @@ class TableView < Qt::TableView
     super
   end
 
-  # paste a CSV array to the index
-  # TODO make additional rows if we need them, or at least check for enough space
+  # copied from actionpack
+  def pluralize(count, singular, plural = nil)
+    "#{count || 0} " + ((count == 1 || count == '1') ? singular : (plural || singular.pluralize))
+  end
+
+  # Paste a CSV array to the index, replacing whatever is at that index
+  # and whatever is at other indices matching the size of the pasted
+  # csv array. Create new rows if there aren't enough.
   def paste_to_index( top_left_index, csv_arr )
     csv_arr.each_with_index do |row,row_index|
+      # append row if we need one
+      model.add_new_item if top_left_index.row + row_index >= model.row_count
+      
       row.each_with_index do |field, field_index|
-        cell_index = model.create_index( top_left_index.row + row_index, top_left_index.column + field_index )
-        model.setData( cell_index, field.to_variant, Qt::PasteRole )
+        unless top_left_index.column + field_index >= model.column_count
+          # do paste
+          cell_index = top_left_index.choppy {|i| i.row += row_index; i.column += field_index }
+          model.setData( cell_index, field.to_variant, Qt::PasteRole )
+        else
+          emit status_text( "#{pluralize( top_left_index.column + field_index, 'column' )} for pasting data is too large. Truncating." )
+        end
       end
       # save records to db
-      model.save( model.create_index( top_left_index.row + row_index, 0 ) )
+      model.save( top_left_index.choppy {|i| i.row += row_index; i.column = 0 } )
     end
     
     # make the gui refresh
-    bottom_right_index = model.create_index( top_left_index.row + csv_arr.size - 1, top_left_index.column + csv_arr[0].size - 1 )
+    bottom_right_index = top_left_index.choppy {|i| i.row += csv_arr.size - 1; i.column += csv_arr[0].size - 1 }
     emit model.dataChanged( top_left_index, bottom_right_index )
     emit model.headerDataChanged( Qt::Vertical, top_left_index.row, top_left_index.row + csv_arr.size )
   end
   
-  def delete_multiple_cells?
+  # ask the question in a dialog. If the user says yes, execute the block
+  def delete_multiple_cells?( question = 'Are you sure you want to delete multiple cells?', &block )
     sanity_check_read_only
     
     # go ahead with delete if there's only 1 cell, or the user says OK
@@ -457,7 +484,7 @@ class TableView < Qt::TableView
       msg = Qt::MessageBox.new(
         Qt::MessageBox::Question,
         'Multiple Delete',
-        'Are you sure you want to delete multiple cells?',
+        question,
         Qt::MessageBox::Yes | Qt::MessageBox::No,
         self
       )
@@ -465,30 +492,37 @@ class TableView < Qt::TableView
     else
       true
     end
-  end
     
+    yield if delete_ok
+  end
+  
+  # Ask if multiple cell delete is OK, then replace contents
+  # of selected cells with nil.
   def delete_cells
-    cells_deleted = false
-    
-    # do delete
-    if delete_multiple_cells?
+    delete_multiple_cells? do
+      cells_deleted = false
+      
+      # do delete
       selection_model.selected_indexes.each do |index|
         index.attribute_value = nil
         cells_deleted = true
       end
-    end
-    
-    # deletes were done, so emit dataChanged
-    if cells_deleted
-      # emit data changed for all ranges
-      selection_model.selection.each do |selection_range|
-        emit dataChanged( selection_range.top_left, selection_range.bottom_right )
+      
+      # deletes were done, so emit dataChanged
+      if cells_deleted
+        # save affected rows
+        selection_model.selected_rows.each { |index| index.entity.save }
+        
+        # emit data changed for all ranges
+        selection_model.selection.each do |selection_range|
+          emit dataChanged( selection_range.top_left, selection_range.bottom_right )
+        end
       end
     end
   end
   
   def delete_rows
-    if delete_multiple_cells?
+    delete_multiple_cells?( 'Are you sure you want to delete multiple rows?' ) do
       model.remove_rows( selection_model.selected_indexes.map{|index| index.row} )
     end
   end
@@ -496,19 +530,18 @@ class TableView < Qt::TableView
   # handle certain key combinations that aren't shortcuts
   def keyPressEvent( event )
     begin
-      # call to model class for shortcuts
-      if model.model_class.respond_to?( :key_press_event )
-        begin
-          model_result = model.model_class.key_press_event( event, current_index, self )
-          return model_result if model_result != nil
-        rescue Exception => e
-          puts e.backtrace
-          error_message = Qt::ErrorMessage.new( self )
-          error_message.show_message( "Error in shortcut handler for #{model.model_class.name}: #{e.message}" )
-          error_message.show
-        end
+      # call to entity class for shortcuts
+      begin
+        view_result = model.entity_view.notify_key_press( self, event, current_index )
+        return view_result unless view_result.nil?
+      rescue Exception => e
+        puts e.backtrace
+        error_message = Qt::ErrorMessage.new( self )
+        error_message.show_message( "Error in shortcut handler for #{model.entity_view.name}: #{e.message}" )
+        error_message.show
       end
       
+      # thrown by the sanity_check_xxx methods
       catch :insane do
         case
         # on the last row, and down is pressed
@@ -525,7 +558,13 @@ class TableView < Qt::TableView
         # TODO this is actually a shortcut
         when event.ctrl? && event.return?
           new_row
-          
+        
+        when event.delete?
+          if selection_model.selected_indexes.size > 1
+            delete_selection
+            return true
+          end
+        
         else
           #~ puts event.inspect
         end
@@ -624,15 +663,15 @@ class TableView < Qt::TableView
   # override to prevent tab pressed from editing next field
   # also takes into account that override_next_index may have been called
   def closeEditor( editor, end_edit_hint )
-    puts "end_edit_hint: #{end_edit_hint.inspect}"
+    puts "end_edit_hint: #{end_edit_hint.inspect}" if $options[:debug]
     case end_edit_hint
       when Qt::AbstractItemDelegate.EditNextItem
         super( editor, Qt::AbstractItemDelegate.NoHint )
-        set_current_unless_override( model.create_index( current_index.row, current_index.column + 1 ) )
+        set_current_unless_override( current_index.choppy { |i| i.column += 1 } )
         
       when Qt::AbstractItemDelegate.EditPreviousItem
         super( editor, Qt::AbstractItemDelegate.NoHint )
-        set_current_unless_override( model.create_index( current_index.row, current_index.column - 1 ) )
+        set_current_unless_override( current_index.choppy { |i| i.column -= 1 } )
         
       else
         super
@@ -651,6 +690,7 @@ class TableView < Qt::TableView
     end
     
     save_entity = current_index.entity
+    save_entity.save if save_entity.changed?
     save_index = current_index
     
     unless self.filtered
@@ -659,7 +699,7 @@ class TableView < Qt::TableView
       if indexes.empty?
         self.filtered = false
       elsif indexes.size > 1
-        puts "Can't do multiple selection filters yet"
+        emit status_text( "Can't do multiple selection filters yet" )
         self.filtered = false
       end
       
@@ -686,7 +726,7 @@ class TableView < Qt::TableView
     unless found_row.nil?
       self.current_index = model.create_index( found_row, save_index.column )
       if self.filtered?
-        emit status_text( "Filtered on #{current_index.field_name} = #{current_index.gui_value}" )
+        emit status_text( "Filtered on #{current_index.field.label} = #{current_index.gui_value}" )
       else
         emit status_text( nil )
       end
@@ -699,7 +739,7 @@ class TableView < Qt::TableView
   # * direction ( :forward, :backward )
   # * from_start?
   #
-  # TODO formalise this
+  # TODO formalise this?
   def search( search_criteria )
     indexes = model.search( current_index, search_criteria )
     if indexes.size > 0