reflexion 0.6.0 → 0.7.0

data/test/test_menu.rb

@@ -125,22 +125,52 @@ class TestMenu < Test::Unit::TestCase
   def test_shortcut()
     m = menu
     m.shortcut_key = :s
-    assert_equal 's', m.shortcut_key
-    assert_equal [],  m.shortcut_modifiers
+    assert_equal :s, m.shortcut_key
+    assert_equal [], m.shortcut_modifiers
 
-    m.shortcut = [:c, :command]
-    assert_equal 'c',         m.shortcut_key
-    assert_equal [:command],  m.shortcut_modifiers
+    m.shortcut = [:c, :control]
+    assert_equal :c,          m.shortcut_key
+    assert_equal [:control],  m.shortcut_modifiers
+  end
+
+  def test_shortcut_key_symbol_roundtrip()
+    m = menu
+    # non-character keys are representable now (were impossible as strings)
+    m.shortcut_key = :f1
+    assert_equal :f1, m.shortcut_key
+    m.shortcut_key = :left
+    assert_equal :left, m.shortcut_key
+
+    # a KeyCode constant is also accepted directly
+    m.shortcut_key = Reflex::KEY_A
+    assert_equal :a, m.shortcut_key
+
+    # nil clears it
+    m.shortcut_key = nil
+    assert_nil m.shortcut_key
+  end
+
+  def test_shortcut_key_unknown_symbol_raises()
+    assert_raise(ArgumentError) {menu.shortcut_key = :nonexistent}
   end
 
   def test_shortcut_key_keeps_modifiers()
     m = menu
-    m.shortcut = [:c, :command, :shift]
-    assert_equal  'c',                   m.shortcut_key
-    assert_equal %i[command shift].sort, m.shortcut_modifiers.sort
+    m.shortcut = [:c, :control, :shift]
+    assert_equal :c,                     m.shortcut_key
+    assert_equal %i[control shift].sort, m.shortcut_modifiers.sort
     m.shortcut_key = :v
-    assert_equal     'v',                m.shortcut_key
-    assert_equal %i[command shift].sort, m.shortcut_modifiers.sort
+    assert_equal :v,                     m.shortcut_key
+    assert_equal %i[control shift].sort, m.shortcut_modifiers.sort
+  end
+
+  def test_shortcut_modifiers_unsupported_on_platform_raise()
+    if osx?
+      assert_raise(ArgumentError) {menu.shortcut_modifiers = [:win]}
+    elsif win32?
+      assert_raise(ArgumentError) {menu.shortcut_modifiers = [:command]}
+      assert_raise(ArgumentError) {menu.shortcut_modifiers = [:win]}
+    end
   end
 
   def test_image()

data/test/test_pointer.rb

@@ -3,22 +3,24 @@ require_relative 'helper'
 
 class TestPointer < Test::Unit::TestCase
 
-  TYPE_NONE = Reflex::Pointer::TYPE_NONE
-  MOUSE     = Reflex::Pointer::MOUSE
-  LEFT      = Reflex::Pointer::MOUSE_LEFT
-  RIGHT     = Reflex::Pointer::MOUSE_RIGHT
-  MIDDLE    = Reflex::Pointer::MOUSE_MIDDLE
-  TOUCH     = Reflex::Pointer::TOUCH
-  PEN       = Reflex::Pointer::PEN
-
-  ACTION_NONE = Reflex::Pointer::ACTION_NONE
-  DOWN        = Reflex::Pointer::DOWN
-  UP          = Reflex::Pointer::UP
-  MOVE        = Reflex::Pointer::MOVE
-  CANCEL      = Reflex::Pointer::CANCEL
-  ENTER       = Reflex::Pointer::ENTER
-  LEAVE       = Reflex::Pointer::LEAVE
-  STAY        = Reflex::Pointer::STAY
+  R = Reflex
+
+  TYPE_NONE = R::Pointer::TYPE_NONE
+  MOUSE     = R::Pointer::MOUSE
+  LEFT      = R::Pointer::MOUSE_LEFT
+  RIGHT     = R::Pointer::MOUSE_RIGHT
+  MIDDLE    = R::Pointer::MOUSE_MIDDLE
+  TOUCH     = R::Pointer::TOUCH
+  PEN       = R::Pointer::PEN
+
+  ACTION_NONE = R::Pointer::ACTION_NONE
+  DOWN        = R::Pointer::DOWN
+  UP          = R::Pointer::UP
+  MOVE        = R::Pointer::MOVE
+  CANCEL      = R::Pointer::CANCEL
+  ENTER       = R::Pointer::ENTER
+  LEAVE       = R::Pointer::LEAVE
+  STAY        = R::Pointer::STAY
 
   T = true
   F = false
