clevic 0.8.0 → 0.11.1

data/lib/clevic/order_attribute.rb

@@ -0,0 +1,53 @@
+=begin rdoc
+Store the SQL order_by attributes with ascending and descending values
+=end
+class OrderAttribute
+  attr_reader :direction, :attribute
+  
+  def initialize( entity_class, sql_order_fragment )
+    @entity_class = entity_class
+    if sql_order_fragment =~ /^(.*?\.)?(.*?) *asc$/i
+      @direction = :asc
+      @attribute = $2
+    elsif sql_order_fragment =~ /^(.*?\.)?(.*?) *desc$/i
+      @direction = :desc
+      @attribute = $2
+    else
+      @direction = :asc
+      @attribute = sql_order_fragment
+    end
+  end
+  
+  # return ORDER BY field name
+  def to_s
+    @string ||= attribute
+  end
+  
+  def to_sym
+    @sym ||= attribute.to_sym
+  end
+  
+  # return 'field ASC' or 'field DESC', depending
+  def to_sql
+    "#{@entity_class.table_name}.#{attribute} #{direction.to_s}"
+  end
+  
+  def reverse( direction )
+    case direction
+      when :asc; :desc
+      when :desc; :asc
+      else; raise "unknown direction #{direction}"
+    end
+  end
+  
+  # return the opposite ASC or DESC from to_sql
+  def to_reverse_sql
+    "#{@entity_class.table_name}.#{attribute} #{reverse(direction).to_s}"
+  end
+
+  def ==( other )
+    @entity_class == other.instance_eval( '@entity_class' ) and
+    self.direction == other.direction and
+    self.attribute == other.attribute
+  end
+end

data/lib/clevic/record.rb

@@ -1,70 +1,70 @@
-require 'active_record.rb'
-require 'active_record/dirty.rb'
+require 'clevic/view.rb'
+require 'clevic/default_view.rb'
 
 module Clevic
 
-  module Default
+  # include this in ActiveRecord::Base instances to
+  # get embedded view definitions. See ModelBuilder.
+  #
+  # A Clevic::Default#{model}View class will be created. If
+  # a define_ui block is not specified in the entity class, 
+  # a default UI will be created.
+  module Record
+    # TODO not sure if these are necessary here anymore?
+    def self.db_options=( db_options )
+      @db_options = db_options
+    end
+    
+    def self.db_options
+      @db_options
+    end
+    
     module ClassMethods
-      def define_ui_block; nil; end
-
-      def post_default_ui_block
-        @post_default_ui_block
+      def default_view_class_name
+        "::Clevic::Default#{name.gsub('::','')}View"
+      end
+      
+      #TODO will have to fix modules here
+      def create_view_class
+        # create the default view class
+        # Don't use Class.new because even if you assign
+        # the result to a contstant, there are still anonymous classes
+        # hanging around, which gives weird results with Clevic::View.subclasses.
+        st,line = <<-EOF, __LINE__
+          class #{default_view_class_name} < Clevic::DefaultView
+            entity_class #{name}
+          end
+        EOF
+        eval st, nil, __FILE__, line
+        
+        # keep track of the order in which views are
+        # defined, so that can be used as the default ordering
+        # of the views.
+        Clevic::View.order << default_view_class_name.constantize
       end
       
-      def post_default_ui( &block )
-        @post_default_ui_block = block
+      def default_view_class
+        @default_view_class ||= eval default_view_class_name
       end
+      
+      # Need to defer the execution of the view definition block
+      # until related models have been defined.
+      def define_ui( &block )
+        default_view_class.define_ui_block( &block )
+      end
+      
     end
     
-    def self.included(base)
-      base.extend(ClassMethods)
-    end
-  end
-
-end
-
-module ActiveRecord
-  class Base
-    include Clevic::Default
-  end
-end
-
-module Clevic
+    def self.included( base )
+      base.extend( ClassMethods )
+      
+      # create the default view class
+      base.create_view_class
 
