qtext 0.6.0 → 0.6.2

data/History.txt

@@ -1,3 +1,6 @@
+== 0.6.2
+* Fix some errors with ActionBuilder. Add ActionBuilder#group_names
+
 == 0.6.0
 * add Qt::Widget.signal class method which adds some signal emitting and
   handling methods.

data/Manifest.txt

@@ -10,6 +10,7 @@ lib/qtext.rb
 lib/qtext/action_builder.rb
 lib/qtext/extensions.rb
 lib/qtext/flags.rb
+lib/qtext/hash_collector.rb
 lib/qtext/object_table_model.rb
 lib/qtext/version.rb
 script/console

data/lib/qtext/action_builder.rb

@@ -89,9 +89,13 @@ module ActionBuilder
     end
   end
   
+  def group_names
+    @group_names ||= []
+  end
+  
   # Create a new separator and add a new separator.
   def separator
-    Qt::Action.construct( parent ) do |action|
+    Qt::Action.new( parent ) do |action|
       action.separator = true
       add_action action
       collect_actions << action
@@ -103,15 +107,22 @@ module ActionBuilder
   # 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.clear
+    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 Qt::Action and
@@ -130,7 +141,7 @@ module ActionBuilder
         raise "you can't specify both :method and a block"
       end
       
-      Qt::Action.construct( parent ) do |action|
+      Qt::Action.new( parent ) do |action|
         action.object_name = name.to_s
         action.text = text
         options.each do |k,v|

data/lib/qtext/extensions.rb

@@ -3,6 +3,7 @@
 require 'Qt4'
 require 'qtext/flags.rb'
 require 'bigdecimal'
+require 'qtext/hash_collector.rb'
 
 # Because Qt::Variant.new( obj ) is a PITA to type
 class Object
@@ -35,6 +36,18 @@ class BigDecimal
   end
 end
 
+# Collect row and column values in various ways
+class IndexCollector < HashCollector
+  dsl_accessor :row, :column
+
+  def initialize( row, column )
+    super()
+    # MUST use writers here, not instance variables
+    self.row = row
+    self.column = column
+  end
+end
+
 # convenience methods
 module Qt
 
@@ -132,6 +145,45 @@ module Qt
       end
     end
     
+    # CHange and cOP(P)Y - make a new index based on this one,
+    # modify the new index with values from the parameters, the
+    # args hash or the block.
+    # The block will instance_eval with no args, or pass self
+    # if there's one arg. You can also pass two parameters, interpreted
+    # as row, columns.
+    # Examples:
+    #   new_index = index.choppy { row 10; column 13 }
+    #   new_index = index.choppy { row 10; column 13 }
+    #   new_index = index.choppy( 1,3 )
+    #   new_index = index.choppy { |i| i.row += 1 }
+    #   new_index = index.choppy :row => 16
+    #   same_index = index.choppy
+    def choppy( *args, &block  )
+      return ModelIndex.invalid unless self.valid?
+      
+      # initialize with defaults
+      stash = IndexCollector.new( row, column )
+      
+      case args.size
+        when 0,1
+          # args.first is a hash, or nil
+          stash.collect( args.first, &block )
+        when 2
+          # args are two parameters - row, column
+          stash.row, stash.column = args
+          stash.collect( &block )
+        else
+          raise TypeError.new( "incorrect args #{args.inspect}" )
+      end
+      
+      # return an invalid index if it's out of bounds,
+      # or the choppy'd index if it's OK.
+      if stash.row >= model.row_count || stash.column >= model.column_count
+        ModelIndex.invalid
+      else
+        model.create_index( stash.row.to_i, stash.column.to_i )
+      end
+    end
   end
 
   # Make keystrokes events easier to work with. For <tt>Qt::Key_Whatever</tt>

data/lib/qtext/hash_collector.rb

