clevic 0.8.0 → 0.11.1

data/lib/clevic/db_options.rb

@@ -19,11 +19,14 @@ Method calls are translated to insertions into a hash with the same
 key as the method being called. The hash is initialised
 with the options value passed in (in this case $options).
 Values have to_s called on them so they can be symbols or strings.
+
+#--
+TODO inherit from HashCollector
 =end
 class DbOptions
   attr_reader :options
   
-  def initialize( options = nil )
+  def initialize( options = nil, &block )
     @options = options || {}
     
     # make sure the relevant entries exist, so method_missing works
@@ -32,42 +35,46 @@ class DbOptions
     @options[:username] ||= ''
     @options[:password] ||= ''
     @options[:database] ||= ''
+    
+    unless block.nil?
+      if block.arity == -1
+        instance_eval &block
+      else
+        yield self
+      end
+    end
   end
   
-  def connect( *args, &block )
-    # using the Rails implementation, included in Qt
-    block.bind( self )[*args]
-    do_connection
-  end
-  
-  # do error checking and make the ActiveRecord connection calls.
-  def do_connection
-    unless @options[:database]
-      raise "Please define database using DbOptions"
+  def connect
+    if @options[:database].nil? || @options[:database].empty?
+      raise "Please define database using DbOptions. Current value is #{@options[:database].inspect}."
     end
     
     # connect to db
     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]
     self
   end
   
   # convenience method so we can do things like
-  #   Clevic::DbOptions.connect( $options ) do
+  #   Clevic::DbOptions.connect do
   #     database :accounts
   #     adapter :postgresql
   #     username 'accounts_user'
   #   end
   # the block is evaluated in the context of the a new DbOptions
-  # object.
-  # TODO use instance_eval
-  def self.connect( args = nil, &block )
-    inst = self.new( args )
-    # using the Rails implementation, included in Qt
-    block.bind( inst )[*args]
-    inst.do_connection
+  # object. You can also pass a block parameter and it will receive
+  # the DbOptions instance, like this:
+  #   Clevic::DbOptions.connect do |dbo|
+  #     dbo.database :accounts
+  #     dbo.adapter :postgresql
+  #     dbo.username 'accounts_user'
+  #   end
+  def self.connect( args = {}, &block )
+    inst = self.new( args, &block )
+    inst.connect
+    inst
   end
   
   # translate method calls in the context of an instance
@@ -75,7 +82,11 @@ class DbOptions
   # variable
   def method_missing(meth, *args, &block)
     if @options.has_key? meth.to_sym
-      @options[meth.to_sym] = args[0].to_s if @options[meth.to_sym].empty?
+      if args.size == 0
+        @options[meth.to_sym]
+      else
+        @options[meth.to_sym] = args[0].to_s
+      end
     else
       super
     end

data/lib/clevic/default_view.rb