-  # The base class for all Clevic model and UI definitions.
-  # minimal definition is like this
-  #   class User < Clevic::Record; end
-  # Record automatically keeps track of the order
-  # in which models are defined, so that tabs can
-  # be constructed in that order.
-  class Record < ActiveRecord::Base
-    include ActiveRecord::Dirty
-    self.abstract_class = true
-    @@subclass_order = []
-    
-    def self.define_ui_block
-      @define_ui_block
-    end
-    
-    # keep track of the order in which subclasses are
-    # defined, so that can be used as the default ordering
-    # of the views.
-    def self.inherited( subclass )
-      @@subclass_order << subclass
-      super
-    end
-    
-    def self.models
-      @@subclass_order
-    end
-    
-    def self.models=( array )
-      @@subclass_order = array
-    end
-    
-    # use this to define UI blocks using the ModelBuilder DSL
-    def self.define_ui( &block )
-      @define_ui_block = block
+      # DbOptions instance
+      db_options = nil
+      found = ObjectSpace.each_object( Clevic::DbOptions ){|x| db_options = x}
+      @db_options = db_options
     end
   end
   

data/lib/clevic/search_dialog.rb

@@ -2,76 +2,80 @@ require 'Qt4'
 require 'clevic/ui/search_dialog_ui.rb'
 require 'qtext/flags.rb'
 
-class SearchDialog
-  include QtFlags
-  attr_reader :match_flags, :layout
-  
-  def initialize
-    @layout = Ui_SearchDialog.new
-    @dialog = Qt::Dialog.new
-    @layout.setupUi( @dialog )
-  end
-  
-  def from_start?
-    layout.from_start.value
-  end
-  
-  def from_start=( value )
-    layout.from_start.value = value
-  end
-  
-  def regex?
-    layout.regex.value
-  end
-  
-  def whole_words?
-    layout.whole_words.value
-  end
-  
-  def search_combo
-    layout.search_combo
-  end
-  
-  def forwards?
-    @layout.forwards.checked?
-  end
-  
-  def backwards?
-    @layout.backwards.checked?
-  end
-  
-  # return either :backwards or :forwards
-  def direction
-    return :forwards if forwards?
-    return :backwards if backwards?
-    raise "direction not known"
-  end
-  
-  def exec( text = '' )
-    search_combo.edit_text = text.to_s
-    search_combo.set_focus
-    retval = @dialog.exec
+module Clevic
+
+  class SearchDialog
+    include QtFlags
+    attr_reader :match_flags, :layout
     
-    # remember previous searches
-    if search_combo.find_text( search_combo.current_text ) == -1
-      search_combo.add_item( search_combo.current_text )
+    def initialize
+      @layout = Ui_SearchDialog.new
+      @dialog = Qt::Dialog.new
+      @layout.setupUi( @dialog )
     end
     
