clevic 0.5.1

data/lib/clevic.rb

@@ -0,0 +1,4 @@
+require 'clevic/table_view.rb'
+require 'clevic/model_builder.rb'
+
+

data/lib/clevic/browser.rb

@@ -0,0 +1,195 @@
+require 'clevic/search_dialog.rb'
+require 'clevic/ui/browser_ui.rb'
+
+module Clevic
+
+=begin rdoc
+The main application class. Each model for display should have a self.ui method
+which returns a Clevic::TableView instance, usually in conjunction with
+a ModelBuilder.
+
+  Clevic::TableView.new( Entry, parent ).create_model.new( Entry, parent ).create_model
+    .
+    .
+    .
+  end
+  
+Model instances 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 Browser < Qt::Widget
+  slots *%w{dump() refresh_table() filter_by_current(bool) next_tab() previous_tab() current_changed(int)}
+  
+  def initialize( main_window )
+    super( main_window )
+    
+    # do menus and widgets
+    @layout = Ui::Browser.new
+    @layout.setup_ui( main_window )
+    
+    # set icon. MUST come after call to setup_ui
+    icon_path = Pathname.new( __FILE__ ).parent + "ui/icon.png"
+    raise "icon.png not found" unless icon_path.file?
+    main_window.window_icon = Qt::Icon.new( icon_path.realpath.to_s )
+    
+    # add the tables tab
+    @tables_tab = Qt::TabWidget.new( @layout.main_widget )
+    @layout.main_widget.layout.add_widget @tables_tab
+    @tables_tab.tab_bar.focus_policy = Qt::NoFocus
+    
+    # connect slots
+    @layout.action_dump.connect       SIGNAL( 'triggered()' ),          &method( :dump )
+    @layout.action_refresh.connect    SIGNAL( 'triggered()' ),          &method( :refresh_table )
+    @layout.action_filter.connect     SIGNAL( 'triggered(bool)' ),      &method( :filter_by_current )
+    @layout.action_next.connect       SIGNAL( 'triggered()' ),          &method( :next_tab )
+    @layout.action_previous.connect   SIGNAL( 'triggered()' ),          &method( :previous_tab )
+    @layout.action_find.connect       SIGNAL( 'triggered()' ),          &method( :find )
+    @layout.action_find_next.connect  SIGNAL( 'triggered()' ),          &method( :find_next )
+    @layout.action_new_row.connect    SIGNAL( 'triggered()' ),          &method( :new_row )
+    
+    tables_tab.connect                SIGNAL( 'currentChanged(int)' ),  &method( :current_changed )
+    
+    # as an example
+    #~ tables_tab.connect SIGNAL( 'currentChanged(int)' ) { |index| puts "other current_changed: #{index}" }
+  end
+  
+  # activated by Ctrl-D for debugging
+  def dump
+    puts "table_view.model: #{table_view.model.inspect}" if table_view.class == Clevic::TableView
+  end
+  
+  # return the Clevic::TableView object in the currently displayed tab
+  def table_view
+    tables_tab.current_widget
+  end
+  
+  def tables_tab
+    @tables_tab
+  end
+  
+  # display a search dialog, and find the entered text
+  def find
+    @search_dialog ||= SearchDialog.new
+    result = @search_dialog.exec( table_view.current_index.gui_value )
+    
+    override_cursor( Qt::BusyCursor ) do
+      case result
+        when Qt::Dialog::Accepted
+          search_for = @search_dialog.search_text
+          table_view.search( @search_dialog )
+        when Qt::Dialog::Rejected
+          puts "Don't search"
+        else
+          puts "unknown dialog code #{result}"
+      end
+    end
+  end
+  
+  def find_next
+    if @search_dialog.nil?
+      @layout.statusbar.show_message( 'No previous find' )
+    else
+      override_cursor( Qt::BusyCursor ) do
+        save_from_start = @search_dialog.from_start?
+        @search_dialog.from_start = false
+        table_view.search( @search_dialog )
+        @search_dialog.from_start = save_from_start
+      end
+    end
+  end
+  
+  # force a complete reload of the current tab's data
+  def refresh_table
+    override_cursor( Qt::BusyCursor ) do
+      table_view.model.reload_data
+    end
+  end
+  
+  # toggle the filter, based on current selection.
+  def filter_by_current( bool_filter )
+    # TODO if there's no selection, use the current index instead
+    table_view.filter_by_indexes( table_view.selection_model.selected_indexes )
+    
+    # set the checkbox in the menu item
+    @layout.action_filter.checked = table_view.filtered
+    
+    # update the tab, so there's a visual indication of filtering
+    tab_title = table_view.filtered ? translate( '| ' + table_view.model_class.name.humanize ) : translate( table_view.model_class.name.humanize )
+    tables_tab.set_tab_text( tables_tab.current_index, tab_title )
+  end
+  
+  # slot to handle Ctrl-Tab and move to next tab, or wrap around
+  def next_tab
+    tables_tab.current_index = 
+    if tables_tab.current_index >= tables_tab.count - 1
+      0
+    else
+      tables_tab.current_index + 1
+    end
+  end
+
+  # slot to handle Ctrl-Backtab and move to previous tab, or wrap around
+  def previous_tab
+    tables_tab.current_index = 
+    if tables_tab.current_index <= 0
+      tables_tab.count - 1
+    else
+      tables_tab.current_index - 1
+    end
+  end
+  
+  def new_row
+    table_view.model.add_new_item
+  end
+  
+  # slot to handle the currentChanged signal from tables_tab, and
+  # set focus on the grid
+  def current_changed( current_tab_index )
+    tables_tab.current_widget.setFocus
+    @layout.action_filter.checked = table_view.filtered
+  end
+  
+  # shortcut for the Qt translate call
+  def translate( st )
+    Qt::Application.translate("Browser", st, nil, Qt::Application::UnicodeUTF8)
+  end
+
+  # return the list of models in $options[:models] or find them
+  # as descendants of ActiveRecord::Base
+  def find_models( models = $options[:models] )
+    if models.nil? || models.empty?
+      models = []
+      ObjectSpace.each_object( Class ) {|x| models << x if x.superclass == ActiveRecord::Base }
+      models
+    else
+      models
+    end
+  end
+  
+  # Create the tabs, each with a collection for a particular model class.
+  #
+  # models parameter can be an array of Model objects, in order of display.
+  # if models is nil, find_models is called
+  def open( *models )
+    models = $options[:models] if models.empty?
+    
+    # Add all existing model objects as tabs, one each
+    find_models( models ).each do |model|
+      if model.respond_to?( :ui )
+        tab = model.ui( tables_tab )
+        tab.connect( SIGNAL( 'status_text(QString)' ) ) { |msg| @layout.statusbar.show_message( msg, 20000 ) }
+      else
+        raise "Can't build ui for #{model.name}. Provide a self.ui method."
+      end
+      tables_tab.add_tab( tab, translate( model.name.humanize ) )
+    end
+  end
+  
+  # make sure all outstanding records are saved
+  def save_all
+    tables_tab.each {|x| x.save_row( x.current_index ) }
+  end
+end
+
+end

