clevic 0.6.0 → 0.7.0

data/bin/clevic

@@ -20,7 +20,7 @@ BANNER
 oparser.separator ''
 
 oparser.on( '-H', '--host HOST', 'RDBMS host', String ) { |o| $options[:host] = o }
-oparser.on( '-u', '--user USERNAME', String ) { |o| $options[:user] = o }
+oparser.on( '-u', '--user USERNAME', String ) { |o| $options[:username] = o }
 oparser.on( '-p', '--pass PASSWORD', String ) { |o| $options[:password] = o }
 oparser.on( '-t', '--table TABLE', 'Table to display', String ) { |o| $options[:table] = o }
 oparser.on( '-d', '--database DATABASE', 'Database name', String ) { |o| $options[:database] = o }
@@ -33,6 +33,11 @@ end
 
 args = oparser.parse( ARGV )
 
+if $options[:debug]
+  require 'pp'
+  pp $options
+end
+
 if args.size > 0
   $options[:definition] = args.shift
   require_if "#{$options[:definition]}_models"
@@ -46,8 +51,8 @@ app = Qt::Application.new( args )
 # show UI
 main_window = Qt::MainWindow.new
 browser = Clevic::Browser.new( main_window )
-browser.open
 # this must come after Clevic::Browser.new
+# TODO should really find a better place for this
 main_window.window_title = $options[:database]
 main_window.show
 # make sure any partially edited records are saved when the window is closed

data/config/hoe.rb

@@ -8,10 +8,12 @@ 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.2.0'],
-    ['activerecord', '>=2.0.2']
+    ['qtext', '>=0.4.1'],
+    ['activerecord', '=2.0.2'],
+    ['fastercsv', '>=1.2.3']
     # This isn't always installed from gems
     #~ ['qtruby4', '>=1.4.9']
+    # bsearch can't be installed from gems
 ]    # An array of rubygem dependencies [name, version]
 
 @config_file = "~/.rubyforge/user-config.yml"

data/lib/clevic.rb

@@ -1,5 +1,6 @@
 require 'clevic/db_options.rb'
 require 'clevic/table_view.rb'
 require 'clevic/model_builder.rb'
+require 'clevic/record.rb'
 
 

data/lib/clevic/browser.rb

@@ -52,6 +52,7 @@ class Browser < Qt::Widget
     
     # as an example
     #~ tables_tab.connect SIGNAL( 'currentChanged(int)' ) { |index| puts "other current_changed: #{index}" }
+    load_models
   end
   
   # activated by Ctrl-D for debugging
@@ -155,15 +156,36 @@ class Browser < Qt::Widget
     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
+  # return the list of descendants of ActiveRecord::Base
+  def find_models
+    models = []
+    ObjectSpace.each_object( Class ) {|x| models << x if x.ancestors.include?( Clevic::Record ) }
+    models
+  end
+  
+  # define a default ui with plain fields for all
+  # columns (except id) in the model. Could combine this with
+  # DrySQL to automate the process.
+  def define_default_ui( model )
+    reflections = model.reflections.keys.map{|x| x.to_s}
+    ui_columns = model.columns.reject{|x| x.name == 'id' }.map do |x|
+      att = x.name.gsub( '_id', '' )
+      if reflections.include?( att )
+        att
+      else
+        x.name
+      end
+    end
+    
+    Clevic::TableView.new( model, tables_tab ).create_model do
+      ui_columns.each do |column|
+        if model.reflections.has_key?( column.to_sym )
+          relational column.to_sym
+        else
+          plain column.to_sym
+        end
+      end
+      records :order => 'id'
     end
   end
   
@@ -171,17 +193,18 @@ class Browser < Qt::Widget
   #
   # 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?
+  def load_models
+    models = Clevic::Record.models || find_models
     
     # Add all existing model objects as tabs, one each
-    find_models( models ).each do |model|
+    models.each do |model|
+      tab = 
       if model.respond_to?( :ui )
-        tab = model.ui( tables_tab )
-        tab.connect( SIGNAL( 'status_text(QString)' ) ) { |msg| @layout.statusbar.show_message( msg, 20000 ) }
+        model.ui( tables_tab )
       else
-        raise "Can't build ui for #{model.name}. Provide a self.ui method."
+        define_default_ui( model )
       end
+      tab.connect( SIGNAL( 'status_text(QString)' ) ) { |msg| @layout.statusbar.show_message( msg, 20000 ) }
       tables_tab.add_tab( tab, translate( model.name.humanize ) )
     end
   end

data/lib/clevic/cache_table.rb

@@ -3,8 +3,6 @@ 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
@@ -73,7 +71,7 @@ for each call?
 class CacheTable < Array
   # the number of records loaded in one call to the db
   attr_accessor :preload_count
-  attr_reader :options
+  attr_reader :options, :model_class
   
   def initialize( model_class, find_options = {} )
     @preload_count = 20
@@ -106,13 +104,25 @@ class CacheTable < Array
     @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 'false' if index == @order_attributes.size
