clevic 0.5.1

data/lib/clevic/field.rb

@@ -0,0 +1,181 @@
+require 'qtext/flags.rb'
+
+module Clevic
+
+=begin rdoc
+This defines a field in the UI, and how it hooks up to a field in the DB.
+=end
+class Field
+  include QtFlags
+  
+  attr_accessor :attribute, :path, :label, :delegate, :class_name, :alignment, :format, :tooltip
+  attr_writer :sample
+  
+  # attribute is the symbol for the attribute on the model_class
+  def initialize( attribute, model_class, options )
+    # sanity checking
+    unless model_class.has_attribute?( attribute )
+      msg = <<EOF
+#{attribute} not found in #{model_class.name}. Possibilities are:
+#{model_class.attribute_names.join("\n")}
+EOF
+      raise msg
+    end
+    
+    # set values
+    @attribute = attribute
+    @model_class = model_class
+    
+    options.each do |key,value|
+      self.send( "#{key}=", value ) if respond_to?( key )
+    end
+    
+    # default the label
+    @label ||= attribute.to_s.humanize
+    
+    # default formats
+    if @format.nil?
+      case meta.type
+        when :time; @format = '%H:%M'
+        when :date; @format = '%d-%h-%y'
+        when :datetime; @format = '%d-%h-%y %H:%M:%S'
+        when :decimal, :float; @format = "%.2f"
+      end
+    end
+    
+    # default alignments
+    if @alignment.nil?
+      @alignment =
+      case meta.type
+        when :decimal, :integer, :float; qt_alignright
+        when :boolean; qt_aligncenter
+      end
+    end
+  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?
+    @is_date_time ||= [:time, :date, :datetime].include?( meta.type )
+  end
+  
+  # return ActiveRecord::Base.columns_hash[attribute]
+  # in other words an ActiveRecord::ConnectionAdapters::Column object
+  def meta
+    @model_class.columns_hash[attribute.to_s] || @model_class.reflections[attribute]
+  end
+
+  # return the name of the field for this Field, quoted for the dbms
+  def quoted_field
+    @model_class.connection.quote_column_name( meta.name )
+  end
+
+  def column
+    [attribute.to_s, path].compact.join('.')
+  end
+  
+  # return an array of the various attribute parts
+  def attribute_path
+    pieces = [ attribute.to_s ]
+    pieces.concat( path.split( /\./ ) ) unless path.nil?
+    pieces.map{|x| x.to_sym}
+  end
+  
+  # format this value. Use strftime for date_time types, or % for everything else
+  def do_format( value )
+    if self.format != nil
+      if is_date_time?
+        value.strftime( format )
+      else
+        self.format % value
+      end
+    else
+      value
+    end
+  end
+  
+  # return a sample for the field which can be used to size a column in the table
+  def sample
+    if @sample.nil?
+      self.sample =
+      case meta.type
+        # max width of 40 chars
+        when :string, :text
+          string_sample( 'n'*40 )
+        
+        when :date, :time, :datetime
+          date_time_sample
+        
+        when :numeric, :decimal, :integer, :float
+          numeric_sample
+        
+        # TODO return a width, or something like that
+        when :boolean; 'W'
+        
+        else
+          puts "#{@model_class.name}.#{attribute} is a #{meta.type}"
+      end
+        
+      if $options[:debug]  
+        puts "@sample for #{@model_class.name}.#{attribute} #{meta.type}: #{@sample.inspect}"
+      end
+    end
+    # if we don't know how to figure it out from the data, just return the label size
+    @sample || self.label
+  end
+
+private
+
+  def format_result( result_set )
+    unless result_set.size == 0
+      obj = result_set[0][attribute]
+      unless obj.nil?
+        do_format( obj )
+      end
+    end
+  end
+  
+  def string_sample( max_sample = nil )
+    result_set = @model_class.connection.execute <<-EOF
+      select distinct #{quoted_field}
+      from #{@model_class.table_name}
+      where
+        length( #{quoted_field} ) = (
+          select max( length( #{quoted_field} ) )
+          from #{@model_class.table_name}
+        )
+    EOF
+    unless result_set.entries.size == 0
+      result = result_set[0][0]
+      if max_sample.nil?
+        result
+      else
+        result.length < max_sample.length ? result : max_sample
+      end
+    end
+  end
+  
+  def date_time_sample
+    result_set = @model_class.find_by_sql <<-EOF
+      select #{quoted_field}
+      from #{@model_class.table_name}
+      where #{quoted_field} is not null
+      limit 1
+    EOF
+    format_result( result_set )
+  end
+  
+  def numeric_sample
+    # TODO Use precision from metadata, not for integers
+    # returns nil for floats. So it's probably not useful
+    #~ puts "meta.precision: #{meta.precision.inspect}"
+    result_set = @model_class.find_by_sql <<-EOF
+      select max( #{quoted_field} )
+      from #{@model_class.table_name}
+    EOF
+    format_result( result_set )
+  end
+  
+end
+
+end

data/lib/clevic/item_delegate.rb

@@ -0,0 +1,62 @@
+require 'Qt4'
+
+module Qt
+  class KeyEvent
+    def inspect
+      "<Qt::KeyEvent text=#{text} key=#{key}"
+    end
+  end
+end
+
+module Clevic
+
+class ItemDelegate < Qt::ItemDelegate
+  
+  def initialize( parent )
+    super
+  end
+  
+  # This catches the event that begins the edit process.
+  # Not used at the moment.
+  def editorEvent ( event, model, style_option_view_item, model_index )
+    puts "editorEvent"
+    puts "event: #{event.inspect}"
+    puts "model: #{model.inspect}"
+    puts "style_option_view_item: #{style_option_view_item.inspect}"
+    puts "model_index: #{model_index.inspect}"
+    super
+  end
+  
+  def createEditor( parent_widget, style_option_view_item, model_index )
+    puts "model_index.metadata.type: #{model_index.metadata.type.inspect}"
+    if model_index.metadata.type == :date
+      # not going to work here because being triggered by
+      # an alphanumeric keystroke (as opposed to F4)
+      # will result in the calendar widget being opened.
+      #~ Qt::CalendarWidget.new( parent_widget )
+      super
+    else
+      super
+    end
+  end
+  
+  #~ def setEditorData( editor, model_index )
+    #~ editor.value = model_index.gui_value
+  #~ end
+  
+  #~ def setModelData( editor, abstract_item_model, model_index )
+    #~ model_index.gui_value = editor.value
+    #~ emit abstract_item_model.dataChanged( model_index, model_index )
+  #~ end
+  
+  def updateEditorGeometry( editor, style_option_view_item, model_index )
+    # figure out where to put the editor widget, taking into
+    # account the sizes of the headers
+    rect = style_option_view_item.rect
+    rect.set_width( [editor.size_hint.width,rect.width].max )
+    rect.set_height( editor.size_hint.height )
+    editor.set_geometry( rect )
+  end
+end
+
+end

data/lib/clevic/model_builder.rb

@@ -0,0 +1,171 @@
+require 'clevic/table_model.rb'
+require 'clevic/delegates.rb'
+require 'clevic/cache_table.rb'
+require 'clevic/field.rb'
+
+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.
+
+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)
+* :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:
+
+  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 )'
+    relational  :debit, 'name', :class_name => 'Account', :conditions => 'active = true', :order => 'lower(name)'
+    relational  :credit, 'name', :class_name => 'Account', :conditions => 'active = true', :order => 'lower(name)'
+    
+    # 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
+class ModelBuilder
+  # The collection of Clevic::Field objects
+  attr_reader :fields
+  
+  def initialize( table_view )
+    @table_view = table_view
+    @fields = []
+  end
+  
+  # return the index of the named field
+  def index( field_name_sym )
+    retval = nil
+    fields.each_with_index{|x,i| retval = i if x.attribute == field_name_sym.to_sym }
+    retval
+  end
+  
+  # the AR class for this table
+  def model_class
+    @table_view.model_class
+  end
+
+  # an ordinary field, edited in place with a text box
+  def plain( 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 = {} )
+    field = Clevic::Field.new( attribute.to_sym, model_class, options )
+    field.delegate = DistinctDelegate.new( @table_view, attribute, @table_view.model_class, options )
+    @fields << field
+  end
+
+  # edited with a combo box, but restricted to a specified set
+  def restricted( attribute, options = {} )
+    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 )
+    @fields << field
+  end
+
+  # for foreign keys. Edited with a combo box using values from the specified
+  # path on the foreign key model object
+  def relational( attribute, path, options = {} )
+    unless options.has_key? :class_name
+      options[:class_name] = attribute.to_s.classify
+    end
+    field = Clevic::Field.new( attribute.to_sym, model_class, options )
+    field.path = path
+    field.delegate = RelationalDelegate.new( @table_view, 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
+  def records( *args )
+    if args.size == 0
+      get_records
+    else
+      set_records( args[0] )
+    end
+  end
+
+  # This is intended to be called from the view class which instantiated
+  # this builder object.
+  def build
+    # build the model with all it's collections
+    # using @model here because otherwise the view's
+    # reference to this very same model is mysteriously
+    # set to nil
+    @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 }
+    
+    # the data
+    @model.collection = records
+    # fill in an empty record
+    @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 )
+    end
+    
+    # give the built model back to the view class
+    # see above comment about @model
+    @table_view.model = @model
+  end
+
+private
+
+  # The collection of model objects to display in a table
+  # arg can either be a Hash, in which case a new CacheTable
+  # is created, or it can be an array
+  # called by records( *args )
+  def set_records( arg )
+    if arg.class == Hash
+      # need to defer this until all fields are collected
+      @options = arg
+    else
+      @records = arg
+    end
+  end
+
+  # return a collection of records. Usually this will be a CacheTable.
+  # called by records( *args )
+  def get_records
+    if @records.nil?
+      #~ add_include_options
+      @records = CacheTable.new( model_class, @options )
+    end
+    @records
+  end
+end
+
+end

data/lib/clevic/model_column.rb

@@ -0,0 +1,23 @@
+=begin rdoc
+This responds to the same methods as ActiveRecord::ConnectionAdapter::Column.
+It exists to pretend that the accessors generated by association methods
+have a column type of :association, which lets us make a sensible paste
+decision using PasteRole, and makes the field/attribute distinction possible
+in ModelIndex.
+=end
+class ModelColumn
+  attr_accessor :primary, :scale, :sql_type, :name, :precision, :default, :limit, :type, :meta
+  
+  def initialize( name, type, meta )
+    @name = name
+    @type = type
+    @meta = meta
+  end
+  
+  # return the underlying field name, ie "#{attribute}_id" if
+  # it's an association
+  alias_method :old_name, :name
+  def name
+    @meta.name
+  end
+end

data/lib/clevic/search_dialog.rb

@@ -0,0 +1,77 @@
+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
+    
+    # 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
+  
+end