clevic 0.8.0 → 0.11.1

data/models/minimal_models.rb

@@ -10,12 +10,14 @@ Clevic::DbOptions.connect do
 end
 
 # minimal definition to get combo boxes to show up
-class Entry < Clevic::Record
+class Entry < ActiveRecord::Base
+  include Clevic::Record
   belongs_to :debit, :class_name => 'Account', :foreign_key => 'debit_id'
   belongs_to :credit, :class_name => 'Account', :foreign_key => 'credit_id'
 end
 
 # minimal definition to get sensible values in combo boxes
-class Account < Clevic::Record
+class Account < ActiveRecord::Base
+  include Clevic::Record
   def to_s; name; end
 end

data/models/times_models.rb

@@ -1,25 +1,28 @@
 require 'clevic.rb'
 
-# db connection options
-db = Clevic::DbOptions.connect( $options ) do
-  # use a different db for testing, so real data doesn't get broken.
-  database( debug? ? :times_test : :times )
-  adapter :postgresql
-  username 'times'
-end
-
 # model definitions
-class Entry < Clevic::Record
+class Entry < ActiveRecord::Base
   belongs_to :invoice
   belongs_to :activity
   belongs_to :project
   
+  include Clevic::Record
+  def time_color
+    return if self.end.nil? || start.nil?
+    'darkviolet' if self.end - start > 8.hours
+  end
+  
+  def time_tooltip
+    return if self.end.nil? || start.nil?
+    'Time interval greater than 8 hours' if self.end - start > 8.hours
+  end
+  
   define_ui do
     plain       :date, :sample => '28-Dec-08'
     relational  :project, :display => 'project', :conditions => 'active = true', :order => 'lower(project)'
     relational  :invoice, :display => 'invoice_number', :conditions => "status = 'not sent'", :order => 'invoice_number'
-    plain       :start
-    plain       :end
+    plain       :start, :foreground => :time_color, :tooltip => :time_tooltip
+    plain       :end, :foreground => lambda{|x| x.time_color}, :tooltip => :time_tooltip
     plain       :description, :sample => 'This is a long string designed to hold lots of data and description'
     
     relational :activity do
@@ -51,24 +54,34 @@ class Entry < Clevic::Record
     view.sanity_check_read_only
     view.sanity_check_ditto
     
-    if view.current_index.row > 1
+    # need a reference to current_index here, because selection_model.clear will invalidate
+    # view.current_index. And anyway, its shorter and easier to read.
+    current_index = view.current_index
+    if current_index.row > 1
       # fetch previous item
-      model = view.model
-      previous_item = model.collection[view.current_index.row - 1]
+      previous_item = view.model.collection[current_index.row - 1]
       
       # copy the relevant fields
-      view.current_index.entity.start = previous_item.end
+      current_index.entity.start = previous_item.end
       [:date, :project, :invoice, :activity, :module, :charge, :person].each do |attr|
-        view.current_index.entity.send( "#{attr.to_s}=", previous_item.send( attr ) )
+        current_index.entity.send( "#{attr.to_s}=", previous_item.send( attr ) )
       end
       
       # tell view to update
-      top_left_index = model.create_index( view.current_index.row, 0 )
-      bottom_right_index = model.create_index( view.current_index.row, view.current_index.column + view.builder.fields.size )
+      top_left_index = current_index.choppy( :column => 0 )
+      bottom_right_index = current_index.choppy( :column => view.model.fields.size - 1 )
       view.dataChanged( top_left_index, bottom_right_index )
       
       # move to end time field
-      view.override_next_index( model.create_index( view.current_index.row, view.builder.index( :end ) ) )
+      view.selection_model.clear
+      next_field =
+      if current_index.entity.start.blank?
+        :start
+      else
+        :end
+      end
+      next_index = current_index.choppy( :column => view.field_column( next_field ) )
+      view.override_next_index( next_index )
     end
   end
 
@@ -89,18 +102,19 @@ class Entry < Clevic::Record
         current_index.entity.invoice = invoice
         
         # update view from top_left to bottom_right