@@ -28,8 +30,7 @@ class TestPointer < Test::Unit::TestCase
     position: 0, modifiers: 0, click_count: 0, drag: false,
     time: 0)
 
-    Reflex::Pointer.new(
-      id, types, action, position, modifiers, click_count, drag, time)
+    R::Pointer.new(id, types, action, position, modifiers, click_count, drag, time)
   end
 
   def test_initialize()
@@ -142,9 +143,9 @@ class TestPointer < Test::Unit::TestCase
   end
 
   def test_modifiers()
-    p = pointer modifiers: Reflex::MOD_SHIFT | Reflex::MOD_NUMPAD
-    assert_equal [:shift, :numpad], p.modifiers
-    assert_equal [:shift],          p.modifiers(locks: false)
+    p = pointer modifiers: R::MOD_SHIFT | R::MOD_NUMPAD
+    assert_equal [:shift],          p.modifiers
+    assert_equal [:shift, :numpad], p.modifiers(all: true)
   end
 
   def test_down()
@@ -156,8 +157,8 @@ class TestPointer < Test::Unit::TestCase
     assert_equal pointer, pointer
 
     assert_not_equal pointer, pointer(id:          1)
-    assert_not_equal pointer, pointer(types:       Reflex::Pointer::PEN)
-    assert_not_equal pointer, pointer(action:      Reflex::Pointer::UP)
+    assert_not_equal pointer, pointer(types:       R::Pointer::PEN)
+    assert_not_equal pointer, pointer(action:      R::Pointer::UP)
     assert_not_equal pointer, pointer(position:    2)
     assert_not_equal pointer, pointer(modifiers:   3)
     assert_not_equal pointer, pointer(click_count: 4)
@@ -165,4 +166,13 @@ class TestPointer < Test::Unit::TestCase
     assert_not_equal pointer, pointer(time:        5)
   end
 
+  def test_inspect()
+    assert_equal(
+      '#<Reflex::Pointer id:1 [:mouse, :mouse_left] :up (2.0, 3.0) mod:[:shift, :control] click:5 drag:true time:4.0>',
+      pointer(
+        id: 1, types: MOUSE | LEFT, action: UP, position: [2, 3], modifiers: 6,
+        click_count: 5, drag: true, time: 4
+      ).inspect)
+  end
+
 end# TestPointer

data/test/test_pointer_event.rb

@@ -3,16 +3,20 @@ require_relative 'helper'
 
 class TestPointerEvent < Test::Unit::TestCase
 
-  TYPE_NONE = Reflex::Pointer::TYPE_NONE
-  TOUCH     = Reflex::Pointer::TOUCH
-  PEN       = Reflex::Pointer::PEN
+  R = Reflex
 
-  ACTION_NONE = Reflex::Pointer::ACTION_NONE
-  DOWN        = Reflex::Pointer::DOWN
-  UP          = Reflex::Pointer::UP
+  TYPE_NONE = R::Pointer::TYPE_NONE
+  MOUSE     = R::Pointer::MOUSE
+  LEFT      = R::Pointer::MOUSE_LEFT
+  TOUCH     = R::Pointer::TOUCH
+  PEN       = R::Pointer::PEN
+
+  ACTION_NONE = R::Pointer::ACTION_NONE
+  DOWN        = R::Pointer::DOWN
+  UP          = R::Pointer::UP
 
   def event(*args, **kwargs)
