clevic 0.12.0 → 0.13.0.b1

data/lib/clevic/action_builder.rb

@@ -0,0 +1,168 @@
+module Clevic
+
+=begin rdoc
+This module is included in a class to make the construction of
+collections of actions more rubyish. It must have
+ - an add_action method 
+ - separator, which returns something which is_a? Separator
+ - create_action( &block ), which creates an Action object
+ - action_method_or_block( action, options, &block ) which handles events
+  
+Menus are generally made up of a collection of actions.
+
+Once included, it's intended to be called as follows:
+  def some_setup_method_or_other
+    build_actions do
+      list :edit do
+        #~ new_action :action_cut, 'Cu&t', :shortcut => Qt::KeySequence::Cut
+        action :action_copy, '&Copy', :shortcut => Qt::KeySequence::Copy, :method => :copy_current_selection
+        action :action_paste, '&Paste', :shortcut => Qt::KeySequence::Paste, :method => :paste
+        separator
+        action :action_ditto, '&Ditto', :shortcut => 'Ctrl+\'', :method => :ditto, :tool_tip => 'Copy same field from previous record'
+        action :action_ditto_right, 'Ditto R&ight', :shortcut => 'Ctrl+]', :method => :ditto_right, :tool_tip => 'Copy field one to right from previous record'
+        action :action_ditto_left, '&Ditto L&eft', :shortcut => 'Ctrl+[', :method => :ditto_left, :tool_tip => 'Copy field one to left from previous record'
+        action :action_insert_date, 'Insert Date', :shortcut => 'Ctrl+;', :method => :insert_current_date
+        action :action_open_editor, '&Open Editor', :shortcut => 'F4', :method => :open_editor
+        separator
+        action :action_row, 'New Ro&w', :shortcut => 'Ctrl+N', :method => :row
+        action :action_refresh, '&Refresh', :shortcut => 'Ctrl+R', :method => :refresh
+        action :action_delete_rows, 'Delete Rows', :shortcut => 'Ctrl+Delete', :method => :delete_rows
+        
+        if $options[:debug]
+          action :action_dump, 'D&ump', :shortcut => 'Ctrl+Shift+D' do
+            puts model.collection[current_index.row].inspect
+          end
+        end
+      end
+      
+      separator
+    end
+  end
+Or you can pass a parameter to the block if you need access to surrounding variables:
+  build_actions do |ab|
+    ab.list :edit do
+      #~ new_action :action_cut, 'Cu&t', :shortcut => Qt::KeySequence::Cut
+      ab.action :action_copy, '&Copy', :shortcut => Qt::KeySequence::Copy, :method => :copy_current_selection
+    end
+  end
+If the including class defines a method called action_triggered( &block ),
+it can be used to wrap the code triggered by actions. That way, the
+including class
+can catch exceptions and things like that.
+  def action_triggered( &block )
+    catch :something_happened do
+      yield
+    end
+  end
+If this method is not defined, it will be created in the including class as an empty wrapper.
+=end
+module ActionBuilder
+  # raise a RuntimeError if the including class/module does not define add_action
+  def self.included( including_module )
+    shortlist = including_module.instance_methods.grep /action/i
+    # add_action is actually an method_missing lookup for addAction, so
+    # search for both.
+    unless shortlist.any? {|x| %w{add_action addAction}.include?( x )}
+      raise NotImplementedError, "#{including_module.class.name} must have an add_action method"
+    end
+  end
+  
+  # Outer block for the build process.
+  def build_actions( &block )
+    raise 'a block must be present' if block.nil?
+    if block.arity == -1
+      instance_eval &block
+    else
+      yield self
+    end
+  end
+  
+  def group_names
+    @group_names ||= []
+  end
+  
+  # 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.
+  def list( group_name, &block )
+    @group_name = group_name
+    group_names << group_name
+    unless respond_to?( "#{group_name.to_s}_actions" )
+      self.class.send( :define_method, "#{group_name.to_s}_actions" ) do
+        eval "@#{group_name.to_s}_actions"
+      end
+    end
+    self.collect_actions = []
+    
+    yield( self )
+    # copy actions to the right instance variable
+    eval "@#{group_name.to_s}_actions = collect_actions"
+    
+    # reset these, just for cleanliness
+    @group_name = nil
+    self.collect_actions = []
+  end
+  
+  # Create a new Action and
+  # 1. pass it to add_action
+  # 1. add it to the collect_actions collection.
+  # The block takes predence over options[:method], which is a method
+  # on self to be called.
+  # Option keys can be any method in Action, ie :tool_tip, :shortcut, :status_tip etc.
+  # A value for :shortcut is automatically passed to create_key_sequence
+  def action( name_or_action, text = nil, options = {}, &block )
+    if name_or_action.is_a? Action
+      add_action( name_or_action )
+    else
+      name = name_or_action
+      if options.has_key?( :method ) && !block.nil?
+        raise "you can't specify both :method and a block"
+      end
+      
+      create_action do |action|
+        action.name = name.to_s
+        action.text = text
+        options.each do |k,v|
+          next if k == :method
+          if k == :shortcut
+            action.shortcut = v
+          else
+            action.send( "#{k.to_s}=", v )
+          end
+        end
+        
+        # add action
+        add_action action
+        
+        # add actions for list. Yes, it's a side-effect.
+        # TODO is there a better way to do this?
+        collect_actions << action
+        
+        action_method_or_block( action, options, &block )
+      end
+    end
+  end
+
+protected
+
+  # the set of actions created so far in a particular list.
+  def collect_actions
+    @collect_actions ||= []
+  end
+  
+  def collect_actions=( arr )
+    @collect_actions = arr
+  end
+  
+  # If parent doesn't define this, add it so that 
+  # our action_method_or_block will work.
+  unless instance_methods.include?( :action_triggered )
+    def action_triggered( &someblock )
+      yield
+    end
+  end
+  
+end
+
+end # Clevic