-    #~ Qt::MatchExactly	0	Performs QVariant-based matching.
-    #~ Qt::MatchFixedString	8	Performs string-based matching. String-based comparisons are case-insensitive unless the MatchCaseSensitive flag is also specified.
-    #~ Qt::MatchContains	1	The search term is contained in the item.
-    #~ Qt::MatchStartsWith	2	The search term matches the start of the item.
-    #~ Qt::MatchEndsWith	3	The search term matches the end of the item.
-    #~ Qt::MatchCaseSensitive	16	The search is case sensitive.
-    #~ Qt::MatchRegExp	4	Performs string-based matching using a regular expression as the search term.
-    #~ Qt::MatchWildcard	5	Performs string-based matching using a string with wildcards as the search term.
-    #~ Qt::MatchWrap	32	Perform a search that wraps around, so that when the search reaches the last item in the model, it begins again at the first item and continues until all items have been examined.
+    def from_start?
+      layout.from_start.value
+    end
+    
+    def from_start=( value )
+      layout.from_start.value = value
+    end
+    
+    def regex?
+      layout.regex.value
+    end
+    
+    def whole_words?
+      layout.whole_words.value
+    end
+    
+    def search_combo
+      layout.search_combo
+    end
+    
+    def forwards?
+      layout.forwards.checked?
+    end
+    
+    def backwards?
+      layout.backwards.checked?
+    end
+    
+    # return either :backwards or :forwards
+    def direction
+      return :forwards if forwards?
+      return :backwards if backwards?
+      raise "direction not known"
+    end
+    
+    def exec( text = '' )
+      search_combo.edit_text = text.to_s
+      search_combo.set_focus
+      retval = @dialog.exec
+      
+      # remember previous searches
+      if search_combo.find_text( search_combo.current_text ) == -1
+        search_combo.add_item( search_combo.current_text )
+      end
+      
+      #~ Qt::MatchExactly	0	Performs QVariant-based matching.
+      #~ Qt::MatchFixedString	8	Performs string-based matching. String-based comparisons are case-insensitive unless the MatchCaseSensitive flag is also specified.
+      #~ Qt::MatchContains	1	The search term is contained in the item.
+      #~ Qt::MatchStartsWith	2	The search term matches the start of the item.
+      #~ Qt::MatchEndsWith	3	The search term matches the end of the item.
+      #~ Qt::MatchCaseSensitive	16	The search is case sensitive.
+      #~ Qt::MatchRegExp	4	Performs string-based matching using a regular expression as the search term.
+      #~ Qt::MatchWildcard	5	Performs string-based matching using a string with wildcards as the search term.
+      #~ Qt::MatchWrap	32	Perform a search that wraps around, so that when the search reaches the last item in the model, it begins again at the first item and continues until all items have been examined.
+      
+      retval
+    end
+    
+    def search_text
+      search_combo.current_text
+    end
     
-    retval
-  end
-  
-  def search_text
-    search_combo.current_text
   end
-  
+
 end

data/lib/clevic/sql_dialects.rb

@@ -0,0 +1,33 @@
+module Clevic
+  # Provide some SQL dialect differences that aren't in ActiveRecord. Including
+  # class must respond to entity_class.
+  module SqlDialects
+    def adapter_name
+      connection.adapter_name
+    end
+    
+    def connection
+      entity_class.connection
+    end
+    
+    # return a string containing the correct
+    # boolean value depending on the DB adapter
+    # because Postgres wants real true and false in complex statements, not 't' and 'f'
+    def sql_boolean( value )
+      case adapter_name
+        when 'PostgreSQL'
+          value ? 'true' : 'false'
+        else
+          value ? connection.quoted_true : connection.quoted_false
+      end
+    end
+    
+    # return a case-insensitive like operator
+    def like_operator
+      case adapter_name
+        when 'PostgreSQL'; 'ilike'
+        else; 'like'
+      end
+    end
+  end
+end

data/lib/clevic/table_model.rb

@@ -10,20 +10,9 @@ require 'clevic/model_column'
 module Clevic
 
 =begin rdoc
-This table model allows an ActiveRecord or ActiveResource to be used as a
-basis for a Qt::AbstractTableModel for viewing in a Qt::TableView.
-
-* labels are the headings in the table view
-
-* dots are the dotted attribute paths that specify how to get values from
-  the underlying ActiveRecord model
-
-* attribute_paths is a collection of attribute symbols. It comes from
-  dots, and is split on /\./
-
-* attributes are the first-level of the dots
-
-* collection is the set of ActiveRecord model objects (also called entities)
+An instance of Clevic::TableModel is constructed by Clevic::ModelBuilder from the
+UI definition in a Clevic::View, or from the default Clevic::View created by
+including the Clevic::Record module in a ActiveRecord::Base subclass.
 =end
 class TableModel < Qt::AbstractTableModel
   include QtFlags
@@ -31,9 +20,6 @@ class TableModel < Qt::AbstractTableModel
   # the CacheTable of Clevic::Record or ActiveRecord::Base objects
   attr_reader :collection
   
