reflexion 0.5.3 → 0.7.0

data/test/test_clipboard.rb

@@ -0,0 +1,54 @@
+require_relative 'helper'
+
+
+class TestClipboard < Test::Unit::TestCase
+
+  def setup()
+    @saved_text = Reflex::Clipboard.text
+  end
+
+  def teardown()
+    if @saved_text
+      Reflex::Clipboard.text = @saved_text
+    else
+      Reflex::Clipboard.clear
+    end
+  end
+
+  def test_initialize()
+    assert_raise(Reflex::ReflexError) {Reflex::Clipboard.new}
+  end
+
+  def test_text()
+    Reflex::Clipboard.text = 'ABC'
+    assert_equal 'ABC', Reflex::Clipboard.text
+  end
+
+  def test_text_utf8()
+    Reflex::Clipboard.text = 'あいう'
+    assert_equal 'あいう',        Reflex::Clipboard.text
+    assert_equal Encoding::UTF_8, Reflex::Clipboard.text.encoding
+  end
+
+  def test_text_multiline()
+    Reflex::Clipboard.text = "A\nB\nC"
+    assert_equal "A\nB\nC", Reflex::Clipboard.text
+  end
+
+  def test_universal_accessor()
+    Reflex::Clipboard.text 'ABC'
+    assert_equal 'ABC', Reflex::Clipboard.text
+  end
+
+  def test_clear()
+    Reflex::Clipboard.text = 'ABC'
+    Reflex::Clipboard.clear
+    assert_nil Reflex::Clipboard.text
+  end unless linux?
+
+  def test_empty_text()
+    Reflex::Clipboard.text = ''
+    assert_equal '', Reflex::Clipboard.text
+  end unless linux?
+
+end# TestClipboard

data/test/test_color_event.rb

@@ -0,0 +1,36 @@
+require_relative 'helper'
+
+
+class TestColorEvent < Test::Unit::TestCase
+
+  def event(*args)
+    Reflex::ColorEvent.new(*args)
+  end
+
+  def color(*args)
+    Reflex::Color.new(*args)
+  end
+
+  def test_initialize()
+    assert_equal color(1, 0, 0),      event(color(1, 0, 0)).color
+    assert_equal color(0, 1, 0, 0.5), event([0, 1, 0, 0.5]).color
+
+    assert_raise(ArgumentError) {event}
+    assert_raise(ArgumentError) {event(nil)}
+  end
+
+  def test_dup()
+    e1 = event color(1, 0, 0)
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+  def test_inspect()
+    assert_equal "#<Reflex::ColorEvent color:[1.0, 0.0, 0.0, 1.0]>", event(color(1, 0, 0)).inspect
+  end
+
+end# TestColorEvent

data/test/test_color_picker.rb

@@ -0,0 +1,62 @@
+require_relative 'helper'
+
+
+class TestColorPicker < Test::Unit::TestCase
+
+  include HasWindow
+
+  def picker(*args, &block)
+    Reflex::ColorPicker.new(*args, &block)
+  end
+
+  def event(color)
+    Reflex::ColorEvent.new color
+  end
+
+  def color(*args)
+    Reflex::Color.new(*args)
+  end
+
+  def test_initialize()
+    assert_nil   picker                     .owner
+    assert_false picker                     .alpha?
+    assert_true  picker(      alpha:  true) .alpha?
+    assert_true  picker      {alpha   true} .alpha?
+    assert_true  picker {self.alpha = true} .alpha?
+  end
+
+  def test_owner()
+    w = window
+    picker.tap do |p|
+      p.owner = w
+      assert_equal w, p.owner
+      p.owner = nil
+      assert_nil      p.owner
+    end
+
+    assert_raise(TypeError) {picker.owner = 1}
+  end
+
+  def test_alpha()
+    picker.tap do |p|
+      p.alpha = true
+      assert_true  p.alpha?
+      p.alpha = false
+      assert_false p.alpha?
+    end
+  end
+
+  def test_color_block_stays_until_close()
+    # the native side calls call_color_block and clear_color_block
+    p, got = picker, []
+    p.instance_variable_set :@color_block, -> e {got << e.color}
+    p.send :call_color_block, event(color(1, 0, 0))
+    p.send :call_color_block, event(color(0, 1, 0))
+    assert_equal [color(1, 0, 0), color(0, 1, 0)], got
+
+    p.send :clear_color_block
+    p.send :call_color_block, event(color(0, 0, 1))
+    assert_equal [color(1, 0, 0), color(0, 1, 0)], got
+  end
+
+end# TestColorPicker

data/test/test_constraint.rb

