clevic 0.13.0.b3 → 0.13.0.b5

data/lib/clevic.rb

@@ -6,8 +6,14 @@ module Clevic
   end
 end
 
-require 'clevic/sequel_ar_adapter.rb'
+# TODO should this really be here?
+# There are other inflection gems.
+# JRuby-1.5.2 raises exception if this require has a .rb on the 
+require 'active_support/inflector'
+
+require 'clevic/framework'
 require 'clevic/sequel_length_validation.rb'
 require 'clevic/record.rb'
 require 'clevic/view.rb'
 require 'clevic/sequel_meta.rb'
+require 'clevic/sequel_clevic.rb'

data/lib/clevic/action_builder.rb

@@ -84,7 +84,7 @@ module ActionBuilder
   # Create and return a list of actions. The actions are grouped together,
   # ie live together on the menu with a separator between groups.
   # A method called "#{group_name}_actions" will be added to self, which will return the
-  # set of Qt::Action instances created in the block.
+  # set of framework-specific Action instances created in the block.
   def list( group_name, &block )
     @group_name = group_name
     group_names << group_name
@@ -160,6 +160,9 @@ protected
   unless instance_methods.include?( :action_triggered )
     def action_triggered( &someblock )
       yield
+    rescue
+      puts $!.message
+      puts $!.backtrace
     end
   end
   

data/lib/clevic/ar_methods.rb

@@ -2,6 +2,71 @@ require 'active_support'
 require 'active_support/core_ext/array/extract_options.rb'
 
 module Sequel
+  class Dataset
+    # Basically, we're translating from AR's hash options
+    # to Sequel's method algebra, and returning the resulting
+    # dataset.
+    def translate( options )
+      # recursively send key-value pairs to self
+      # and return the result
+      options.inject( self ) do |dataset, (key, value)|
+        case key
+          when :limit; dataset.limit( value, nil )
+          when :offset
+            # workaround for Sequel's refusal to do offset without limit
+            # not sure we need :all for >= 3.13.0
+            dataset.limit( options[:limit] || :all, value )
+          
+          when :order
+            orders = value.split(/, */ ).map do |x|
+              case x
+              when /^(\w+) +(asc|desc)$/i
+                $1.to_sym.send( $2 )
+                
+              when /^\w+$/i
+                x.to_sym
+              
+              else
+                x.lit
+                
+              end
+            end
+            dataset.order( *orders )
+          
+          when :conditions
+            # this translation is not adequate for all use cases of the AR api
+            # specifically where value contains a SQL expression
+            unless value.nil?
+              possible_literal =
+              if value.is_a?( String )
+                value.lit
+              else
+                value
+              end
+              
+              dataset.filter( possible_literal ) 
+            end
+          
+          when :include
+            # this is the class to join
+            joined_class = eval( model.reflections[value][:class_name] )
+            dataset.join_table(
+              :inner,
+              joined_class,
+              joined_class.primary_key => model.reflections[value][:key]
+            ).select( model.table_name.* )
+            
+          else
+            raise "#{key} not implemented"
+        # make sure at least it's unchanged, in case options is empty
+        end || dataset
+      end
+      
+      rescue Exception => e
+        raise RuntimeError, "#{self} #{options.inspect} #{e.message}", caller(0)
+    end
+  end
+  
   module Plugins
     module ArMethods
       # plugin :ar_methods calls this.
@@ -18,60 +83,10 @@ module Sequel
         # Copy the necessary class instance variables to the subclass.
         def inherited(subclass)
           super
-          #~ store = @cache_store
-          #~ ttl = @cache_ttl
-          #~ cache_ignore_exceptions = @cache_ignore_exceptions
-          #~ subclass.instance_eval do
-            #~ @cache_store = store
-            #~ @cache_ttl = ttl
-            #~ @cache_ignore_exceptions = cache_ignore_exceptions
-          #~ end
         end
         
-        def lit_if_string( arg )
-          if arg.is_a?( String )
-            arg.lit
-          else
-            arg
-          end
-        end
-        
-        # Basically, we're translating from AR's hash options
-        # to Sequel's method algebra, and returning the resulting
-        # dataset.
         def translate( options )