-        model = current_index.model
-        changed_index = model.create_index( current_index.row, view.builder.index( :invoice ) )
+        changed_index = current_index.choppy( :column => view.field_column( :invoice ) )
         view.dataChanged( changed_index, changed_index )
         
         # move edit cursor to start time field
-        view.override_next_index( model.create_index( current_index.row, view.builder.index( :start ) ) )
+        view.selection_model.clear
+        view.override_next_index( current_index.choppy( :column => view.field_column( :start ) ) )
       end
     end
   end
 end
 
-class Invoice < Clevic::Record
+class Invoice < ActiveRecord::Base
+  include Clevic::Record
   has_many :entries
 
   define_ui do
@@ -117,7 +131,8 @@ class Invoice < Clevic::Record
   end
 end
 
-class Project < Clevic::Record
+class Project < ActiveRecord::Base
+  include Clevic::Record
   has_many :entries
 
   define_ui do
@@ -142,7 +157,8 @@ class Project < Clevic::Record
 
 end
 
-class Activity < Clevic::Record
+class Activity < ActiveRecord::Base
+  include Clevic::Record
   has_many :entries
 
   # define how fields are displayed

data/models/times_sqlite_models.rb

@@ -6,149 +6,5 @@ Clevic::DbOptions.connect( $options ) do
   adapter :sqlite3
 end
 
-# model definitions
-class Entry < Clevic::Record
-  belongs_to :invoice
-  belongs_to :activity
-  belongs_to :project
-  
-  # define how fields are displayed
-  def self.build_table_model( model_builder )
-    model_builder.instance_exec do
-      plain       :date, :sample => '28-Dec-08'
-      relational  :project, :display => 'project', :conditions => "active = true", :order => 'lower(project)'
-      relational  :invoice, :display => 'invoice_number', :conditions => "status = 'not sent'", :order => 'invoice_number'
-      plain       :start
-      plain       :end
-      plain       :description, :sample => 'This is a long string designed to hold lots of data and description'
-      relational  :activity, :display => 'activity', :order => 'lower(activity)', :sample => 'Troubleshooting', :conditions => 'active = #{connection.quoted_true}'
-      distinct    :module, :tooltip => 'Module or sub-project'
-      plain       :charge, :tooltip => 'Is this time billable?'
-      distinct    :person, :tooltip => 'The person who did the work'
-      
-      records     :order => 'date, start, id'
-    end
-  end
+require 'times_models.rb'
 