@@ -0,0 +1,184 @@
+require_relative 'helper'
+
+
+class TestConstraint < Test::Unit::TestCase
+
+  include HasWindow
+
+  R = Reflex
+
+  def view(x = 0, y = 0, w = 50, h = 50, **options, &block)
+    R::View.new(
+      frame: [x, y, w, h],
+      shape: R::RectShape.new(density: 1),
+      **options, &block)
+  end
+
+  def point(...)
+    R::Point.new(...)
+  end
+
+  def setup_views(win = window)
+    v1 = view 100, 100, dynamic: true
+    v2 = view 200, 100, static:  true
+    win&.add v1
+    win&.add v2
+    [v1, v2, win, win&.root]
+  end
+
+  def test_activation()
+    v1, v2, = setup_views nil
+    w       = window
+
+    c = v1.link v2; assert_false c.active?
+    w.add    v1;    assert_false c.active?
+    w.add    v2;    assert_true  c.active?
+    w.remove v1;    assert_false c.active?
+    w.add    v1;    assert_true  c.active?
+    c = v1.link v2; assert_true  c.active?
+
+    assert_in_delta 100, c.current_distance
+  end
+
+  def test_pins()
+    v1, v2, = setup_views
+
+    c = v1.pin(10, 20).snap v2.pin(30, 40)
+    assert_equal       v1,            c.pins[0].view
+    assert_equal_point point(10, 20), c.pins[0].pos
+    assert_equal       v2,            c.pins[1].view
+    assert_equal_point point(30, 40), c.pins[1].pos
+    assert_equal       [v1, v2],      c.views
+    assert_equal       [v1, v2],      c.pins.map(&:view)
+  end
+
+  def test_resolved_positions()
+    v1, v2, = setup_views
+
+    assert_equal_point point( 25,   25), v1.pin        .snap(v2)        .pins[0].pos
+    assert_equal_point point(-75,   25), v1.pin        .snap(v2)        .pins[1].pos
+    assert_equal_point point( 10,   20), v1.pin(10, 20).snap(v2)        .pins[0].pos
+    assert_equal_point point(-90,   20), v1.pin(10, 20).snap(v2)        .pins[1].pos
+    assert_equal_point point( 130,  40), v1.pin        .snap(v2, 30, 40).pins[0].pos
+    assert_equal_point point( 30,   40), v1.pin        .snap(v2, 30, 40).pins[1].pos
+    assert_equal_point point( 50,   60), v1.pin(50, 60).snap(v2, 70, 80).pins[0].pos
+    assert_equal_point point( 70,   80), v1.pin(50, 60).snap(v2, 70, 80).pins[1].pos
+  end
+
+  def test_spring()
+    v1, v2, = setup_views
+
+    c = v1.link v2, spring: 4, damping: 0.5
+    assert_in_delta 4,                 c.spring
+    assert_in_delta 0.5,               c.damping
+
+    c.spring = nil; assert_nil         c.spring
+    c.spring = 8;   assert_in_delta 8, c.spring
+  end
+
+  def test_collide()
+    v1, v2, = setup_views
+
+    assert_false v1.snap(v2)                .collide?
+    assert_false v1.snap(v2, collide: false).collide?
+    assert_true  v1.snap(v2, collide: true) .collide?
+  end
+
+  def test_selector()
+    v1, v2, = setup_views
+
+    c = v1.link v2, name: :name1, tag: [:tag1, :tag2]
+    assert_equal 'name1',          c.name
+    assert_equal ['tag1', 'tag2'], c.tags.to_a
+    assert_true                    c.tag?(:tag1)
+    assert_true                    c.tag?('tag1')
+    assert_true                    c.tag?(:tag2)
+    assert_false                   c.tag?(:tag3)
+
+    c.name = :name2
+    assert_equal 'name2', c.name
+
+    assert_false                           c.tag?(:tag9)
+    c.add_tag                                     :tag9
+    assert_true                            c.tag?(:tag9)
+    assert_equal ['tag1', 'tag2', 'tag9'], c.tags.to_a
+    c.remove_tag                                  :tag9
+    assert_false                           c.tag?(:tag9)
+    assert_equal ['tag1', 'tag2'],         c.tags.to_a
+
+    c.clear_tags
+    assert_equal [], c.tags.to_a
+  end
+
+  def test_block()
+    v1, v2, = setup_views
+
+    c = v1.link v2 do
+      distance 80
+      spring   4
+    end
+    assert_equal    80, c.distance
+    assert_in_delta 4,  c.spring
+  end
+
+  def test_constraints()
+    v1, v2, = setup_views
+
+    c1 = v1.link v2
+    c2 = v1.snap v2
+    assert_equal [c1, c2], v1.constraints.to_a
+    assert_equal [c1, c2], v2.constraints.to_a
+    assert_equal [R::LinkConstraint, R::SnapConstraint], v1.constraints.map(&:class)
+  end
+
+  def test_remove()
+    v1, v2, _, parent = setup_views
+
+    c = v1.link v2
+    c.remove
+    assert_false     c.active?
+    assert_true      c.removed?
+    assert_equal [], v1.constraints.to_a
+    assert_equal [], v2.constraints.to_a
+
+    c.remove # idempotent
+
+    parent.remove v1
+    parent.add    v1
+    assert_false c.active? # never comes back
+
+    assert_nothing_raised do
+      c.spring   = 4
+      c.damping  = 0.5
+      c.distance = 50
+    end
+    assert_false c.active? # removed constraint is inert
+  end
+
+  def test_constrain_to_itself_error()
+    setup_views.tap do |v,|
+      assert_raise(ArgumentError) {v.snap  v}
+    end
+    setup_views.tap do |v,|
+      assert_raise(ArgumentError) {v.chase v}
+      assert_equal [], v.constraints.to_a # rejected self-constraint leaves no orphan
+    end
+  end
+
+  def test_world_mismatch_error()
+    win             = window
+    parent1, child1 = view(0, 0, 500, 500), view(100, 100, dynamic: true)
+    parent2, child2 = view(0, 0, 500, 500), view(100, 100, dynamic: true)
+    parent1.add child1
+    parent2.add child2
+    win.add parent1
+    win.add parent2
+    child1.meter2pixel # create parent1 world
+    child2.meter2pixel # create parent2 world
+
+    assert_raise(R::PhysicsError) {child1.snap child2}
+    assert_equal [], child1.constraints.to_a # rejected pins leave no trace
+    assert_equal [], child2.constraints.to_a
+  end
+
+end# TestConstraint