-    Reflex::PointerEvent.new(*args, **kwargs)
+    R::PointerEvent.new(*args, **kwargs)
   end
 
   def pointer(
@@ -20,8 +24,7 @@ class TestPointerEvent < Test::Unit::TestCase
     position: 0, modifiers: 0, click_count: 0, drag: false,
     time: 0)
 
-    Reflex::Pointer.new(
-      id, type, action, position, modifiers, click_count, drag, time)
+    R::Pointer.new(id, type, action, position, modifiers, click_count, drag, time)
   end
 
   def test_initialize()
@@ -89,4 +92,16 @@ class TestPointerEvent < Test::Unit::TestCase
     assert_nil       e[-4]
   end
 
+  def test_inspect()
+    assert_equal(
+      "#<Reflex::PointerEvent id:1 [:mouse, :mouse_left] :down (2.0, 3.0) mod:[:shift, :control] click:5 drag:true time:4.0>",
+      event(
+        pointer(
+          id: 1, type: MOUSE | LEFT, action: DOWN,
+          position: [2, 3], modifiers: 6, drag: true, click_count: 5,
+          time: 4),
+        pointer(id: 10, type: TOUCH, action: UP)
+      ).inspect)
+  end
+
 end# TestPointerEvent

data/test/test_reflex.rb

@@ -0,0 +1,36 @@
+require_relative 'helper'
+
+
+class TestReflex < Test::Unit::TestCase
+
+  R = Reflex
+
+  def test_all_keys_have_symbol()
+    R::KEYS.each do |key|
+      assert_not_nil R.get_key_symbol!(key), "no symbol for keycode 0x%X" % key
+    end
+  end
+
+  def test_all_keys_are_on_this_platform()
+    R::KEYS.each do |key|
+      assert_operator key, :>=, 0, "keycode 0x%X is not on this platform" % key
+    end
+  end
+
+  def test_unsided_modifiers_have_symbol()
+    omit 'no command or option key here' unless Xot.osx? || Xot.win32?
+    assert_equal :command, R.get_key_symbol!(R::KEY_COMMAND)
+    assert_equal :option,  R.get_key_symbol!(R::KEY_OPTION)
+  end
+
+  def test_key_symbol_representative()
+    # Several keycodes share one symbol; the reverse lookup returns the
+    # first-defined keycode (KEY_SHIFT is listed before KEY_LSHIFT/KEY_RSHIFT).
+    assert_equal :shift, R.get_key_symbol!(R::KEY_SHIFT)
+    assert_equal :shift, R.get_key_symbol!(R::KEY_LSHIFT)
+    assert_equal :shift, R.get_key_symbol!(R::KEY_RSHIFT)
+
+    assert_equal R::KEY_SHIFT, R::KEYS.find {:shift == R.get_key_symbol!(_1)}
+  end
+
+end# TestReflex

data/test/test_screen.rb

@@ -3,12 +3,34 @@ require_relative 'helper'
 
 class TestScreen < Test::Unit::TestCase
 
+  include HasWindow
+
+  R = Reflex
+  S = R::Screen
+
   def screen()
-    Reflex::Window.new.screen
+    window.screen
   end
 
   def test_initialize()
-    assert_raise(Reflex::ReflexError) {Reflex::Screen.new}
+    assert_raise(R::ReflexError) {S.new}
+  end
+
+  def test_name()
+    S.all.each {assert_kind_of String, _1.name}
+  end
+
+  def test_pixel_density()
+    S.all.each {assert_operator _1.pixel_density, :>=, 1}
+  end
+
+  def test_all()
+    all = S.all
+    assert_true all.all? {_1.is_a? S}
+
+    omit 'no screen here' if all.empty?
+
+    assert_equal [0, 0], all.first.frame.position.to_a(2)
   end
 
 end# TestScreen