-          options.inject( dataset ) do |dataset, (key, value)|
-            case key
-              when :limit; dataset.limit( value, nil )
-              when :offset
-                # workaround for Sequel's refusal to do offset without limit
-                dataset.limit( options[:limit] || :all, value )
-              
-              when :order
-                dataset.order( lit_if_string( value ) )
-              
-              when :conditions
-                # this is most likely not adequate for all use cases
-                # of the AR api
-                dataset.filter( lit_if_string( value ) ) unless value.nil?
-              
-              when :include
-                # this is the class to joing
-                joined_class = eval( reflections[value][:class_name] )
-                dataset.join_table(
-                  :inner,
-                  joined_class,
-                  joined_class.primary_key => reflections[value][:key]
-                ).select( table_name.* )
-                
-              else
-                raise "#{key} not implemented"
-            # make sure at least it's unchanged
-            end || dataset
-          end
-          
-          rescue Exception => e
-            raise RuntimeError, "#{self.name} #{options.inspect} #{e.message}", caller(0)
+          dataset.translate( options )
         end
         
         def find_ar( *args )
@@ -82,19 +97,19 @@ module Sequel
           
           case args.first
             when :first
-              translate(options).first
+              dataset.translate(options).first
               
             when :last
-              translate(options).last
+              dataset.translate(options).last
               
             when :all
-              translate(options).all
+              dataset.translate(options).all
               
             else
               if args.size == 1
-                translate(options).filter( :id.qualify( table_name ) => args.first ).first
+                dataset.translate(options).filter( :id.qualify( table_name ) => args.first ).first
               else
-                translate(options).filter( :id.qualify( table_name ) => args ).all
+                dataset.translate(options).filter( :id.qualify( table_name ) => args ).all
               end
           end
         end
@@ -103,7 +118,7 @@ module Sequel
           options = args.extract_options!
           attribute = args.first
           
-          dataset = translate( options )
+          dataset = dataset.translate( options )
           
           unless attribute.nil?
             dataset = dataset.select( attribute )

data/lib/clevic/attribute_list.rb

@@ -1,4 +1,8 @@
 module Clevic
+
+  # Provide a list of entries for a distinct field, ordered
+  # by either value order, or frequency order.
+  # TODO move this into the common DistinctDelegate class.
   class AttributeList
     def initialize( entity_class, attribute, attribute_value, find_options )
       @entity_class = entity_class

data/lib/clevic/cache_table.rb

@@ -1,7 +1,9 @@
-require 'clevic/table_searcher.rb'
-require 'clevic/order_attribute.rb'
+require 'clevic/table_searcher'
+require 'clevic/ordered_dataset'
 require 'bsearch'
 
+module Clevic
+
 =begin rdoc
 Fetch rows from the db on demand, rather than all up front.
 
@@ -18,76 +20,34 @@ 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?
 
-TODO use Sequel instead of order_attributes
+TODO figure out how to handle situations where the character set ordering
+in the db and in Ruby are different.
 =end
 class CacheTable < Array
+  
+  include OrderedDataset
+  
   # the number of records loaded in one call to the db
   attr_accessor :preload_count
-  attr_reader :find_options, :entity_class
+  attr_reader :entity_class
   
-  def initialize( entity_class, find_options = {} )
-    @preload_count = 20
-    # must be before sanitise_options
+  def initialize( entity_class, dataset = nil )
+    @preload_count = 30
     @entity_class = entity_class
-    # must be before anything that uses options
-    @find_options = (find_options || {}).clone
-    sanitise_options!
+    # defined in OrderAttributes
+    self.dataset = dataset || entity_class.dataset
     
     # size the array and fill it with nils. They'll be filled
     # in by the [] operator
-    @row_count = sql_count
-    super( @row_count )
+    super( sql_count )
   end
   
   # The count of the records according to the db, which may be different to
   # the records in the cache
   def sql_count
-    entity_class.adaptor.count( find_options.reject{|k,v| k == :order} )
+    dataset.count
   end
   
-  # Return the set of OrderAttribute objects for this collection.
-  # If no order attributes are specified, the primary key will be used.
-  # TODO what about compound primary keys?
-  def order_attributes
-    # This is sorted in @find_options[:order], so use that for the search
-    if @order_attributes.nil?
-      @order_attributes = find_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
-      unless @order_attributes.any? {|x| x.attribute.to_s == entity_class.primary_key.to_s }
-        @order_attributes << OrderAttribute.new( entity_class, entity_class.primary_key )
-      end
-    end
-    @order_attributes
-  end
-  
-  # add an id to options[:order] if it's not in there
-  # make sure options[:conditions] uses db values rather than objects
-  # ie convert { :debit => DebitObject<...> } to { :debit_id => 5 }
-  def sanitise_options!
-    # make sure we have a string here, even if it's blank
-    # value would be a ,-separated list of order by fields (expressions?)
-    find_options[:order] ||= ''
-    
-    # recreate the options[:order] entry to include default
-    find_options[:order] = order_attributes.map{|x| x.to_sql}.join(',')
-    
-    # make sure objects are converted to ids
-    if find_options.has_key?( :conditions ) && find_options[:conditions].is_a?( Hash )
-      conditions = find_options[:conditions].map do |key,value|
-        metadata = entity_class.meta[key]
-        if metadata.association?
-          [metadata.key, value.send( value.primary_key )]
-        else
-          [key,value]
-        end
-      end
-      find_options[:conditions] = Hash[ *conditions.flatten ]
-    end
-  end
-
   # Execute the block with the specified preload_count,
   # and restore the existing one when done.
   # Return the value of the block