data/test/test_event.rb

@@ -46,7 +46,7 @@ class TestEvent < Test::Unit::TestCase
   end
 
   def test_time()
-    assert_in_delta Time.now.to_f, event.time, 0.001
+    assert_in_delta Time.now.to_f, event.time, 0.1
   end
 
 end# TestEvent

data/test/test_file_dialog.rb

@@ -0,0 +1,48 @@
+require_relative 'helper'
+
+
+class TestFileDialog < Test::Unit::TestCase
+
+  def dialog(*args, &block)
+    Reflex::FileDialog.new(*args, &block)
+  end
+
+  def test_initialize()
+    assert_nil            dialog                            .owner
+    assert_equal '',      dialog                            .title
+    assert_equal 'hoge',  dialog(      title:  'hoge')      .title
+    assert_equal 'hoge',  dialog      {title   'hoge'}      .title
+    assert_equal 'hoge',  dialog {self.title = 'hoge'}      .title
+    assert_equal [],      dialog                            .extensions
+    assert_equal ['png'], dialog(      extensions:  ['png']).extensions
+    assert_equal ['png'], dialog      {extensions   ['png']}.extensions
+    assert_equal ['png'], dialog {self.extensions = ['png']}.extensions
+  end
+
+  def test_extensions()
+    dialog.tap do |d|
+      d.extensions = %w[png jpg]
+      assert_equal   %w[png jpg], d.extensions
+      d.extensions = ['txt']
+      assert_equal   ['txt'],     d.extensions
+    end
+
+    assert_equal %w[png],    dialog(extensions: 'png')      .extensions
+    assert_equal %w[png],    dialog(extensions: ['png'])    .extensions
+    assert_equal %w[png],    dialog(extensions: [:png])     .extensions
+    assert_equal %w[jpg],    dialog(extensions: ['.jpg'])   .extensions
+    assert_equal %w[gif],    dialog(extensions: ['..gif'])  .extensions
+    assert_equal %w[tar.gz], dialog(extensions: ['.tar.gz']).extensions
+
+    assert_raise(ArgumentError) {dialog.extensions = ['']}
+    assert_raise(ArgumentError) {dialog.extensions = ['.']}
+    assert_raise(ArgumentError) {dialog.extensions = ['png', '']}
+    assert_raise(ArgumentError) {dialog.extensions = ['*.png']}
+    assert_raise(ArgumentError) {dialog.extensions = ['p?g']}
+    assert_raise(ArgumentError) {dialog.extensions = ['png;jpg']}
+    assert_raise(ArgumentError) {dialog.extensions = ['a/b']}
+    assert_raise(ArgumentError) {dialog.extensions = [/png/]}
+    assert_raise(ArgumentError) {dialog.extensions = [1]}
+  end
+
+end# TestFileDialog

data/test/test_file_event.rb