+    return sql_boolean( false ) if index == @order_attributes.size
     
     # fetch the current attribute
     attribute = @order_attributes[index]
@@ -120,11 +130,12 @@ class CacheTable < Array
     # build case statement, including recusion
     st = <<-EOF
 case
-  when #{quote_column attribute} #{operator} :#{attribute} then true
+  when #{quote_column attribute} #{operator} :#{attribute} then #{sql_boolean true}
   when #{quote_column attribute} = :#{attribute} then #{build_recursive_comparison( operator, index+1 )}
-  else false
+  else #{sql_boolean false}
 end
 EOF
+    st.gsub!( /^/, '  ' * index )
   end
   
   # return a Hash containing
@@ -143,6 +154,13 @@ EOF
     # 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}"
+    end
+    
     # build parameter values
     params = {}
     @order_attributes.each {|x| params[x.to_sym] = entity.send( x.attribute )}
@@ -234,10 +252,8 @@ EOF
     
     # 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

data/lib/clevic/db_options.rb

@@ -8,7 +8,7 @@ connection to a particular database. Like this:
   Clevic::DbOptions.connect( $options ) do
     database :accounts
     adapter :postgresql
-    username 'panic'
+    username 'accounts_user'
   end
 
 When the block ends, a check is done to see that the :database key
@@ -21,7 +21,9 @@ with the options value passed in (in this case $options).
 Values have to_s called on them so they can be symbols or strings.
 =end
 class DbOptions
-  def initialize( options )
+  attr_reader :options
+  
+  def initialize( options = nil )
     @options = options || {}
     # make sure the relevant entries exist, so method_missing works
     @options[:adapter] ||= ''
@@ -44,21 +46,22 @@ class DbOptions
     end
     
     # connect to db
-    ActiveRecord::Base.establish_connection( @options )
-    ActiveRecord::Base.logger = Logger.new(STDOUT) if @options[:verbose]
+    ActiveRecord::Base.establish_connection( options )
+    ActiveRecord::Base.logger = Logger.new(STDOUT) if options[:verbose]
     #~ ActiveRecord.colorize_logging = @options[:verbose]
-    puts "using database #{ActiveRecord::Base.connection.raw_connection.db}" if $options[:debug]
+    puts "using database #{ActiveRecord::Base.connection.raw_connection.db}" if options[:debug]
+    self
   end
   
   # convenience method so we can do things like
   #   Clevic::DbOptions.connect( $options ) do
   #     database :accounts
   #     adapter :postgresql
-  #     username 'panic'
+  #     username 'accounts_user'
   #   end
   # the block is evaluated in the context of the a new DbOptions
   # object.
-  def self.connect( args, &block )
+  def self.connect( args = nil, &block )
     inst = self.new( args )
     # using the Rails implementation, included in Qt
     block.bind( inst )[*args]
@@ -70,7 +73,7 @@ class DbOptions
   # variable
   def method_missing(meth, *args, &block)
     if @options.has_key? meth.to_sym
-      @options[meth.to_sym] = args[0].to_s
+      @options[meth.to_sym] = args[0].to_s if @options[meth.to_sym].empty?
     else
       super
     end

data/lib/clevic/delegates.rb

@@ -219,7 +219,7 @@ class DistinctDelegate < ComboDelegate
     @attribute = attribute
     @options = options
     # hackery for amateur query building in populate
-    @options[:conditions] ||= 'true'
+    @options[:conditions] ||= '1=1'
     super( parent )
   end
   
@@ -259,10 +259,13 @@ class DistinctDelegate < ComboDelegate
     # to be in the select list where distinct is involved
     conn = @ar_model.connection
     query =
-    if @options[:frequency]
-      query_order_frequency( conn, model_index )
-    else
-      query_order_description( conn, model_index )
+    case
+      when @options[:description]
+        query_order_description( conn, model_index )
+      when @options[:frequency]
+        query_order_frequency( conn, model_index )
+      else
+        query_order_frequency( conn, model_index )
     end
     rs = conn.execute( query )
     rs.each do |row|
@@ -304,17 +307,21 @@ end
 
 # Edit a relation from an id and display a list of relevant entries.
 #
-# attribute_path is the full dotted path to get from the entity in the
-# model to the values displayed in the combo box.
+# attribute is the method to call on the row entity to retrieve the related object.
 # 
 # The ids of the ActiveRecord models are stored in the item data
 # and the item text is fetched from them using attribute_path.
 class RelationalDelegate < ComboDelegate
-
-  def initialize( parent, attribute_path, options )
-    @model_class = ( options[:class_name] || attribute_path[0].to_s.classify ).constantize
-    @attribute_path = attribute_path[1..-1].join('.')
+  
+  def initialize( parent, attribute, options )
+    @model_class = ( options[:class_name] || attribute.to_s.classify ).constantize
+    # TODO this doesn't seem to be used
+    @attribute = attribute.to_s
     @options = options.clone