@@ -0,0 +1,120 @@
+# A DSL class that allows options to be collected for a field
+# definition using a block and/or a hash.
+#  hash = { :colour => :red, :hue => 15 }
+#  collector = HashCollector.new( hash ) do |hc|
+#    hc.saturation = 17
+#    hc.opacity = 0.43
+#    hc.grooviness = 100
+#  end
+# or like this (without the block parameter)
+#  collector = HashCollector.new( hash ) do
+#    saturation 17
+#    opacity 0.43
+#    grooviness = 100
+#  end
+# either way, a call to collector.to_hash will result in
+#  { :hue=>15, :saturation=>17, :opacity=>0.43, :grooviness=>100, :colour=>:red }
+# and the following accessors will be added
+#  collector.hue
+#  collector.hue( some_value )
+#  collector.hue = some_value
+# for hue, saturation, opacity, grooviness and colour.
+class HashCollector
+  # remove unused methods that might clash with user accessors
+  keep_methods = %w( __send__ __id__ self send class inspect instance_eval instance_variables )
+  instance_methods.each do |method|
+    undef_method( method ) unless keep_methods.include?( method )
+  end
+  
+  # Collect values from the hash and the block, using the collect method.
+  def initialize( hash = {}, &block )
+    @hash = hash || {}
+    gather( &block )
+  end
+  
+  # evaluate the block and collect options from args. Even if it's nil.
+  def collect( args = {}, &block )
+    @hash.merge!( args || {} )
+    unless block.nil?
+      if block.arity == -1
+        instance_eval &block
+      else
+        yield self
+      end
+    end
+  end
+  
+  # return a hash of the collected elements
+  def to_hash
+    @hash
+  end
+  
+protected
+  
+  # Modified from Jim Freeze's article.
+  # For each symbol, add accessors to allow:
+  #  instance.symbol as reader
+  #  instance.symbol( value ) as writer
+  #  instance.symbol = value as writer
+  def self.dsl_accessor( *symbols )
+    @stripper ||= /^([^\= ]+)\s*\=?\s*$/
+    symbols.each do |sym|
+      stripped = @stripper.match( sym.to_s )[1]
+      line, st = __LINE__, <<-EOF
+        def #{stripped}(*val)
+          if val.empty?
+            @hash[:#{stripped}]
+          else
+            @hash[:#{stripped}] = val.size == 1 ? val[0] : val
+          end
+        end
+        
+        def #{stripped}=(*val)
+          @hash[:#{stripped}] = val.size == 1 ? val[0] : val
+        end
+      EOF
+      class_eval st, __FILE__, line + 1
+    end
+  end
+  
+  # Do not allow accessors to be added dynamically. In other words,
+  # a subclass like this
+  #  class IndexCollector < HashCollector
+  #    dsl_static
+  #    dsl_accessor :row, :column
+  #  end
+  # will fail if used like this
+  #  collector = IndexCollector.new( :row => 4, :column => 6 ) do
+  #    other 'oops'
+  #  end
+  # because :other isn't added by dsl_accessor.
+  def self.dsl_static
+    @dynamic = false
+  end
+  
+  # Allow accessors to be added dynamically, the default.
+  def self.dsl_dynamic
+    @dynamic = true
+  end
+  
+  def self.dynamic?
+    # don't optimise this to @dynamic ||= true, because it will reset
+    # an @dynamic of false to true
+    @dynamic = true if @dynamic.nil?
+    @dynamic
+  end
+
+  # Originally from Jim Freeze's article. Add the accessor methods if
+  # they don't already exist, and if dsl_dynamic is in effect, which is
+  # the default. If dsl_static is in effect, the normal method_missing
+  # behaviour will be invoked.
+  def method_missing(sym, *args)
+    if self.class.dynamic?
+      self.class.dsl_accessor sym
+      send( sym, *args )
+    else
+      super
+    end
+  end
+  
+end

data/lib/qtext/object_table_model.rb

@@ -1,6 +1,31 @@
 require 'active_support'
 require 'qtext/flags.rb'
 
+module Qt
+  class ModelIndex
+    def entity
+      model.collection[row]
+    end
+  end
+end
+
+class ZeroSize
+  def size; 0; end
+end
+
+module TreeViewable
+  attr_accessor :parent
+  
+  def children=( ary )
+    ary.each{|x| x.parent = self}
+    @children = ary
+  end
+  
+  def children
+    @children ||= ZeroSize.new
+  end
+end
+
 =begin rdoc
 A header for ObjectTableModel.
 =end
@@ -55,6 +80,7 @@ class ObjectTableModel < Qt::AbstractTableModel
   # - :collection is an alias for :data
   def initialize( args = {} )
     super( args[:parent] )
+    @parent = args[:parent]
     @collection = args[:data] || args[:collection] || []
     set_headers( args[:headers] )
   end
@@ -62,7 +88,7 @@ class ObjectTableModel < Qt::AbstractTableModel
   # implementation of Qt:AbstractItemModel method
   def rowCount( parent_model_index = Qt::ModelIndex.invalid )
     if parent_model_index.valid?
-      0
+      parent_model_index.entity.children.size
     else
       collection.size
     end
@@ -70,12 +96,25 @@ class ObjectTableModel < Qt::AbstractTableModel
   
   def columnCount( parent_model_index = Qt::ModelIndex.invalid )
     if parent_model_index.valid?
-      0
+      parent_model_index.entity.children.size == 0 ? 0 : headers.size
     else
       headers.size
     end
   end
   
+  # TODO what exactly is this for again? Something to do with
+  # QWidget.parent() and Qt::AbstractTableModel.parent(...)
+  def parent( *args )
+    if args.size == 0
+      retval = super()
+      retval || @parent
+    else
+      if model_index.valid?
+        collection.index( model_index.entity.parent )
+      end
+    end
+  end
+  
   # implementation of Qt:AbstractItemModel method
   def headerData( section, orientation, role )
     value =

data/lib/qtext/version.rb

@@ -2,7 +2,7 @@ module Qtext #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 6
-    TINY  = 0
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/test_hash_collector.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class OtherThing < HashCollector
+  dsl_static
+  dsl_accessor :thing, :other
+end
+
+class BuildOn < HashCollector
+  dsl_accessor :ook
+end
+
+class TestHashCollector < Test::Unit::TestCase
+  def setup
+    @hash = { :colour => :red, :hue => 15 }
+    @collected_hash = { :saturation => 17, :opacity => 0.43, :grooviness => 100 }
+    @full_hash = @hash.merge( @collected_hash )
+    @collector = HashCollector.new
+  end
+  
+  def teardown
+  end
+  
+  context 'static hash collector' do
+    setup do
+      @collector = OtherThing.new
+    end
+    
+    should "throw NoMethodError on collection" do
+      assert_raise( NoMethodError ) do
+        @collector.collect { thing 2; blah 3 }
+      end
+      assert_raise( NoMethodError ) do
+        @collector.collect {|c| c.blah = 3 }
+      end
+      assert_raise( NoMethodError ) { @collector.blah }
+      assert_raise( NoMethodError ) { @collector.blah = 5 }
+    end
+
+    should "understand defined attributes" do
+      assert_nothing_raised do
+        @collector.collect do
+          thing 1
+          other 2
+        end
+      end
+      
+      assert_nothing_raised { @collector.thing = 2 }
+      assert_nothing_raised { @collector.other = 4 }
+    end
+    
+    should "be dynamic" do
+      assert BuildOn.dynamic?
+    end
+  end
+  
+  def assert_collected( collector )
+    assert_equal 17, collector.saturation
+    assert_equal 0.43, collector.opacity
+    assert_equal 100, collector.grooviness
+  end
+  
+  def assert_hashed( collector )
+    assert_equal :red, collector.colour
+    assert_equal 15, collector.hue
+  end
+  
+  should "collect from a hash" do
+    @collector.collect( @hash )
+    assert_equal @hash, @collector.to_hash
+  end
+
+  should 'not fail on a nil hash' do
+    @collector.collect nil
+    assert_equal 0, @collector.to_hash.size
+  end
+  
+  should 'collect from a block, with dsl setters' do
+    @collector.collect do
+      saturation 17
+      opacity 0.43
+      grooviness 100
+    end
+    assert_collected( @collector )
+    assert_equal @collected_hash, @collector.to_hash
+  end
+
+  should 'collect from a block, with = setters' do
+    @collector.collect do |hc|
+      hc.saturation = 17
+      hc.opacity = 0.43
+      hc.grooviness = 100
+    end
+    assert_collected( @collector )
+    assert_equal @collected_hash, @collector.to_hash
+  end
+  
+  should 'collect from a hash and block, with dsl setters' do
+    @collector.collect( @hash ) do
+      saturation 17
+      opacity 0.43
+      grooviness 100
+    end
+    assert_collected( @collector )
+    assert_hashed( @collector )
+    assert_equal @full_hash, @collector.to_hash
+  end
+  
+  should 'collect from a hash and block with = setters' do
+    @collector.collect( @hash ) do |hc|
+      hc.saturation = 17
+      hc.opacity = 0.43
+      hc.grooviness = 100
+    end
+    assert_collected( @collector )
+    assert_hashed( @collector )
+    assert_equal @full_hash, @collector.to_hash
+  end
+  
+  should 'not fail construction with a nil hash' do
+    collector = HashCollector.new nil
+    assert_equal 0, @collector.to_hash.size
+  end
+  
+  should 'construct from a hash and block, with dsl setters' do
+    collector = HashCollector.new( @hash ) do
+      saturation 17
+      opacity 0.43
+      grooviness 100
+    end
+    assert_collected( collector )
+    assert_hashed( collector )
+    assert_equal @full_hash, collector.to_hash
+  end
+  
+  should 'construct from a hash and bslock with = setters' do
+    collector = HashCollector.new( @hash ) do |hc|
+      hc.saturation = 17
+      hc.opacity = 0.43
+      hc.grooviness = 100
+    end
+    assert_collected( collector )
+    assert_hashed( collector )
+    assert_equal @full_hash, collector.to_hash
+  end
+  
+  should 'not conflict with Object methods' do
+    hc = HashCollector.new do
+      display 'something'
+      sample "This is a long string designed to test the code to the very limits of possibility."
+    end
+    
+    assert_equal 'something', hc.display
+    assert_equal "This is a long string designed to test the code to the very limits of possibility.", hc.sample
+  end
+  
+  should 'work when called with &block instead of a do ... end' do
+    options = gather_block do
+      display    'activity'
+      order      'lower(activity)'
+      sample     'Troubleshooting'
+      conditions 'active = true'
+    end
+    assert_equal 'activity', options[:display]
+  end
+  
+  should 'work when called with options and &block instead of a do ... end' do
+    options = gather_block :blah => 'ook' do
+      display    'activity'
+      order      'lower(activity)'
+      sample     'Troubleshooting'
+      conditions 'active = true'
+    end
+    assert_equal 'activity', options[:display]
+    assert_equal 'ook', options[:blah]
+  end
+  
+  def gather_block( options = {}, &block )
+    HashCollector.new( options, &block ).to_hash
+  end
+end

data/test/test_model_index_extensions.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class TestModelIndex < Test::Unit::TestCase
+  def self.startup
+  end
+  
+  def self.shutdown
+  end
+  
+  def setup
+    @model = Qt::StandardItemModel.new( 4, 4 )
+    ( 0...@model.row_count ).each do |i|
+      ( 0...@model.column_count ).each do |j|
+        @model.set_item( i, j, Qt::StandardItem.new( "location: (#{i},#{j})" ) )
+      end
+    end
+    @zero_index = @model.create_index(0,0)
+  end
+  
+  def teardown
+  end
+  
+  should "be valid" do
+    assert @zero_index.valid?
+  end
+  
+  should_eventually "be invalid" do
+    mi = @model.create_index( @model.row_count+1, @model.column_count+1 )
+    assert !mi.valid?
+  end
+  
+  should 'be an invalid copy of an invalid index' do
+    choppy = Qt::ModelIndex.invalid.choppy
+    assert !choppy.valid?
+  end
+  
+  should "be a valid exact copy" do
+    choppy = @zero_index.choppy
+    assert choppy.valid?
+  end
+
+  should 'be an invalid copy' do
+    choppy = @zero_index.choppy( :row => @model.row_count )
+    assert !choppy.valid?, "choppy: #{choppy.inspect}"
+    
+    choppy = @zero_index.choppy( :column => @model.column_count )
+    assert !choppy.valid?
+  end
+  
+  should 'be a copy with a changed row and column, from hash' do
+    choppy = @zero_index.choppy( :row => 1, :column => 2)
+    assert_equal 1, choppy.row, choppy.inspect
+    assert choppy.valid?, choppy.inspect
+    assert_equal 2, choppy.column, choppy.inspect
+  end
+
+  should 'be a choppy with incremented row and column, from block' do
+    choppy = @zero_index.choppy do |i|
+      i.row += 1
+      i.column += 2
+    end
+    assert choppy.valid?
+    assert_equal 1, choppy.row
+    assert_equal 2, choppy.column
+  end
+  
+  should 'be a copy with changed row and column, from parameters' do
+    choppy = @zero_index.choppy(3,0)
+    assert choppy.valid?
+    assert_equal 3, choppy.row
+    assert_equal 0, choppy.column
+  end
+  
+  should 'raise an exception because parameters are wrong' do
+    assert_raise TypeError do
+      @zero_index.choppy( 3 )
+    end
+  end
+  
+  should 'be a copy with decremented row and column, from block' do
+    two_index = @model.create_index(2,2)
+    
+    choppy = two_index.choppy do |i|
+      i.row -= 1
+      i.column -= 2
+    end
+    assert choppy.valid?
+    assert_equal 1, choppy.row
+    assert_equal 0, choppy.column
+  end
+
+  should 'be a copy with changed row and column, from block' do
+    choppy = @zero_index.choppy do |i|
+      i.row = 3
+      i.column = 2
+    end
+    assert choppy.valid?
+    assert_equal 3, choppy.row
+    assert_equal 2, choppy.column
+  end
+
+  should 'be a copy with changed row and column, from instance_eval' do
+    choppy = @zero_index.choppy do
+      row 3
+      column 2
+    end
+    assert choppy.valid?
+    assert_equal 3, choppy.row
+    assert_equal 2, choppy.column
+  end
+end

data/test/test_object_table.rb

@@ -4,6 +4,7 @@ require 'Qt4'
 
 class TestObjectTableModel < Test::Unit::TestCase
   Thing = Struct.new( :name, :value, :location, :price, :ignored )
+  Thing.include TreeViewable
   
   def self.startup
     $app ||= Qt::Application.new( [] )
@@ -16,12 +17,18 @@ class TestObjectTableModel < Test::Unit::TestCase
       Thing.new( "Bed", 'large', 'bedroom' ),
       Thing.new( "Approximation", 'useful', 'maths', 'none', 'all' )
     ]
+    @data[3].children = @data
     @model = ObjectTableModel.new( :data => @data, :headers => [ :name, :value, :location, Header.new( :attribute => :price, :alignment => Qt::AlignRight ) ] )
     @main_window = Qt::MainWindow.new
-    @view = Qt::TableView.new( @main_window ) { |tv| tv.model = @model }
+    #~ @view = Qt::TableView.new( @main_window ) { |tv| tv.model = @model }
+    @view = Qt::TreeView.new( @main_window ) { |tv| tv.model = @model }
     @main_window.central_widget = @view
   end
   
+  should 'have children for data[3]' do
+    assert_equal 4, @data[3].children.size
+  end
+  
   should 'have a 4 x 4 size' do
     assert_equal 4, @model.rowCount
     assert_equal 4, @model.row_count
@@ -55,14 +62,6 @@ class TestObjectTableModel < Test::Unit::TestCase
     assert_equal Qt::AlignRight.to_i, @model.data( @model.create_index(0,3), Qt::TextAlignmentRole ).to_i & Qt::AlignRight.to_i
   end
   
-  should_eventually 'display the window' do
-  #~ should 'display the window' do
-    @main_window.window_title = 'Test ObjectTableModel'
-    @main_window.move( 150, 0 )
-    @main_window.show
-    $app.exec
-  end
-  
   should 'have a nil parent' do
     assert_nil @model.parent
   end
@@ -71,4 +70,20 @@ class TestObjectTableModel < Test::Unit::TestCase
     model = ObjectTableModel.new( :parent => @model, :data => @data, :headers => [ :name, :value, :location, Header.new( :attribute => :price, :alignment => Qt::AlignRight ) ] )
     assert_equal @model, model.parent
   end
+  
+  context 'tree view' do
+    should 'have children' do
+      model_index = @model.create_index(3,0)
+      assert_equal 4, @model.row_count( model_index )
+    end
+  end
+
+  def dont_test_show_window
+  #~ def test_show_window
+    @main_window.window_title = 'Test ObjectTableModel'
+    @main_window.move( 150, 0 )
+    @main_window.show
+    $app.exec
+  end
+  
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: qtext
 version: !ruby/object:Gem::Version 
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors: 
 - FIXME full name
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-10-09 00:00:00 +02:00
+date: 2009-01-29 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.7.0
+        version: 1.8.0
     version: 
 description: description of gem
 email: 
@@ -47,6 +47,7 @@ files:
 - lib/qtext/action_builder.rb
 - lib/qtext/extensions.rb
 - lib/qtext/flags.rb
+- lib/qtext/hash_collector.rb
 - lib/qtext/object_table_model.rb
 - lib/qtext/version.rb
 - script/console
@@ -82,11 +83,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: qtext
-rubygems_version: 1.2.0
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: description of gem
 test_files: 
+- test/test_model_index_extensions.rb
 - test/test_object_table.rb
+- test/test_hash_collector.rb
 - test/test_widget.rb
 - test/test_helper.rb