data/lib/clevic/ar_methods.rb

@@ -0,0 +1,120 @@
+require 'active_support'
+require 'active_support/core_ext/array/extract_options.rb'
+
+module Sequel
+  module Plugins
+    module ArMethods
+      # plugin :ar_methods calls this.
+      # model is the model class. The rest is whatever options are
+      # in the plugin call, possibility for
+      #  plugin :ar_methods :override_sequel => true
+      def self.configure(model, options = {})
+        model.instance_eval do
+          # store model-related stuff here
+        end
+      end
+      
+      module ClassMethods
+        # 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)
+        end
+        
+        def find_ar( *args )
+          # copied from ActiveRecord::Base.find
+          options = args.extract_options!
+          #~ validate_find_options(options)
+          #~ set_readonly_option!(options)
+          
+          case args.first
+            when :first
+              translate(options).first
+              
+            when :last
+              translate(options).last
+              
+            when :all
+              translate(options).all
+              
+            else
+              if args.size == 1
+                translate(options).filter( :id.qualify( table_name ) => args.first ).first
+              else
+                translate(options).filter( :id.qualify( table_name ) => args ).all
+              end
+          end
+        end
+        
+        def count_ar( *args )
+          options = args.extract_options!
+          attribute = args.first
+          
+          dataset = translate( options )
+          
+          unless attribute.nil?
+            dataset = dataset.select( attribute )
+          end
+          dataset.count
+        end
+        
+      end
+      
+      module InstanceMethods
+      end
+    end
+  end
+end

data/lib/clevic/attribute_list.rb

@@ -0,0 +1,56 @@
+module Clevic
+  class AttributeList
+    def initialize( entity_class, attribute, attribute_value, find_options )
+      @entity_class = entity_class
+      @attribute, @attribute_value, @find_options = attribute, attribute_value, find_options
+    end
+    attr_reader :entity_class, :attribute, :attribute_value, :find_options
+    
+    # because Sequel::Dataset won't .filter with {}
+    def conditions( dataset )
+      # make sure the current attribute value is included if there's a filter
+      rv = 
+      if find_options.has_key?( :conditions )
+        find_options[:conditions].lit | { attribute => attribute_value }
+      end
+      
+      # filter if necessary
+      unless rv.nil?
+        dataset.filter( rv ) 
+      else
+        dataset
+      end
+    end
+    
+    # sorts by attribute
+    def dataset_by_description
+      # must have attribute equality test first, otherwise if find_options
+      # doesn't have :conditions, then we end up with ( nil | { attribute => attribute_value } )
+      # which confuses Sequel
+      ds = entity_class.naked \
+        .order( attribute ) \
+        .select( attribute ) \
+        .distinct
+      conditions( ds )
+    end
+      
+    # sorts by first letter then most frequent, instead of pure alphabetical
+    def dataset_by_frequency
+      ds = entity_class.naked \
+        .select( attribute, :count.sql_function( attribute ) ) \
+        .group( attribute ) \
+        .order( :substr.sql_function( attribute,1,1 ), :count.sql_function( attribute ).desc )
+      conditions( ds )
+    end
+    
+    # by_frequency is the default
+    def dataset( by_description, by_frequency )
+      case
+        when by_description
+          dataset_by_description
+        else
+          dataset_by_frequency
+      end
+    end
+  end
+end