-  # called when a key is pressed in this model's table view
-  def self.key_press_event( event, current_index, view )
-    case
-      # copy almost all of the previous line
-      when event.ctrl? && event.quote_dbl?
-        if current_index.row > 1
-          # fetch previous item
-          model = current_index.model
-          previous_item = model.collection[current_index.row - 1]
-          
-          # copy the relevant fields
-          current_index.entity.start = previous_item.end
-          [:date, :project, :invoice, :activity, :module, :charge, :person].each do |attr|
-            current_index.entity.send( "#{attr.to_s}=", previous_item.send( attr ) )
-          end
-          
-          # tell view to update
-          top_left_index = model.create_index( current_index.row, 0 )
-          bottom_right_index = model.create_index( current_index.row, current_index.column + view.builder.fields.size )
-          view.dataChanged( top_left_index, bottom_right_index )
-          
-          # move to end time field
-          view.override_next_index( model.create_index( current_index.row, view.builder.index( :end ) ) )
-        end
-        # don't let anybody else handle the keypress
-        return true
-      
-      when event.ctrl? && event.i?
-        invoice_from_project( current_index, view )
-        # don't let anybody else handle the keypress
-        return true
-    end
-  end
-  
-  # called when data is changed in this model's table view
-  def self.data_changed( top_left, bottom_right, view )
-    invoice_from_project( top_left, view ) if ( top_left == bottom_right )
-  end
-  
-  def self.invoice_from_project( current_index, view )
-    # auto-complete invoice number field from project
-    current_field = current_index.attribute
-    if current_field == :project && current_index.entity.project != nil
-      # most recent entry, ordered in reverse
-      invoice = current_index.entity.project.latest_invoice
-      
-      unless invoice.nil?
-        # make a reference to the invoice
-        current_index.entity.invoice = invoice
-        
-        # update view from top_left to bottom_right
-        model = current_index.model
-        changed_index = model.create_index( current_index.row, view.builder.index( :invoice ) )
-        view.dataChanged( changed_index, changed_index )
-        
-        # move edit cursor to start time field
-        view.override_next_index( model.create_index( current_index.row, view.builder.index( :start ) ) )
-      end
-    end
-  end
-end
-
-class Project < Clevic::Record
-  has_many :entries
-
-  def self.build_table_model( model_builder )
-    model_builder.instance_exec do
-      plain     :project
-      plain     :description
-      distinct  :client
-      plain     :rate
-      plain     :active
-      
-      records   :order => 'project'
-    end
-  end
-  
-  # Return the latest invoice for this project
-  # Not part of the UI.
-  def latest_invoice
-    Invoice.find(
-      :first,
-      :conditions => ["client = ? and status = 'not sent'", self.client],
-      :order => 'invoice_number desc'
-    )
-  end
-
-end
-
-class Activity < Clevic::Record
-  has_many :entries
-
-  # define how fields are displayed
-  def self.build_table_model( model_builder )
-    model_builder.instance_exec do
-      plain :activity
-      plain :active
-      
-      records :order => 'activity'
-    end
-  end
-end
-
-class Invoice < Clevic::Record
-  has_many :entries
-
-  # define how fields are displayed
-  def self.build_table_model( model_builder )
-    model_builder.instance_exec do
-      plain :date
-      distinct :client
-      plain :invoice_number
-      restricted :status, :set => ['not sent', 'sent', 'paid', 'debt', 'writeoff', 'internal']
-      restricted :billing, :set => %w{Hours Quote Internal}
-      plain :quote_date
-      plain :quote_amount
-      plain :description
-      
-      records :order => 'invoice_number'
-    end
-  end
-end

data/models/values_models.rb

@@ -8,25 +8,24 @@ Clevic::DbOptions.connect( $options ) do
 end
 
 # This is a read-only view, which is currently not implemented
-class Value < Clevic::Record
+class Value < ActiveRecord::Base
   set_table_name 'values'
   #~ has_many :debits, :class_name => 'Entry', :foreign_key => 'debit_id'
   #~ has_many :credits, :class_name => 'Entry', :foreign_key => 'credit_id'
   
-  def self.build_table_model( model_builder )
-    model_builder.instance_exec do
-      read_only!
-      plain       :date
-      plain       :description
-      plain       :debit
-      plain       :credit
-      plain       :pre_vat_amount
-      plain       :cheque_number
-      plain       :vat, :label => 'VAT'
-      plain       :financial_year
-      plain       :month
-      
-      records :order => 'date'
-    end
+  include Clevic::Record
+  define_ui do
+    read_only!
+    plain       :date
+    plain       :description
+    plain       :debit
+    plain       :credit
+    plain       :pre_vat_amount
+    plain       :cheque_number
+    plain       :vat, :label => 'VAT'
+    plain       :financial_year
+    plain       :month
+    
+    records :order => 'date'
   end
 end

data/test/test_cache_table.rb