+    unless @options[:conditions].nil?
+      @options[:conditions].gsub!( /true/, @model_class.connection.quoted_true )
+      @options[:conditions].gsub!( /false/, @model_class.connection.quoted_false )
+    end
     [ :class_name, :sample, :format ].each {|x| @options.delete x }
     super( parent )
   end
@@ -338,7 +345,7 @@ class RelationalDelegate < ComboDelegate
       if item
         item_index = editor.find_data( item.id.to_variant )
         if item_index == -1
-          editor.add_item( item[@attribute_path], item.id.to_variant )
+          add_to_list( editor, model_index, item )
         end
       end
     end
@@ -347,10 +354,14 @@ class RelationalDelegate < ComboDelegate
   def populate( editor, model_index )
     # add set of all possible related entities
     @model_class.find( :all, collect_finder_options( @options ) ).each do |x|
-      editor.add_item( x[@attribute_path], x.id.to_variant )
+      add_to_list( editor, model_index, x )
     end
   end
   
+  def add_to_list( editor, model_index, item )
+    editor.add_item( model_index.field.transform_attribute( item ), item.id.to_variant )
+  end
+  
   # send data to the editor
   def setEditorData( editor, model_index )
     if is_combo?( editor )

data/lib/clevic/extensions.rb

@@ -48,8 +48,12 @@ module Qt
   class ModelIndex
     # the value to be displayed in the gui for this index
     def gui_value
-      return nil if entity.nil?
-      entity.evaluate_path( attribute_path )
+      field.value_for( entity )
+    end
+    
+    # return the Clevic::Field for this index
+    def field
+      @field ||= model.field_for_index( self )
     end
     
     # set the value returned from the gui, as whatever the underlying

data/lib/clevic/field.rb

@@ -8,13 +8,14 @@ This defines a field in the UI, and how it hooks up to a field in the DB.
 class Field
   include QtFlags
   
-  attr_accessor :attribute, :path, :label, :delegate, :class_name, :alignment, :format, :tooltip
-  attr_writer :sample
+  attr_accessor :attribute, :path, :label, :delegate, :class_name
+  attr_accessor :alignment, :format, :tooltip, :path_block
+  attr_writer :sample, :read_only
   
   # 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 )
+    unless model_class.has_attribute?( attribute ) or model_class.instance_methods.include?( attribute.to_s )
       msg = <<EOF
 #{attribute} not found in #{model_class.name}. Possibilities are:
 #{model_class.attribute_names.join("\n")}
@@ -27,7 +28,14 @@ EOF
     @model_class = model_class
     
     options.each do |key,value|
-      self.send( "#{key}=", value ) if respond_to?( key )
+      self.send( "#{key}=", value ) if respond_to?( "#{key}=" )
+    end
+    
+    # TODO could convert everything to a block here, even paths
+    if options[:display].kind_of?( Proc )
+      @path_block = options[:display]
+    else
+      @path = options[:display]
     end
     
     # default the label
@@ -53,6 +61,31 @@ EOF
     end
   end
   
+  # Return the attribute value for the given entity, which may
+  # be an ActiveRecord instance
+  # entity is an ActiveRecord instance
+  def value_for( entity )
+    return nil if entity.nil?
+    transform_attribute( entity.send( attribute ) )
+  end
+  
+  # apply path, or path_block, to the given
+  # attribute value. Otherwise just return
+  # attribute_value itself
+  def transform_attribute( attribute_value )
+    return nil if attribute_value.nil?
+    case
+      when !path_block.nil?
+        path_block.call( attribute_value )
+        
+      when !path.nil?
+        attribute_value.evaluate_path( path.split( /\./ ) )
+        
+      else
+        attribute_value
+    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?
@@ -65,11 +98,19 @@ EOF
     @model_class.columns_hash[attribute.to_s] || @model_class.reflections[attribute]
   end
 
+  # return true if this field can be used in a filter
+  # virtual fields (ie those that don't exist in this field's
+  # table) can't be filtered on.
+  def filterable?
+    !meta.nil?
+  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
 
+  # return the result of the attribute + the path
   def column
     [attribute.to_s, path].compact.join('.')
   end
@@ -81,6 +122,11 @@ EOF
     pieces.map{|x| x.to_sym}
   end
   
+  # is the field read-only. Defaults to false.
+  def read_only?
+    @read_only || false
+  end
+  
   # format this value. Use strftime for date_time types, or % for everything else
   def do_format( value )
     if self.format != nil
@@ -103,7 +149,7 @@ EOF
         when :string, :text
           string_sample( 'n'*40 )
         
-        when :date, :time, :datetime
+        when :date, :time, :datetime, :timestamp
           date_time_sample
         
         when :numeric, :decimal, :integer, :float
@@ -112,8 +158,11 @@ EOF
         # TODO return a width, or something like that
         when :boolean; 'W'
         
+        when ActiveRecord::Reflection::AssociationReflection
+          #TODO width for relations
+        
         else
-          puts "#{@model_class.name}.#{attribute} is a #{meta.type}"
+          puts "#{@model_class.name}.#{attribute} is a #{meta.type.inspect}"
       end
         
       if $options[:debug]