@@ -104,14 +64,14 @@ class CacheTable < Array
   # hits on the db
   def fetch_entity( index )
     # calculate negative indices for the SQL offset
-    offset = index < 0 ? index + @row_count : index
+    offset = index < 0 ? index + sql_count : index
     
     # fetch self.preload_count records
-    records = entity_class.adaptor.find( :all, find_options.merge( :offset => offset, :limit => preload_count ) )
+    records = dataset.limit( preload_count, offset )
     records.each_with_index {|x,i| self[i+index] = x if !cached_at?( i+index )}
     
     # return the first one
-    records[0]
+    records.first
   end
   
   # return the entity at the given index. Fetch it from the
@@ -120,11 +80,25 @@ class CacheTable < Array
     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( args = nil )
-    clear
-    self.class.new( entity_class, args || find_options )
+  # Make a new instance based on the current dataset.
+  # Unless new_dataset is specified, pass the dataset
+  # to the block, and use the return
+  # value from the block as the new dataset.
+  #
+  # This is so that filter of datasets can be based on the
+  # existing one, but it's easy to go back to previous data
+  # sets if necessary.
+  # TODO write tests for both cases.
+  def renew( new_dataset = nil, &block )
+    if new_dataset && block_given?
+      raise "Passing a new dataset and a modification block doesn't make sense."
+    end
+    
+    if block_given?
+      self.class.new( entity_class, block.call( dataset ) )
+    else
+      self.class.new( entity_class, new_dataset || dataset )
+    end
   end
   
   # key is what we're searching for. candidate
@@ -165,14 +139,12 @@ class CacheTable < Array
       bsearch do |candidate|
         # find using all sort attributes
         order_attributes.inject(0) do |result,attribute|
-          # value from the block should be in [-1,0,1],
+          # result from the block should be in [-1,0,1],
           # similar to candidate <=> entity
+          key, direction = attribute
           if result == 0
-            # they're equal, so compare attribute values
-            method = attribute.attribute.to_sym
-            
             # compare taking ordering direction into account
-            retval = compare( entity.send( method ), candidate.send( method ), attribute.to_i )
+            retval = compare( entity.send( key ), candidate.send( key ), direction )
             
             # exit now because we have a difference
             next( retval ) if retval != 0
@@ -189,6 +161,8 @@ class CacheTable < Array
   end
 end
 
+end
+
 # This is part of Array in case the programmer wants to use
 # a simple array instead of a CacheTable.
 class Array

data/lib/clevic/dataset_roller.rb

@@ -0,0 +1,22 @@
+module Clevic
+
+  # Tricky, this. Keeps passing on the dataset and
+  # lets it build up, but keeps the result.
+  # Used in the UI block to make a nice syntax for specifying the dataset.
+  class DatasetRoller
+    def initialize( original_dataset )
+      @rolling_dataset = original_dataset
+    end
+    
+    def dataset
+      @rolling_dataset
+    end
+    
+    def method_missing(meth, *args, &block)
+      @rolling_dataset = @rolling_dataset.send( meth, *args, &block )
+      self
+    end
+  end
+  
+
+end

data/lib/clevic/delegate.rb

@@ -8,12 +8,21 @@ class Delegate
   include FieldValuer
 
   def initialize( field )
+    super()
     @field = field
   end
   
-  attr_accessor :entity, :parent
+  # This is the ORM entity instance for which this delegate
+  # is editing a single field. It needs to be the entire entity
+  # so we can set the edited field value on it.
+  attr_accessor :entity
   
+  # The parent widget of this delegate / this delegate's widget
+  attr_accessor :parent
+  
+  # the Clevic::Field instance which this delegate edits.
   attr_reader :field
+  
   def attribute
     field.attribute
   end
@@ -22,10 +31,7 @@ class Delegate
     field.entity_class
   end
   
-  def find_options
-    field.find_options
-  end
-  
+  # assume this is not a combo delegate. That will come later.
   def is_combo?
     false
   end