@@ -0,0 +1,66 @@
+module Clevic
+
+  # A subclass of Clevic::DefaultView is created by Clevic::Record
+  # when the latter is included in an ActiveRecord::Base subclass.
+  # 
+  # The Clevic::DefaultView subclass knows how to:
+  # - build a fairly sensible UI from the the ActiveRecord::Base metadata.
+  # - create a UI definition using a class method called define_ui.
+  #
+  # See Clevic::ModelBuilder for an example.
+  class DefaultView < View
+    def method_missing( meth, *args, &block )
+      if entity_class.respond_to?( meth )
+        entity_class.send( meth, *args, &block )
+      else
+        super
+      end
+    end
+    
+    def self.define_ui_block( &block )
+      @define_ui_block ||= block
+    end
+    
+    def define_ui
+      if self.class.define_ui_block.nil?
+        # use the define_ui from Clevic::View to build a default UI
+        super
+      else
+        # use the provided block
+        model_builder( &self.class.define_ui_block )
+      end
+    end
+    
+    def title
+      @title ||= entity_class.name.demodulize.tableize.humanize
+    end
+
+    def define_actions( table_view, action_builder )
+      if entity_class.respond_to?( :actions )
+        puts "Deprecated: #{entity_class.name}.actions( table_view, action_builder ). Use define_actions( table_view, action_builder ) instead."
+        entity_class.actions( table_view, action_builder )
+      elsif entity_class.respond_to?( :define_actions )
+        entity_class.define_actions( table_view, action_builder )
+      end
+    end
+    
+    def notify_data_changed( table_view, top_left_model_index, bottom_right_model_index )
+      if entity_class.respond_to?( :data_changed )
+        puts "Deprecated: #{entity_class.name}.data_changed( top_left, bottom_right, table_view ). Use notify_data_changed( table_view, top_left_model_index, bottom_right_model_index ) instead."
+        entity_class.data_changed( top_left_model_index, bottom_right_model_index, table_view )
+      elsif entity_class.respond_to?( :notify_data_changed )
+        entity_class.notify_data_changed( table_view, top_left_model_index, bottom_right_model_index )
+      end
+    end
+    
+    def notify_key_press( table_view, key_press_event, current_model_index )
+      if entity_class.respond_to?( :key_press_event )
+        puts "Deprecated: #{entity_class.name}.key_press_event( key_press_event, current_model_index, table_view ). Use notify_key_press( table_view, key_press_event, current_model_index ) instead."
+        entity_class.key_press_event( key_press_event, current_model_index, table_view )
+      elsif entity_class.respond_to?( :notify_key_press )
+        entity_class.notify_key_press( table_view, key_press_event, current_model_index )
+      end
+    end
+  end
+  
+end

data/lib/clevic/delegates.rb

@@ -6,12 +6,11 @@ module Clevic
 Base class for other delegates using Combo boxes. Emit focus out signals,
 because ComboBox stupidly doesn't.
 
-Generally these will be created using a ModelBuilder.
+Generally these will be created using a Clevic::ModelBuilder.
 =end
 class ComboDelegate < Clevic::ItemDelegate
-  def initialize( parent )
+  def initialize( parent, field )
     super
-    @@active_record_options ||= [ :conditions, :class_name, :order ]
   end
   
   # Convert Qt:: constants from the integer value to a string value.
@@ -186,26 +185,11 @@ class ComboDelegate < Clevic::ItemDelegate
       end
       
     else
-      model_index.gui_value = editor.text
+      model_index.attribute_value = editor.text
     end
     emit abstract_item_model.dataChanged( model_index, model_index )
   end
 
-protected
-
-  # given a hash of options, return only those
-  # which are applicable to a ActiveRecord::Base.find
-  # method call
-  def collect_finder_options( options )
-    new_options = {}
-    options.each do |key,value|
-      if @@active_record_options.include?( key )
-        new_options[key] = value
-      end
-    end
-    new_options
-  end
-
 end
 
 # Provide a list of all values in this field,
@@ -214,18 +198,9 @@ end
 # the options are sorted in order of most frequently used first.
 class DistinctDelegate < ComboDelegate
   
-  def initialize( parent, attribute, model_class, options )
-    @ar_model = model_class
-    @attribute = attribute
-    @options = options
-    # hackery for amateur query building in populate
-    @options[:conditions] ||= '1=1'
-    super( parent )
-  end
-  
   def needs_combo?
     # works except when there is a '' in the column
-    @ar_model.count( @attribute, collect_finder_options( @options ) ) > 0
+    entity_class.count( attribute.to_s, find_options ) > 0
   end
   
   def populate_current( editor, model_index )
@@ -234,22 +209,22 @@ class DistinctDelegate < ComboDelegate
   
   def query_order_description( conn, model_index )
     <<-EOF