-  # the actual class for the collection objects
-  attr_accessor :model_class
-  
   # the collection of Clevic::Field objects
   attr_reader :fields
   
@@ -44,11 +30,15 @@ class TableModel < Qt::AbstractTableModel
   attr_accessor :auto_new
   def auto_new?; auto_new; end
   
+  attr_accessor :entity_view
+  
+  def entity_class
+    entity_view.entity_class
+  end
+  
   signals(
     # index where error occurred, value, message
-    'data_error(QModelIndex,QVariant,QString)',
-    # top_left, bottom_right
-    'dataChanged(const QModelIndex&,const QModelIndex&)'
+    'data_error(QModelIndex,QVariant,QString)'
   )
   
   def initialize( parent = nil )
@@ -59,16 +49,10 @@ class TableModel < Qt::AbstractTableModel
   def fields=( arr )
     @fields = arr
     
-    #reset these
+    # reset these
     @metadatas = []
-    @dots = nil
     @labels = nil
     @attributes = nil
-    @attribute_paths = nil
-  end
-  
-  def dots
-    @dots ||= fields.map {|x| x.column }
   end
   
   def labels
@@ -79,15 +63,11 @@ class TableModel < Qt::AbstractTableModel
     @attributes ||= fields.map {|x| x.attribute }
   end
   
-  def attribute_paths
-    @attribute_paths ||= fields.map {|x| x.attribute_path }
-  end
-  
   def collection=( arr )
     @collection = arr
     # fill in an empty record for data entry
     if collection.size == 0 && auto_new?
-      collection << model_class.new
+      collection << entity_class.new
     end
   end
   
@@ -115,25 +95,15 @@ class TableModel < Qt::AbstractTableModel
     []
   end
   
-  #~ def build_dots( dots, attrs, prefix="" )
-    #~ attrs.inject( dots ) do |cols, a|
-      #~ if a[1].respond_to? :attributes
-        #~ build_keys(cols, a[1].attributes, prefix + a[0] + ".")
-      #~ else
-        #~ cols << prefix + a[0]
-      #~ end
-    #~ end
-  #~ end
-  
   # cache metadata (ActiveRecord#column_for_attribute) because it's not going
   # to change over the lifetime of the table
   # if the column is an attribute, create a ModelColumn
   # TODO use ActiveRecord::Base.reflections instead
   def metadata( column )
     if @metadatas[column].nil?
-      meta = model_class.columns_hash[attributes[column].to_s]
+      meta = entity_class.columns_hash[attributes[column].to_s]
       if meta.nil?
-        meta = model_class.columns_hash[ "#{attributes[column]}_id" ]
+        meta = entity_class.columns_hash[ "#{attributes[column]}_id" ]
         if meta.nil?
           return nil
         else
@@ -149,20 +119,21 @@ class TableModel < Qt::AbstractTableModel
   def add_new_item
     # 1 new row
     begin_insert_rows( Qt::ModelIndex.invalid, row_count, row_count )
-    collection << model_class.new
+    collection << entity_class.new
     end_insert_rows
   end
   
   # rows is a collection of integers specifying row indices to remove
-  # TODO call begin_remove and end_remove around the whole block
   def remove_rows( rows )
     # delete from the end to avoid holes affecting the indexing
-    rows.sort.reverse.each do |index|
+    rows.uniq.sort.reverse.each do |index|
       # remove the item from the collection
+      # NOTE call this within each iteration because
+      # the rows array may be non-contiguous
       begin_remove_rows( Qt::ModelIndex.invalid, index, index )
       removed = collection.delete_at( index )
       end_remove_rows
-      # destroy the db object, and its table row
+      # destroy the db object, and its associated table row
       removed.destroy
     end
   end
@@ -187,26 +158,32 @@ class TableModel < Qt::AbstractTableModel
     collection.size
   end
 
+  # Not looked up or aliased properly by Qt bindings
   def row_count
     collection.size
   end
   
   def columnCount( parent = nil )
-    dots.size
+    fields.size
   end
   