data/lib/clevic/delegates/combo_delegate.rb

@@ -0,0 +1,156 @@
+require 'andand'
+
+module Clevic
+
+=begin rdoc
+Base class for other delegates using Combo boxes.
+=end
+# TODO this should be a module
+class ComboDelegate
+  # Return the GUI component / widget that is displayed when editing.
+  # Usually this will be a combo box widget, but it can be a text editor
+  # in some cases.
+  # if editor is a combo it must support no_insert=( bool )
+  attr_reader :editor
+  
+  # Return a string to be shown to the user.
+  # model_value is an item stored in the combo box model.
+  def display_for( model_value )
+    field.transform_attribute( model_value )
+  end
+  
+  # Some GUIs (Qt) can just set this. Swing can't.
+  def configure_prefix
+  end
+  
+  # TODO kinda redundant because all combos must be editable
+  # to support prefix matching
+  def configure_editable
+    editor.editable = true
+  end
+  
+  # this will create the actual combo box widget
+  framework_responsibility :create_combo_box
+
+  # framework-specific code goes in here
+  # it's called right at the end of init_component, once all the other setup
+  # is done. Mainly it's so that event handlers can be attached
+  # to the combo box without having to deal with events triggered
+  # by setup code.
+  framework_responsibility :framework_setup
+  
+  # This is called by the combo box to convert an item
+  # to something that the combo can insert into
+  # itself. Usually this will be a display value
+  # and a storage value.
+  framework_responsibility :item_to_editor
+  
+  # This is called by the combo box when it needs to convert a
+  # storage value to an item, which is something that the delegate
+  # will understand.
+  framework_responsibility :editor_to_item
+
+  # Create a GUI widget and fill it with the possible values.
+  # *args will be passed as-is to framework_setup
+  # NOTE RIght now it's the framework's responsibility to call
+  #  self.entity = some_entity
+  # There must be a good way to check that though.
+  def init_component( *args )
+    if needs_combo?
+      @editor = create_combo_box( *args )
+      @editor.delegate = self
+ 
+      # add all entries from population
+      population.each do |item|
+        editor << item
+      end
+      
+      # create a nil entry if necessary
+      if allow_null? && !editor.include?( nil )
+        editor << nil
+      end
+      
+      # don't allow inserts if the delegate is restricted
+      editor.no_insert = restricted?
+      
+      # set the correct value in the list
+      editor.selected_item = entity.nil? ? nil : attribute_value      
+      
+      # set up prefix matching when typing in the editor
+      configure_prefix
+      
+      framework_setup( *args )
+    else
+      @editor =
+      if restricted?
+        show_message( empty_set_message )
+        nil
+      else
+        # there is no data yet for the combo, and it's
+        # not restricted, so just edit with a simple text field.
+        line_editor( edit_value )
+      end
+    end
+    editor
+  end
+  
+  # open the combo box, just like if F4 was pressed
+  framework_responsibility :full_edit
+  
+  # show only the text editor part, not the drop-down
+  def minimal_edit
+    editor.hide_popup if is_combo?
+  end
+  
+  # returns true if the editor allows values outside of a predefined
+  # range, false otherwise.
+  def restricted?
+    false
+  end
+  
+  # TODO fetch this from the model definition
+  def allow_null?
+    true
+  end
+  
+  # Subclasses should override this to prove a list of
+  # values to be used by the combo box. Values could
+  # be pretty much anything, depending on the delegate.
+  # For example, a RelationalDelegate will have a collection
+  # of entity objects, most other delegates will have collections
+  # of strings.
+  subclass_responsibility :population
+  
+  # Return true if this delegate needs a combo, false otherwise
+  # ie if there are no values yet and it's not restricted, then a
+  # full combo doesn't make sense
+  subclass_responsibility :needs_combo?
+
+  # return true if this delegate has/needs a combo widget
+  # or false if it's a plain text field.
+  framework_responsibility :is_combo?
+  
+  # return true if this field has no data (needs_combo? is false)
+  # and is at the same time restricted (ie needs data from somewhere else)
+  def empty_set?
+    !needs_combo? && restricted?
+  end
+  
+  # the message to display if the set is empty, and
+  # the delegate is restricted to a predefined set.
+  subclass_responsibility :empty_set_message
+  
+  # if this delegate has an empty set, return the message, otherwise
+  # return nil.
+  def if_empty_message
+    empty_set_message if empty_set?
+  end
+  
+  # the value represented by the combo, ie either
+  # the current attribute_value of the field
+  # this combo is editing, or an object that could
+  # be a new attribute_value
+  framework_responsibility :value
+end
+
+end