@@ -0,0 +1,138 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class PopulateCachePassengers < ActiveRecord::Migration
+  def self.up
+    Passenger.create :name => 'John Anderson', :flight => Flight.find_by_number('EK211'), :row => 36, :seat => 'A', :nationality => 'UAE'
+    Passenger.create :name => 'Genie', :flight => Flight.find_by_number('CA001'), :row => 1, :seat => 'A', :nationality => 'Canada'
+    Passenger.create :name => 'Aladdin', :flight => Flight.find_by_number('CA001'), :row => 2, :seat => 'A', :nationality => 'Canada'
+  end
+  
+  def self.down
+    Passenger.delete :all
+  end
+end
+
+# need to set up a test DB, and test data for this
+class TestCacheTable < Test::Unit::TestCase
+  def self.startup
+    PopulateCachePassengers.up
+  end
+  
+  def self.shutdown
+    PopulateCachePassengers.down
+  end
+  
+  
+  def setup
+    @cache_table = CacheTable.new( Passenger )
+  end
+  
+  def teardown
+  end
+  
+  def test_passenger_count
+    assert_equal 3, Passenger.count
+  end
+  
+  should "have a sql_count equal to number of records" do
+    assert_equal Passenger.count, @cache_table.sql_count
+  end
+  
+  should "have a size equal to number of records" do
+    assert_equal Passenger.count, @cache_table.size
+  end
+  
+  def test_cache_loading
+    # test not yet cached
+    (0...Passenger.count).each do |i|
+      assert @cache_table.cached_at?(i) == false, "record #{i} should not be cached yet"
+    end
+    
+    # test cache retrieval
+    (0...Passenger.count).each do |i|
+      assert @cache_table[i] == Passenger.find( :first, :offset => i ), "#{i}th cached record is not #{i}th db record"
+    end
+  end
+  
+  def test_preload_limit_1
+    @cache_table.preload_limit 1 do
+      assert !@cache_table[0].nil?, 'First object should not be nil'
+      (1...Passenger.count).each do |i|
+        assert !@cache_table.cached_at?(i), "#{i}th object should be nil"
+      end
+    end
+  end
+
+  # make sure preloads are done
+  def test_preload_limit_default
+    (0...Passenger.count).each do |i|
+      assert !@cache_table.cached_at?(i), "record #{i} should not be cached yet"
+    end
+    @cache_table[0]
+    (0...Passenger.count).each do |i|
+      assert @cache_table.cached_at?(i), "#{i}th object should not be nil"
+    end
+  end
+  
+  should 'have id as a default order attribute' do
+    oa = OrderAttribute.new( Passenger, 'id' )
+    assert_equal oa, @cache_table.order_attributes[0]
+  end
+  
+  def test_parse_order_attributes
+    order_string = 'name desc, passengers.nationality asc, row'
+    ct = CacheTable.new Passenger, :order => order_string
+    assert_equal OrderAttribute.new( Passenger, 'name desc' ), ct.order_attributes[0]
+    assert_equal OrderAttribute.new( Passenger, 'nationality' ), ct.order_attributes[1]
+    assert_equal OrderAttribute.new( Passenger, 'row asc' ), ct.order_attributes[2]
+  end
+  
+  should 'not have new record on empty' do
+    # without auto_new
+    (0...Passenger.count).each do |i|
+      @cache_table.delete_at 0
+      @cache_table.delete_at 0
+      @cache_table.delete_at 0
+    end
+    assert_equal 0, @cache_table.size
+  end
+  
+  should 'have new record on empty' do
+    #with auto_new
+    @cache_table = @cache_table.renew( :auto_new => true )
+    assert !@cache_table.options.has_key?( :auto_new ), "CacheTable should not have :auto_new in options"
+    (0...Passenger.count).each do |i|
+      @cache_table.delete_at 0
+      @cache_table.delete_at 0
+      @cache_table.delete_at 0
+    end
+    
+    assert_equal 1, @cache_table.size
+  end
+  
+  should 'return nil for a nil parameter' do
+    assert_nil @cache_table.index_for_entity( nil )
+  end
+    
+  should 'return nil for an empty set' do
+    cache_table = @cache_table.renew( :conditions => "nationality = 'nothing'" )
+    assert_nil cache_table.index_for_entity( Passenger.find( :first ) )
+  end
+  
+  def test_index_for_entity
+    # test in ascending order
+    first_passenger = Passenger.find :first
+    index = @cache_table.index_for_entity( first_passenger )
+    assert_equal 0, index, 'first passenger should have an index of 0'
+    
+    # test in descending order
+    @cache_table = @cache_table.renew( :order => 'id desc' )
+    last_passenger = Passenger.find :first, :order => 'id desc'
+    assert_equal 0, @cache_table.index_for_entity( last_passenger ), "last passenger in reverse order should have an index of 0"
+    
+    # test with two order fields
+    @cache_table = @cache_table.renew( :order => 'nationality, row' )
+    passenger = Passenger.find :first, :order => 'nationality, row'
+    assert_equal 0, @cache_table.index_for_entity( passenger ), "passenger in (nationality, row) order should have an index of 0"
+  end
+end