data/test/test_snap_constraint.rb

@@ -3,9 +3,7 @@ require_relative 'helper'
 
 class TestSnapConstraint < Test::Unit::TestCase
 
-  def window()
-    Reflex::Window.new
-  end
+  include HasWindow
 
   def view(x = 0, y = 0, w = 50, h = 50, **options, &block)
     Reflex::View.new(

data/test/test_text_event.rb

@@ -0,0 +1,54 @@
+# -*- coding: utf-8 -*-
+require_relative 'helper'
+
+
+class TestTextEvent < Test::Unit::TestCase
+
+  PREEDIT, COMMIT = Reflex::TextEvent::PREEDIT, Reflex::TextEvent::COMMIT
+
+  def event(*args)
+    Reflex::TextEvent.new(*args)
+  end
+
+  def test_initialize()
+    assert_equal :preedit, event(PREEDIT, 'あ', 1, 2).action
+    assert_equal 'あ',     event(PREEDIT, 'あ', 1, 2).text
+    assert_equal 1...3,    event(PREEDIT, 'あ', 1, 2).selection
+  end
+
+  def test_dup()
+    assert_equal :preedit, event(PREEDIT, 'あ', 1, 2).dup.action
+    assert_equal 'あ',     event(PREEDIT, 'あ', 1, 2).dup.text
+    assert_equal 1...3,    event(PREEDIT, 'あ', 1, 2).dup.selection
+
+    e1 = event PREEDIT, 'あ', 1, 2
+    e2 = e1.dup
+    e1.block
+    e3 = e1.dup
+    assert_true  e1.blocked?
+    assert_false e2.blocked?
+    assert_true  e3.blocked?
+  end
+
+  def test_preedit_commit()
+    assert_true  event(PREEDIT, 'あ', 1, 2).preedit?
+    assert_false event(PREEDIT, 'あ', 1, 2).commit?
+    assert_false event(COMMIT,  'あ', 1, 2).preedit?
+    assert_true  event(COMMIT,  'あ', 1, 2).commit?
+  end
+
+  def test_text()
+    assert_equal '',              event(PREEDIT, '',  1, 2).text
+    assert_equal '',              event(PREEDIT, nil, 1, 2).text
+    assert_equal Encoding::UTF_8, event(PREEDIT, 'あいう', 1, 2).text.encoding
+    assert_equal 3,               event(PREEDIT, 'あい😁', 1, 2).text.size
+  end
+
+  def test_selection()
+    assert_nil                      event(PREEDIT, 'あいうえ', -1, 0).selection
+    assert_equal 0...0,             event(PREEDIT, 'あいうえ',  0, 0).selection
+    assert_equal 1...1,             event(PREEDIT, 'あいうえ',  1, 0).selection
+    assert_equal 'いう', 'あいうえ'[event(PREEDIT, 'あいうえ',  1, 2).selection]
+  end
+
+end# TestTextEvent

data/test/test_view.rb

@@ -3,14 +3,12 @@ require_relative 'helper'
 
 class TestView < Test::Unit::TestCase
 
+  include HasWindow
+
   def view(*a, **k, &b)
     Reflex::View.new(*a, **k, &b)
   end
 
-  def window(*a, **k, &b)
-    Reflex::Window.new(*a, **k, &b)
-  end
-
   def style(*a, **k, &b)
     Reflex::Style.new(*a, **k, &b)
   end
@@ -486,6 +484,45 @@ class TestView < Test::Unit::TestCase
     v.capture += [];                      assert_equal [],                      v.capture
   end
 
+  def test_accepts_text_input()
+    assert_false view                                             .accepts_text_input?
+    assert_true  view.tap {_1.text_input = true}                  .accepts_text_input?
+    assert_true  view.tap {_1.text_input = true;  _1.on(:text) {}}.accepts_text_input?
+    assert_false view.tap {_1.text_input = false}                 .accepts_text_input?
+    assert_false view.tap {_1.text_input = false; _1.on(:text) {}}.accepts_text_input?
+    assert_false view.tap {_1.text_input = nil}                   .accepts_text_input?
+    assert_true  view.tap {_1.text_input = nil;   _1.on(:text) {}}.accepts_text_input?
+
+    new_class = -> hook = nil {
+      Class.new(Reflex::View) {define_method(hook) {|*|} if hook}
+    }
+
+    assert_true  new_class.call(:on_text).new          .accepts_text_input?
+    assert_false new_class.call(:on_text).new.hide     .accepts_text_input?
+    assert_true  new_class.call(:on_text).new.hide.show.accepts_text_input?
+
+    %w[on_text on_text_preedit on_text_commit].each do |hook|
+      on_less = hook.sub 'on_', ''
+      assert_true new_class.call(hook).new        .accepts_text_input?, hook
+      assert_true view.tap {_1.on(on_less)  {|*|}}.accepts_text_input?, hook
+      assert_true view.tap {_1.before(hook) {|*|}}.accepts_text_input?, hook
+      assert_true view.tap {_1.after(hook)  {|*|}}.accepts_text_input?, hook
+    end
+  end
+
+  def test_text_input()
+    v            = view;  assert_nil   v.text_input
+    v.text_input = true;  assert_true  v.text_input
+    v.text_input = false; assert_false v.text_input
+    v.text_input = nil;   assert_nil   v.text_input
+  end
+
+  def test_text_input_bounds()
+    v = view
+    v.frame = [10, 20, 30, 40]
+    assert_equal Reflex::Bounds.new(0, 0, 30, 40), v.text_input_bounds
+  end
+
   def test_capturing()
     v, w = view, window
     w.add v

data/test/test_wheel_constraint.rb

@@ -3,9 +3,7 @@ require_relative 'helper'
 
 class TestWheelConstraint < Test::Unit::TestCase
 
-  def window()
-    Reflex::Window.new
-  end
+  include HasWindow
 
   def view(x = 0, y = 0, w = 50, h = 50, **options, &block)
     Reflex::View.new(

data/test/test_wheel_event.rb

@@ -3,8 +3,10 @@ require_relative 'helper'
 
 class TestWheelEvent < Test::Unit::TestCase
 
+  R = Reflex
+
   def event(*args)
-    Reflex::WheelEvent.new(*args)
+    R::WheelEvent.new(*args)
   end
 
   def point(*args)
@@ -19,7 +21,7 @@ class TestWheelEvent < Test::Unit::TestCase
     assert_equal 4,                        e.dx
     assert_equal 5,                        e.dy
     assert_equal 6,                        e.dz
-    assert_equal [:alt, :control, :shift], e.modifiers
+    assert_equal [:shift, :control, :alt], e.modifiers
     assert_equal point(1, 2, 3),           e. position
     assert_equal point(4, 5, 6),           e.dposition
   end
@@ -35,9 +37,15 @@ class TestWheelEvent < Test::Unit::TestCase
   end
 
   def test_modifiers()
-    e = event 0, 0, 0, 0, 0, 0, Reflex::MOD_CONTROL | Reflex::MOD_SCROLL
-    assert_equal [:control, :scroll], e.modifiers
-    assert_equal [:control],          e.modifiers(locks: false)
+    e = event 0, 0, 0, 0, 0, 0, R::MOD_CONTROL | R::MOD_SCROLL
+    assert_equal [:control],          e.modifiers
+    assert_equal [:control, :scroll], e.modifiers(all: true)
+  end
+
+  def test_inspect()
+    assert_equal(
+      "#<Reflex::WheelEvent x:1.0 y:2.0 z:3.0 dx:4.0 dy:5.0 dz:6.79 mod:[:control, :scroll]>",
+      event(1, 2, 3, 4, 5, 6.789, R::MOD_CONTROL | R::MOD_SCROLL).inspect)
   end
 
 end# TestWheelEvent