clevic 0.8.0 → 0.11.1

data/config/hoe.rb

@@ -8,9 +8,10 @@ RUBYFORGE_PROJECT = 'clevic' # The unix name for your project
 HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
 DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
 EXTRA_DEPENDENCIES = [
-    ['qtext', '>=0.5.0'],
-    ['activerecord', '=2.0.2'],
-    ['fastercsv', '>=1.2.3']
+    ['qtext', '>=0.6.2'],
+    ['activerecord', '>=2.0.2'],
+    ['fastercsv', '>=1.2.3'],
+    ['gather', '>=0.0.3']
     # This isn't always installed from gems
     #~ ['qtruby4', '>=1.4.9']
     # bsearch can't be installed from gems
@@ -44,6 +45,9 @@ RDOC_OPTS = ['--quiet', '--title', 'clevic documentation',
     "--opname", "index.html",
     "--line-numbers",
     "--main", "README",
+    #~ '--accessor=property',
+    '-A', 'property=Property',
+    '--format=darkfish',
     "--inline-source"]
 
 class Hoe

data/lib/clevic.rb

@@ -1,6 +1,4 @@
+# This provides enough to define UIs.
 require 'clevic/db_options.rb'
-require 'clevic/table_view.rb'
-require 'clevic/model_builder.rb'
 require 'clevic/record.rb'
-
-
+require 'clevic/view.rb'

data/lib/clevic/browser.rb

@@ -1,17 +1,20 @@
 require 'clevic/search_dialog.rb'
 require 'clevic/ui/browser_ui.rb'
-require 'clevic/record.rb'
+require 'clevic/table_view.rb'
 require 'clevic.rb'
 
 module Clevic
 
 =begin rdoc
-The main application class. Display as many tabs as there are Clevic::Record or ActiveRecord::Base
-subclasses. 
+The main application class. Display one tabs for each descendant of Clevic::View
+in Clevic::View.order. DefaultView classes created by Clevic::Record are automatically
+added.
 =end
 class Browser < Qt::Widget
   slots *%w{dump() refresh_table() filter_by_current(bool) next_tab() previous_tab() current_changed(int)}
   
+  attr_reader :tables_tab
+  
   def initialize( main_window )
     super( main_window )
     
@@ -42,10 +45,17 @@ class Browser < Qt::Widget
     
     tables_tab.connect                SIGNAL( 'currentChanged(int)' ),  &method( :current_changed )
     
-    load_models
+    load_views
     update_menus
+    main_window.window_title = [database_name, 'Clevic'].compact.join ' '
   end
   
+  # Set the main window title to the name of the database, if we can find it.
+  def database_name
+    #~ FIXME #{__FILE__}:#{__LINE__}"
+    #~ table_view.model.db_options.database
+  end  
+  
   def update_menus
     # update edit menu
     @layout.menu_edit.clear
@@ -70,7 +80,7 @@ class Browser < Qt::Widget
   # activated by Ctrl-Shift-D for debugging
   def dump
     puts "table_view.model: #{table_view.model.inspect}"
-    puts "table_view.model.model_class: #{table_view.model.model_class.inspect}"
+    puts "table_view.model.entity_class: #{table_view.model.entity_class.inspect}"
   end
   
   # return the Clevic::TableView object in the currently displayed tab
@@ -78,10 +88,6 @@ class Browser < Qt::Widget
     tables_tab.current_widget
   end
   
-  def tables_tab
-    @tables_tab
-  end
-  
   # slot to handle Ctrl-Tab and move to next tab, or wrap around
   def next_tab
     tables_tab.current_index = 
@@ -114,53 +120,33 @@ class Browser < Qt::Widget
     Qt::Application.translate("Browser", st, nil, Qt::Application::UnicodeUTF8)
   end
 
-  # return the list of descendants of ActiveRecord::Base, or
-  # of Clevic::Record
-  def find_models
-    models = []
-    ObjectSpace.each_object( Class ) do |x|
-      if x.ancestors.include?( ActiveRecord::Base )
-        case
-          when x == ActiveRecord::Base; # don't include this
-          when x == Clevic::Record; # don't include this
-          else; models << x
-        end
-      end
-    end
-    models.sort{|a,b| a.name <=> b.name}
-  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 load_models
-    models = Clevic::Record.models
-    models = find_models if models.empty?
+  # Create the tabs, each with a collection for a particular entity class.
+  # views come from Clevic::View.order
+  def load_views
+    views = Clevic::View.order.uniq
+    Kernel.raise "no views to display" if views.empty?
     
     # Add all existing model objects as tabs, one each
-    models.each do |model_class|
-      begin
-        next unless model_class.table_exists?
+    views.each do |view_class|
+      view = view_class.new
+      unless view.entity_class.table_exists?
+        puts "No table for #{view.entity_class.inspect}"
+        next
+      end
         
-        # create the the table_view and the table_model for the model_class
-        tab =
-        if model_class.respond_to?( :ui )
-          puts "Entity#ui deprecated. Use build_table_model instead."
-          model_class.ui( tables_tab )
-        else
-          Clevic::TableView.new( model_class, tables_tab )
-        end
+      begin
+        # create the the table_view and the table_model for the entity_class
+        tab = Clevic::TableView.new( view )
         
         # show status messages
         tab.connect( SIGNAL( 'status_text(QString)' ) ) { |msg| @layout.statusbar.show_message( msg, 10000 ) }
         
         # add a new tab
-        tables_tab.add_tab( tab, translate( model_class.name.demodulize.tableize.humanize ) )
+        tables_tab.add_tab( tab, translate( tab.title ) )
         
         # add the table to the Table menu
         action = Qt::Action.new( @layout.menu_model )
-        action.text = translate( model_class.name.demodulize.tableize.humanize )
+        action.text = translate( tab.title )
         action.connect SIGNAL( 'triggered()' ) do
           tables_tab.current_widget = tab
         end
@@ -169,12 +155,14 @@ class Browser < Qt::Widget
         # handle filter status changed, so we can provide a visual indication
         tab.connect SIGNAL( 'filter_status(bool)' ) do |status|
           # update the tab, so there's a visual indication of filtering
-          tab_title = ( tab.filtered ? '| ' : '' ) + translate( model_class.name.humanize )
-          tables_tab.set_tab_text( tables_tab.current_index, tab_title )
+          filter_title = ( tab.filtered ? '| ' : '' ) + translate( tab.title )
+          tables_tab.set_tab_text( tables_tab.current_index, filter_title )
         end
       rescue Exception => e
-        puts e.backtrace if $options[:debug]
-        puts "Model #{model_class} will not be available: #{e.message}"
+        puts
+        puts "UI from #{view} will not be available: #{e.message}"
+        puts e.backtrace #if $options[:debug]
+        puts
       end
     end
   end

data/lib/clevic/cache_table.rb

@@ -1,57 +1,16 @@
 require 'rubygems'
 require 'active_record'
-require 'active_record/dirty.rb'
+require 'clevic/table_searcher.rb'
+require 'clevic/order_attribute.rb'
 require 'bsearch'
 
-=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
-  
+begin
+  require 'active_record/dirty.rb'
+rescue MissingSourceFile
+  require 'clevic/dirty.rb'
 end
 
+
 =begin rdoc
 Fetch rows from the db on demand, rather than all up front.
 
@@ -61,7 +20,7 @@ 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
 
@@ -71,125 +30,59 @@ for each call?
 class CacheTable < Array
   # the number of records loaded in one call to the db
   attr_accessor :preload_count
-  attr_reader :options, :model_class
+  attr_reader :options, :entity_class
   
-  def initialize( model_class, find_options = {} )
+  def initialize( entity_class, find_options = {} )
     @preload_count = 20
     # must be before sanitise_options
-    @model_class = model_class
+    @entity_class = entity_class
     # must be before anything that uses options
-    @options = sanitise_options( find_options )
+    @options = find_options.clone
+    sanitise_options!
     
     # size the array and fill it with nils. They'll be filled
     # in by the [] operator
     @row_count = sql_count
-    super(@row_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
-  
-  # 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 model_class.connection.adapter_name
-      when 'PostgreSQL'
-        value ? 'true' : 'false'
-      else
-        value ? model_class.connection.quoted_true : model_class.connection.quoted_false
-    end
-  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 #{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 )
+    @entity_class.count( @options.reject{|k,v| k == :order} )
   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 )
-    
-    # only Postgres seems to understand real booleans
-    # everything else needs the big case statement to be compared
-    # to something
-    unless model_class.connection.adapter_name == 'PostgreSQL'
-      sql += " = #{sql_boolean true}"
+  # Return the set of OrderAttribute objects for this collection.
+  # If no order attributes are specified, the primary key will be used.
+  # TODO what about compund primary keys?
+  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(@entity_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 == @entity_class.primary_key }
+        @order_attributes << OrderAttribute.new( @entity_class, @entity_class.primary_key )
+      end
     end
-    
-    # build parameter values
-    params = {}
-    @order_attributes.each {|x| params[x.to_sym] = entity.send( x.attribute )}
-    { :sql => sql, :params => params }
+    @order_attributes
   end
   
   # add an id to options[:order] if it's not in there
   # also create @order_attributes, and @auto_new
-  def sanitise_options( options )
+  def sanitise_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)}
-    
-    # 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
+    @auto_new = @options[:auto_new]
+    @options.delete :auto_new
     