+  # Not looked up or aliased properly by Qt bindings
   def column_count
-    dots.size
+    fields.size
   end
   
   def flags( model_index )
     retval = super
+    
+    # sometimes this actually happens. 
+    # TODO probably a bug in the combo editor exit code
+    return retval if model_index.column >= columnCount
+    
     # TODO don't return IsEditable if the model is read-only
     if model_index.metadata.type == :boolean
       retval = item_boolean_flags
     end
     
-    # read-only
     unless model_index.field.read_only? || model_index.entity.readonly? || read_only?
       retval |= qt_item_is_editable.to_i 
     end
@@ -263,10 +240,11 @@ class TableModel < Qt::AbstractTableModel
         
       when qt_background_role
         if orientation == Qt::Vertical
+          item = collection[section]
           case
-            when !collection[section].errors.empty?
+            when !item.errors.empty?
               Qt::Color.new( 'orange' )
-            when collection[section].changed?
+            when item.changed?
               Qt::Color.new( 'yellow' )
           end
         end
@@ -281,23 +259,25 @@ class TableModel < Qt::AbstractTableModel
   
   # Provide data to UI.
   def data( index, role = qt_display_role )
-    #~ puts "data for index: #{index.inspect} and role: #{const_as_string role}"
+    #~ puts "data for index: #{index.inspect}, field #{index.field.attribute.inspect} and role: #{const_as_string role}"
     begin
       retval =
       case role
-        when qt_display_role, qt_edit_role
+        when qt_display_role
           # boolean values generally don't have text next to them in this context
-          # check explicitly to avoid fetching the entity from
-          # the model's collection when we don't need to
+          # check this explicitly to avoid fetching the entity from
+          # the model's collection (and maybe db) when we
+          # definitely don't need to
           unless index.metadata.type == :boolean
-            begin
-              value = index.gui_value
-              unless value.nil?
-                index.field.do_format( value )
-              end
-            rescue Exception => e
-              puts e.backtrace
-            end
+            value = index.gui_value
+            index.field.do_format( value ) unless value.nil?
+          end
+          
+        when qt_edit_role
+          # see comment for qt_display_role
+          unless index.metadata.type == :boolean
+            value = index.gui_value
+            index.field.do_edit_format( value ) unless value.nil?
           end
           
         when qt_checkstate_role
@@ -306,22 +286,30 @@ class TableModel < Qt::AbstractTableModel
           end
           
         when qt_text_alignment_role
-          index.field.alignment
+          case index.field.alignment
+            when :left; qt_alignleft
+            when :right; qt_alignright
+            when :centre; qt_aligncenter
+            when :justified; qt_alignjustified
+          end
         
-        # these are just here to make debug output quieter
+        # just here to make debug output quieter
         when qt_size_hint_role;
         
         # show field with a red background if there's an error
         when qt_background_role
-          Qt::Color.new( 'red' ) if index.has_errors?
-          
+          index.field.background_for( index.entity ) || Qt::Color.new( 'red' ) if index.has_errors?
+        
         when qt_font_role;
+        
         when qt_foreground_role
+          index.field.foreground_for( index.entity ) ||
           if index.field.read_only? || index.entity.readonly? || read_only?
             Qt::Color.new( 'dimgray' )
           end
-          
+        
         when qt_decoration_role;
+          index.field.decoration_for( index.entity )
         
         when qt_tooltip_role
           case
@@ -336,6 +324,9 @@ class TableModel < Qt::AbstractTableModel
             # read-only field
             when index.field.read_only?
               'Read-only'
+              
+            else
+              index.field.tooltip_for( index.entity )
           end    
         else
           puts "data index: #{index}, role: #{const_as_string(role)}" if $options[:debug]
@@ -343,23 +334,27 @@ class TableModel < Qt::AbstractTableModel
       end
       
       # return a variant
+      #~ puts "retval: #{retval.inspect}"
       retval.to_variant
     rescue Exception => e