-      select distinct #{@attribute.to_s}, lower(#{@attribute.to_s})
-      from #{@ar_model.table_name}
-      where (#{@options[:conditions]})
-      or #{conn.quote_column_name( @attribute.to_s )} = #{conn.quote( model_index.attribute_value )}
-      order by lower(#{@attribute.to_s})
+      select distinct #{attribute.to_s}, lower(#{attribute.to_s})
+      from #{entity_class.table_name}
+      where (#{find_options[:conditions] || '1=1'})
+      or #{conn.quote_column_name( attribute.to_s )} = #{conn.quote( model_index.attribute_value )}
+      order by lower(#{attribute.to_s})
     EOF
   end
   
   def query_order_frequency( conn, model_index )
     <<-EOF
-      select distinct #{@attribute.to_s}, count(#{@attribute.to_s})
-      from #{@ar_model.table_name}
-      where (#{@options[:conditions]})
-      or #{conn.quote_column_name( @attribute.to_s )} = #{conn.quote( model_index.attribute_value )}
-      group by #{@attribute.to_s}
-      order by count(#{@attribute.to_s}) desc
+      select distinct #{attribute.to_s}, count(#{attribute.to_s})
+      from #{entity_class.table_name}
+      where (#{find_options[:conditions] || '1=1'})
+      or #{conn.quote_column_name( attribute.to_s )} = #{conn.quote( model_index.attribute_value )}
+      group by #{attribute.to_s}
+      order by count(#{attribute.to_s}) desc
     EOF
   end
   
@@ -257,19 +232,21 @@ class DistinctDelegate < ComboDelegate
     # we only use the first column, so use the second
     # column to sort by, since SQL requires the order by clause
     # to be in the select list where distinct is involved
-    conn = @ar_model.connection
+    conn = entity_class.connection
     query =
     case
-      when @options[:description]
+      when field.description
         query_order_description( conn, model_index )
-      when @options[:frequency]
+      when field.frequency
         query_order_frequency( conn, model_index )
       else
         query_order_frequency( conn, model_index )
     end
+    puts "query: #{query}"
     rs = conn.execute( query )
     rs.each do |row|
-      editor.add_item( row[0], row[0].to_variant )
+      value = row[attribute.to_s]
+      editor.add_item( value, value.to_variant )
     end
   end
   
@@ -281,13 +258,9 @@ end
 # A Combo box which only allows a restricted set of value to be entered.
 class RestrictedDelegate < ComboDelegate
   # options must contain a :set => [ ... ] to specify the set of values.
-  def initialize( parent, attribute, model_class, options )
-    raise "RestrictedDelegate must have a :set in options" unless options.has_key?( :set )
-    @ar_model = model_class
-    @attribute = attribute
-    @options = options
-    @set = options[:set]
-    super( parent )
+  def initialize( parent, field )
+    raise "RestrictedDelegate must have a :set in options" if field.set.nil?
+    super
   end
   
   def needs_combo?
@@ -299,10 +272,22 @@ class RestrictedDelegate < ComboDelegate
   end
   
   def populate( editor, model_index )
-    @set.each do |item|
-      editor.add_item( item, item.to_variant )
+    field.set.each do |item|
+      if item.is_a?( Array )
+        # this is a hash, so use key as db value
+        # and value as display value
+        editor.add_item( item.last, item.first.to_variant )
+      else
+        editor.add_item( item, item.to_variant )
+      end
     end
   end
+
+  #~ def translate_from_editor_text( editor, text )
+    #~ item_index = editor.find_text( text )
+    #~ item_data = editor.item_data( item_index )
+    #~ item_data.to_int
+  #~ end
 end
 
 # Edit a relation from an id and display a list of relevant entries.
@@ -313,25 +298,24 @@ end
 # and the item text is fetched from them using attribute_path.
 class RelationalDelegate < ComboDelegate
   
-  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 )
+  def initialize( parent, field )
+    super
+    unless find_options[:conditions].nil?
+      find_options[:conditions].gsub!( /true/, entity_class.connection.quoted_true )
+      find_options[:conditions].gsub!( /false/, entity_class.connection.quoted_false )
     end
-    [ :class_name, :sample, :format ].each {|x| @options.delete x }
-    super( parent )
+  end
+  
+  def entity_class
+    @entity_class ||= ( field.class_name || field.attribute.to_s.classify ).constantize
   end
   
   def needs_combo?
-    @model_class.count( :conditions => @options[:conditions] ) > 0
+    entity_class.count( :conditions => find_options[:conditions] ) > 0
   end
   
   def empty_set_message
-    "There must be records in #{@model_class.name.humanize} for this field to be editable."
+    "There must be records in #{entity_class.name.humanize} for this field to be editable."
   end
   
   # add the current item, unless it's already in the combo data
@@ -353,7 +337,7 @@ 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|
+    entity_class.find( :all, find_options ).each do |x|
       add_to_list( editor, model_index, x )
     end
   end
@@ -387,7 +371,7 @@ class RelationalDelegate < ComboDelegate
       # get the entity it refers to, if there is one
       # use find_by_id so that if it's not found, nil will
       # be returned
-      @model_class.find_by_id( item_data.to_int )
+      entity_class.find_by_id( item_data.to_int )
     end
   end
   

data/lib/clevic/dirty.rb

@@ -0,0 +1,101 @@
+begin
+  ActiveRecord::Dirty
+rescue NameError
+
+module ActiveRecord
+  # Define ActiveRecord::Dirty if it isn't already defined by ActiveRecord,
+  # which it is in 2.1 and up.
+  module Dirty
+    def self.included(base)
+      base.attribute_method_suffix '_changed?', '_change', '_original'
+      base.alias_method_chain :read_attribute,  :dirty
+      base.alias_method_chain :write_attribute, :dirty
+      base.alias_method_chain :save,            :dirty
+    end
+
+    # Do any attributes have unsaved changes?
+    #   person.changed? # => false
+    #   person.name = 'bob'
+    #   person.changed? # => true
+    def changed?
+      !changed_attributes.empty?
+    end
+
+    # List of attributes with unsaved changes.
+    #   person.changed # => []
+    #   person.name = 'bob'
+    #   person.changed # => ['name']
+    def changed
+      changed_attributes.keys
+    end
+
+    # Map of changed attrs => [original value, new value]
+    #   person.changes # => {}
+    #   person.name = 'bob'
+    #   person.changes # => { 'name' => ['bill', 'bob'] }
+    def changes
+      changed.inject({}) { |h, attr| h[attr] = attribute_change(attr); h }
+    end
+
+
+    # Clear changed attributes after they are saved.
+    def save_with_dirty(*args) #:nodoc:
+      save_without_dirty(*args)
+    ensure
+      changed_attributes.clear
+    end
+
+    private
+    
+    # Map of change attr => original value.
+    def changed_attributes
+      @changed_attributes ||= {}
+    end
+
+
+    # Wrap read_attribute to freeze its result.
+    def read_attribute_with_dirty(attr)
+      read_attribute_without_dirty(attr).freeze
+    end
+
+    # Wrap write_attribute to remember original attribute value.
+    def write_attribute_with_dirty(attr, value)
+      attr = attr.to_s
+
+      # The attribute already has an unsaved change.
+      unless changed_attributes.include?(attr)
+        old = read_attribute(attr)
+
+        # Remember the original value if it's different.
+        changed_attributes[attr] = old unless old == value
+      end
+
+      # Carry on.
+      write_attribute_without_dirty(attr, value)
+    end
+
+
+    # Handle *_changed? for method_missing.
+    def attribute_changed?(attr)
+      changed_attributes.include?(attr)
+    end
+
+    # Handle *_change for method_missing.
+    def attribute_change(attr)
+      [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
+    end
+
+    # Handle *_original for method_missing.
+    def attribute_original(attr)
+      attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+    end
+  end # module Dirty
+
+  # put this here so it's part of the compatibility rescue block.
+  class Base
+    include ActiveRecord::Dirty
+  end
+
+end # module ActiveRecord
+
+end # rescue