data/lib/clevic/cache_table.rb

@@ -0,0 +1,281 @@
+require 'rubygems'
+require 'active_record'
+require 'active_record/dirty.rb'
+require 'bsearch'
+
+require 'profiler'
+
+=begin rdoc
+Store the SQL order_by attributes with ascending and descending values
+=end
+class OrderAttribute
+  attr_reader :direction, :attribute
+  
+  def initialize( model_class, sql_order_fragment )
+    @model_class = model_class
+    if sql_order_fragment =~ /.*\.(.*?) *asc/
+      @direction = :asc
+      @attribute = $1
+    elsif sql_order_fragment =~ /.*\.(.*?) *desc/
+      @direction = :desc
+      @attribute = $1
+    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
+    "#{@model_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
+    "#{@model_class.table_name}.#{attribute} #{reverse(direction).to_s}"
+  end
+  
+end
+
+=begin rdoc
+Fetch rows from the db on demand, rather than all up front.
+
+Being able to change the recordset on the fly and still find a previously
+known entity in the set requires a defined ordering, so if no ordering
+is specified, the primary key of the entity will be used.
+
+It hasn't been tested with compound primary keys.
+--
+TODO drop rows when they haven't been accessed for a while
+
+TODO how to handle a quickly-changing underlying table? invalidate cache
+for each call?
+=end
+class CacheTable < Array
+  # the number of records loaded in one call to the db
+  attr_accessor :preload_count
+  attr_reader :options
+  
+  def initialize( model_class, find_options = {} )
+    @preload_count = 20
+    # must be before sanitise_options
+    @model_class = model_class
+    # must be before anything that uses options
+    @options = sanitise_options( find_options )
+    
+    # size the array and fill it with nils. They'll be filled
+    # in by the [] operator
+    @row_count = sql_count
+    super(@row_count)
+  end
+  
+  # The count of the records according to the db, which may be different to
+  # the records in the cache
+  def sql_count
+    @model_class.count( :conditions => @options[:conditions] )
+  end
+  
+  def order
+    @options[:order]
+  end
+  
+  def reverse_order
+    @order_attributes.map{|x| x.to_reverse_sql}.join(',')
+  end
+  
+  def quote_column( field_name )
+    @model_class.connection.quote_column_name( field_name )
+  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 'false' if index == @order_attributes.size
+    
+    # fetch the current attribute
+    attribute = @order_attributes[index]
+    
+    # build case statement, including recusion
+    st = <<-EOF
+case
+  when #{quote_column attribute} #{operator} :#{attribute} then true
+  when #{quote_column attribute} = :#{attribute} then #{build_recursive_comparison( operator, index+1 )}
+  else false
+end
+EOF
+  end
+  
+  # return a Hash containing
+  # :sql => the sql statement to be used as part of a where clause
+  # :params => the parameters corresponding to :sql
+  # entity is an AR model object
+  # direction is either :forwards or :backwards
+  def build_sql_find( entity, direction )
+    operator =
+    case direction
+      when :forwards; '>'
+      when :backwards; '<'
+      else; raise "unknown direction #{direction.inspect}"
+    end
+    
+    # build the sql comparison where clause fragment
+    sql = build_recursive_comparison( operator )
+    
+    # build parameter values
+    params = {}
+    @order_attributes.each {|x| params[x.to_sym] = entity.send( x.attribute )}
+    { :sql => sql, :params => params }
+  end
+  
+  # add an id to options[:order] if it's not in there
+  # also create @order_attributes
+  def sanitise_options( options )
+    options[:order] ||= ''
+    @order_attributes = options[:order].split( /, */ ).map{|x| OrderAttribute.new(@model_class, x)}
+    
+    # add the primary key if nothing is specified
+    # because we need an ordering of some kind otherwise
+    # index_for_entity will not work
+    if !@order_attributes.any? {|x| x.attribute == @model_class.primary_key }
+      @order_attributes << OrderAttribute.new( @model_class, @model_class.primary_key )
+    end
+    
+    # recreate the options[:order] entry
+    options[:order] = @order_attributes.map{|x| x.to_sql}.join(',')
+    
+    # give back the sanitised options
+    options
+  end
+
+  # Execute the block with the specified preload_count,
+  # and restore the existing one when done.
+  # Return the value of the block
+  def preload_limit( limit, &block )
+    old_limit = preload_count
+    self.preload_count = limit
+    retval = yield
+    self.preload_count = old_limit
+    retval
+  end
+  
+  # Fetch the entity for the given index from the db, and store it
+  # in the array. Also, preload preload_count records to avoid subsequent
+  # hits on the db
+  def fetch_entity( index )
+    # calculate negative indices for the SQL offset
+    offset = index < 0 ? index + @row_count : index
+    
+    # fetch self.preload_count records
+    records = @model_class.find( :all, @options.merge( :offset => offset, :limit => preload_count ) )
+    records.each_with_index {|x,i| self[i+index] = x if !cached_at?( i+index )}
+    
+    # return the first one
+    records[0]
+  end
+  
+  # return the entity at the given index. Fetch it from the
+  # db if it isn't in this array yet
+  def []( index )
+    super( index ) || fetch_entity( index )
+  end
+  
+  # make a new instance that has the attributes of this one, but an empty
+  # data set. pass in ActiveRecord options to filter
+  def renew( options = {} )
+    clear
+    self.class.new( @model_class, @options.merge( options ) )
+  end
+  
+  # Return the set of OrderAttribute objects for this collection
+  def order_attributes
+    # This is sorted in @options[:order], so use that for the search
+    if @order_attributes.nil?
+      @order_attributes = @options[:order].to_s.split( /, */ ).map{|x| OrderAttribute.new(@model_class, x)}
+      
+      # add the primary key if nothing is specified
+      # because we need an ordering of some kind otherwise
+      # index_for_entity will not work
+      if !@order_attributes.any? {|x| x.attribute == @model_class.primary_key }
+        @order_attributes << OrderAttribute.new( @model_class, @model_class.primary_key )
+      end
+    end
+    @order_attributes
+  end
+  
+  # find the index for the given entity, using a binary search algorithm (bsearch).
+  # The order_by ActiveRecord style options are used to do the binary search.
+  # 0 is returned if the entity is nil
+  # nil is returned if the array is empty
+  def index_for_entity( entity )
+    return nil if size == 0
+    return nil if entity.nil?
+    
+    # only load one record at a time
+    preload_limit( 1 ) do
+      #~ puts "entity: #{entity.inspect}"
+      # do the binary search based on what we know about the search order
+      bsearch do |candidate|
+        #~ puts "candidate: #{candidate.inspect}"
+        # find using all sort attributes
+        order_attributes.inject(0) do |result,attribute|
+          if result == 0
+            method = attribute.attribute.to_sym
+            # compare taking ordering direction into account
+            retval =
+            if attribute.direction == :asc
+              #~ candidate.send( method ) <=> entity.send( method )
+              candidate[method] <=> entity[method]
+            else
+              #~ entity.send( method ) <=> candidate.send( method )
+              entity[method] <=> candidate[method]
+            end
+            # exit now because we have a difference
+            next( retval ) if retval != 0
+            
+            # otherwise try with the next order attribute
+            retval
+          else
+            # they're equal, so try next order attribute
+            result
+          end
+        end
+      end
+    end
+  end
+  
+  def delete_at( index )
+    retval = super
+    if self.size == 0
+      self << @model_class.new
+    end
+    retval
+  end
+  
+end
+
+class Array
+  # For use with CacheTable. Return true if something is cached, false otherwise
+  def cached_at?( index )
+    !at(index).nil?
+  end
+end