-    # recreate the options[:order] entry
-    options[:order] = @order_attributes.map{|x| x.to_sql}.join(',')
+    # make sure we have a string here
+    @options[:order] ||= ''
     
-    # give back the sanitised options
-    options
+    # recreate the options[:order] entry to include default
+    # TODO why though?
+    @options[:order] = order_attributes.map{|x| x.to_sql}.join(',')
   end
 
   # Execute the block with the specified preload_count,
@@ -211,7 +104,7 @@ EOF
     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 = @entity_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
@@ -228,23 +121,7 @@ EOF
   # 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
+    self.class.new( @entity_class, @options.merge( options ) )
   end
   
   # find the index for the given entity, using a binary search algorithm (bsearch).
@@ -255,7 +132,8 @@ EOF
     return nil if size == 0
     return nil if entity.nil?
     
-    # only load one record at a time
+    # only load one record at a time, because mostly we only
+    # need one for the binary seach. No point in pulling several out.
     preload_limit( 1 ) do
       # do the binary search based on what we know about the search order
       bsearch do |candidate|
@@ -266,6 +144,7 @@ EOF
             # compare taking ordering direction into account
             retval =
             if attribute.direction == :asc
+              # TODO which would be more efficient here?
               #~ candidate.send( method ) <=> entity.send( method )
               candidate[method] <=> entity[method]
             else
@@ -290,20 +169,31 @@ EOF
     @auto_new
   end
   
+  def search( field, search_criteria, start_entity )
+    Clevic::TableSearcher.new( entity_class, order_attributes, search_criteria, field ).search( start_entity )
+  end
+
+  # delete the given index. If the size ends up as 0,
   # make sure there's always at least one empty record
   def delete_at( index )
     retval = super
     if self.size == 0 && auto_new?
-      self << @model_class.new
+      self << @entity_class.new
     end
     retval
   end
   
 end
 
+# This is part of Array in case the programmer wants to use
+# a simple array instead of a CacheTable.
 class Array
   # For use with CacheTable. Return true if something is cached, false otherwise
   def cached_at?( index )
     !at(index).nil?
   end
+  
+  def searcher
+    raise "not implemented"
+  end
 end