+      puts "#{index.inspect} #{value.inspect} #{index.entity.inspect} for and role: #{const_as_string role}"
+      puts e.message
       puts e.backtrace
-      puts "#{index.inspect} #{value.inspect} #{index.entity.inspect} #{e.message}"
       nil.to_variant
     end
   end
 
   # data sent from UI
+  # return true if conversion from variant was successful,
+  # or false if something went wrong.
   def setData( index, variant, role = qt_edit_role )
     if index.valid?
       case role
       when qt_edit_role
         # Don't allow the primary key to be changed
-        return false if index.attribute == model_class.primary_key.to_sym
+        return false if index.attribute == entity_class.primary_key.to_sym
         
-        if ( index.column < 0 || index.column >= dots.size )
+        if ( index.column < 0 || index.column >= column_count )
           raise "invalid column #{index.column}" 
         end
         
@@ -369,7 +364,7 @@ class TableModel < Qt::AbstractTableModel
         # translate the value from the ui to something that
         # the AR model will understand
         begin
-          index.gui_value =
+          index.attribute_value =
           case
             when value.class.name == 'Qt::Date'
               Date.new( value.year, value.month, value.day )
@@ -382,19 +377,19 @@ class TableModel < Qt::AbstractTableModel
             # TODO need to be cleverer about which year to use
             # for when you're entering 16dec and you're in the next
             # year
-            when type == :date && value =~ %r{^(\d{1,2})[ /-]?(\w{3})$}
+            when [:date,:datetime].include?( 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 type == :date && value =~ %r{^(\d{1,2})$}
+            when [:date,:datetime].include?( type ) && value =~ %r{^(\d{1,2})$}
               previous_entity = collection[index.row - 1]
               # year,month,day
               Date.new( previous_entity.date.year, previous_entity.date.month, $1.to_i )
             
             # this one is mostly to fix date strings that have come
             # out of the db and been formatted
-            when type == :date && value =~ %r{^(\d{2})[ /-](\w{3})[ /-](\d{2})$}
+            when [:date,:datetime].include?( type ) && value =~ %r{^(\d{2})[ /-](\w{3})[ /-](\d{2})$}
               Date.parse( "#$1 #$2 20#$3" )
             
             # allow lots of flexibility in entering times
@@ -452,51 +447,9 @@ class TableModel < Qt::AbstractTableModel
     end
   end
   
-  def like_operator
-    case model_class.connection.adapter_name
-      when 'PostgreSQL'; 'ilike'
-      else; 'like'
-    end
-  end
-  
   # return a set of indexes that match the search criteria
-  # TODO this implementation is very un-ruby.
   def search( start_index, search_criteria )
-    # get the search value parameter, in SQL format
-    search_value =
-    if search_criteria.whole_words?
-      "% #{search_criteria.search_text} %"
-    else
-      "%#{search_criteria.search_text}%"
-    end
-
-    # build up the ordering conditions
-    bits = collection.build_sql_find( start_index.entity, search_criteria.direction )
-    
-    # do the conditions for the search value
-    conditions =
-    if start_index.field.is_association?
-      # for related tables
-      # TODO this will only work with a path value with no dots
-      "#{start_index.field.path} #{like_operator} :search_value"
-    else
-      # for this table
-      "#{model_class.connection.quote_column_name( start_index.field_name )} #{like_operator} :search_value"
-    end
-    
-    # add ordering conditions
-    conditions += ( " and " + bits[:sql] ) unless search_criteria.from_start?
-    
-    params = { :search_value => search_value }
-    params.merge!( bits[:params] ) unless search_criteria.from_start?
-    
-    # find the first match
-    entity = model_class.find(
-      :first,
-      :conditions => [ conditions, params ],
-      :order => search_criteria.direction == :forwards ? collection.order : collection.reverse_order,
-      :joins => ( start_index.field.meta.name if start_index.field.is_association? )
-    )
+    entity = collection.search( start_index.field, search_criteria, start_index.entity )
     
     # return matched indexes
     if entity != nil