@@ -0,0 +1,43 @@
+require_relative 'helper'
+
+
+class TestFileEvent < Test::Unit::TestCase
+
+  Event            = Reflex::FileEvent
+
+  NONE, OPEN, SAVE = Event::ACTION_NONE, Event::OPEN, Event::SAVE
+
+  def event(*args)
+    Event.new(*args)
+  end
+
+  def test_initialize()
+    assert_equal :open,        event(OPEN, ['/a', '/b']).action
+    assert_equal ['/a', '/b'], event(OPEN, ['/a', '/b']).paths
+    assert_equal '/a',         event(OPEN, ['/a', '/b']).path
+  end
+
+  def test_dup()
+    e1 = event OPEN, ['/a']
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+  def test_action()
+    assert_equal :none, event(NONE, []).action
+    assert_equal :open, event(OPEN, []).action
+    assert_equal :save, event(SAVE, []).action
+  end
+
+  def test_open_save?()
+    assert_true  event(OPEN, ['/a']).open?
+    assert_false event(OPEN, ['/a']).save?
+    assert_false event(SAVE, ['/a']).open?
+    assert_true  event(SAVE, ['/a']).save?
+  end
+
+end# TestFileEvent

data/test/test_has_text_preedit.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+require_relative 'helper'
+
+
+class TestHasTextPreedit < Test::Unit::TestCase
+
+  PREEDIT, COMMIT = Reflex::TextEvent::PREEDIT, Reflex::TextEvent::COMMIT
+
+  def view(*args)
+    Class.new(Reflex::View) {include Reflex::HasTextPreedit}.new(*args)
+  end
+
+  def event(*args)
+    Reflex::TextEvent.new(*args)
+  end
+
+  def test_initial_state()
+    v = view
+    assert_equal '', v.preedit
+    assert_nil       v.preedit_selection
+    assert_false     v.preedit?
+  end
+
+  def test_preedit()
+    v = view
+    v.on_text_preedit event(PREEDIT, 'こんにちは', 1, 2)
+    assert_equal 'こんにちは', v.preedit
+    assert_equal 1...3,        v.preedit_selection
+    assert_true                v.preedit?
+  end
+
+  def test_cancel()
+    v = view
+    v.on_text_preedit event(PREEDIT, 'こんにちは', 1, 2)
+    v.on_text_preedit event(PREEDIT, '', -1, 0)
+    assert_equal '', v.preedit
+    assert_nil       v.preedit_selection
+    assert_false     v.preedit?
+  end
+
+  def test_commit_clears_preedit()
+    v = view
+    v.on_text_preedit event(PREEDIT, 'こんにちは', 1, 2)
+    v.on_text_commit  event(COMMIT,  '今日は',    -1, 0)
+    assert_equal '', v.preedit
+    assert_nil       v.preedit_selection
+    assert_false     v.preedit?
+  end
+
+  def test_include_accepts_text_input()
+    assert_true view.accepts_text_input?
+  end
+
+end# TestHasTextPreedit

data/test/test_key_event.rb

@@ -3,10 +3,12 @@ require_relative 'helper'
 
 class TestKeyEvent < Test::Unit::TestCase
 
-  DOWN, UP = Reflex::KeyEvent::DOWN, Reflex::KeyEvent::UP
+  R = Reflex
+
+  DOWN, UP = R::KeyEvent::DOWN, R::KeyEvent::UP
 
   def event(*args)
-    Reflex::KeyEvent.new(*args)
+    R::KeyEvent.new(*args)
   end
 
   def test_initialize()
@@ -43,4 +45,23 @@ class TestKeyEvent < Test::Unit::TestCase
     assert_nil event(DOWN, nil, 1, 2, 3).chars
   end
 
+  def test_key()
+    assert_equal :a,    event(DOWN, 'a', R::KEY_A,    0, 0).key
+    assert_equal :f1,   event(DOWN, '',  R::KEY_F1,   0, 0).key
+    assert_equal :left, event(DOWN, '',  R::KEY_LEFT, 0, 0).key
+  end
+
+  def test_modifiers()
+    e = event DOWN, 'a', 1, R::MOD_CONTROL | R::MOD_CAPS, 0
+    assert_equal [:control],        e.modifiers
+    assert_equal [:control, :caps], e.modifiers(all: true)
+  end
+
+  def test_inspect()
+    hex_z = R::KEY_Z.to_s(16).upcase
+    assert_equal(
+      "#<Reflex::KeyEvent :down chars:'z' key:z code:0x#{hex_z} mod:[:control, :caps] repeat:2 captured?:false>",
+      event(DOWN, 'z', R::KEY_Z, R::MOD_CONTROL | R::MOD_CAPS, 2).inspect)
+  end
+
 end# TestKeyEvent