data/lib/clevic/cache_table.rb

@@ -1,16 +1,7 @@
-require 'rubygems'
-require 'active_record'
 require 'clevic/table_searcher.rb'
 require 'clevic/order_attribute.rb'
 require 'bsearch'
 
-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.
 
@@ -26,18 +17,20 @@ 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
 =end
 class CacheTable < Array
   # the number of records loaded in one call to the db
   attr_accessor :preload_count
-  attr_reader :options, :entity_class
+  attr_reader :find_options, :entity_class
   
   def initialize( entity_class, find_options = {} )
     @preload_count = 20
     # must be before sanitise_options
     @entity_class = entity_class
     # must be before anything that uses options
-    @options = find_options.clone
+    @find_options = (find_options || {}).clone
     sanitise_options!
     
     # size the array and fill it with nils. They'll be filled
@@ -49,21 +42,21 @@ class CacheTable < Array
   # The count of the records according to the db, which may be different to
   # the records in the cache
   def sql_count
-    entity_class.count( options.reject{|k,v| k == :order} )
+    entity_class.adaptor.count( find_options.reject{|k,v| k == :order} )
   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 compund primary keys?
+  # TODO what about compound 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)}
+      @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
-      if !@order_attributes.any? {|x| x.attribute == entity_class.primary_key }
+      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
@@ -71,14 +64,28 @@ class CacheTable < Array
   end
   
   # add an id to options[:order] if it's not in there
-  # also create @order_attributes
+  # 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
-    options[:order] ||= ''
+    # value would be a ,-separated list of order by fields (expressions?)
+    find_options[:order] ||= ''
     
     # recreate the options[:order] entry to include default
-    # TODO why though? Can't remember
-    options[:order] = order_attributes.map{|x| x.to_sql}.join(',')
+    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,
@@ -100,7 +107,7 @@ class CacheTable < Array
     offset = index < 0 ? index + @row_count : index
     
     # fetch self.preload_count records
-    records = entity_class.find( :all, options.merge( :offset => offset, :limit => preload_count ) )
+    records = entity_class.adaptor.find( :all, find_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
@@ -115,15 +122,38 @@ class CacheTable < Array
   
   # make a new instance that has the attributes of this one, but an empty
   # data set. pass in ActiveRecord options to filter.
-  # TODO using named scopes might make filtering easier.
   def renew( args = nil )
     clear
-    self.class.new( entity_class, args || options )
+    self.class.new( entity_class, args || find_options )
+  end
+  
+  # key is what we're searching for. candidate
+  # is what the current candidate is. direction is 1
+  # for sorted ascending, and -1 for sorted descending
+  # TODO retrieve nulls first/last from dataset. In sequel (>3.13.0)
+  # this is related to entity_class.filter( :release_date.desc(:nulls=>:first), :name.asc(:nulls=>:last) )
+  def compare( key, candidate, direction )
+    if ( key_nil = key.nil? ) || candidate.nil?
+      if key == candidate
+        # both nil, ie equal
+        0
+      else
+        # assume nil is sorted greater
+        # TODO this should be retrieved from the db
+        # ie candidate(nil) <=> key is 1
+        # and key <=> candidate(nil) is -1
+        key_nil ? -1 : 1
+      end
+    else
+      candidate <=> key
+    end * direction
+    # reverse the result if we're searching a desc attribute,
+    # where direction will be -1
   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 entity is nil
   # nil is returned if the array is empty
   def index_for_entity( entity )
     return nil if size == 0 || entity.nil?
@@ -135,35 +165,28 @@ 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],
+          # similar to candidate <=> entity
           if result == 0
+            # they're equal, so compare attribute values
             method = attribute.attribute.to_sym
+            
             # 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
-              #~ entity.send( method ) <=> candidate.send( method )
-              entity[method] <=> candidate[method]
-            end
+            retval = compare( entity.send( method ), candidate.send( method ), attribute.to_i )
+            
             # 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
+            # recurse out because we have a difference already
             result
           end
         end
       end
     end
   end
-  
-  def search( field, search_criteria, start_entity )
-    Clevic::TableSearcher.new( entity_class, order_attributes, search_criteria, field ).search( start_entity )
-  end
 end
 
 # This is part of Array in case the programmer wants to use