shoes 4.0.0.pre1 → 4.0.0.pre2

data/spec/swt_shoes/input_box_spec.rb

@@ -1,110 +0,0 @@
-require 'swt_shoes/spec_helper'
-
-describe Shoes::Swt::InputBox do
-  include_context "swt app"
-
-  let(:dsl) { double('dsl', app: shoes_app, visible?: true, element_width: 80,
-                            element_height: 22, initial_text: 'Jay',
-                            secret?: secret).as_null_object }
-  let(:real) { double('real', disposed?: false, text: text).as_null_object }
-  let(:styles) {::Swt::SWT::SINGLE | ::Swt::SWT::BORDER}
-  let(:secret) {false}
-  let(:text) {'Some text...'}
-
-  subject { Shoes::Swt::InputBox.new dsl, parent, styles }
-
-  before :each do
-    ::Swt::Widgets::Text.stub(:new) { real }
-    ::Swt::Widgets::Text.stub(:text=) { real }
-  end
-
-  it_behaves_like "movable element"
-  it_behaves_like "clearable native element"
-  it_behaves_like "togglable"
-
-  describe "#initialize" do
-    let(:event) {double 'Event', source: source}
-    let(:source) {double 'Source'}
-    it "sets text on real element" do
-      subject.text = "some text"
-      expect(real).to have_received(:text=).with("some text")
-    end
-
-    describe 'change listeners' do
-
-      it "should set up a listener that delegates change events" do
-        expect(dsl).to receive(:call_change_listeners)
-        expect(real).to receive(:add_modify_listener) do |&blk|
-          blk.call(event)
-        end
-        subject
-      end
-
-      describe 'modify block' do
-        before :each do
-          @modify_block = nil
-          expect(real).to receive(:add_modify_listener) do |&blk|
-            @modify_block = blk
-          end
-          subject
-        end
-
-        it 'normally calls the dsl change listeners' do
-          @modify_block.call event
-
-          expect(dsl).to have_received :call_change_listeners
-        end
-
-        describe 'with the same text' do
-          let(:event) {double 'Bad Event', source: source,
-                              class: Java::OrgEclipseSwtEvents::ModifyEvent}
-          let(:source) {double 'Our source',
-                               class: Java::OrgEclipseSwtWidgets::Text,
-                               text: text}
-          let(:text) {'Double call'}
-          it 'does not call the change listeners' do
-            subject.text = text
-            @modify_block.call event
-            expect(dsl).to_not have_received :call_change_listeners
-          end
-        end
-
-      end
-    end
-  end
-
-  describe 'text selections' do
-    it 'translates the highlight_text call' do
-      subject.highlight_text 4, 20
-      expect(real).to have_received(:set_selection).with(4, 20)
-    end
-
-    it 'translates the caret_to call' do
-      subject.caret_to 42
-      expect(real).to have_received(:set_selection).with(42)
-    end
-  end
-
-  describe Shoes::Swt::EditLine do
-    subject {Shoes::Swt::EditLine.new dsl, parent}
-    describe ":secret option" do
-      context "when NOT set" do
-        it "does NOT set PASSWORD style" do
-          options = Shoes::Swt::EditLine::DEFAULT_STYLES
-          dsl.stub(:secret?) { false }
-          expect(::Swt::Widgets::Text).to receive(:new).with(parent.real, options)
-          subject
-        end
-      end
-
-      context "when set" do
-        it "sets PASSWORD style" do
-          options = Shoes::Swt::EditLine::DEFAULT_STYLES | ::Swt::SWT::PASSWORD
-          dsl.stub(:secret?) { true }
-          expect(::Swt::Widgets::Text).to receive(:new).with(parent.real, options)
-          subject
-        end
-      end
-    end
-  end
-end

data/spec/swt_shoes/integration_spec.rb

@@ -1,18 +0,0 @@
-require 'swt_shoes/spec_helper'
-
-describe Shoes::App do
-  before :each do
-    # The stubs that are unstubbed here occur in the spec_helper
-    # error not triggered with a stubbed flush (removing the stub overall
-    # seemed to difficult after initial try)
-    Shoes::Swt::App.any_instance.unstub(:flush)
-    Shoes::Swt::RedrawingAspect.unstub :new
-  end
-
-  it 'does not fail with just a simple para #574' do
-    expect do
-      app = Shoes.app do para 'me no fail' end
-      app.quit
-    end.not_to raise_error
-  end
-end

data/spec/swt_shoes/key_listener_spec.rb

@@ -1,320 +0,0 @@
-# encoding: UTF-8
-require 'swt_shoes/spec_helper'
-
-describe Shoes::Swt::Keypress do
-  let(:app) { double('app', add_key_listener: nil) }
-  let(:dsl) { double('dsl') }
-  let(:block) { proc{ |key| key} }
-  let(:key_listener) {Shoes::Swt::Keypress.new(dsl, app, &block)}
-
-  describe '.get_swt_constant' do
-    it 'gets the swt constant' do
-      expect(Shoes::Swt::KeyListener.get_swt_constant("TAB")).to eq ::Swt::SWT::TAB
-    end
-  end
-
-  describe "subclasses" do
-
-    describe "Subclass Keypress" do
-      it "adds key listener on creation" do
-        app.should_receive(:add_key_listener)
-        Shoes::Swt::Keypress.new dsl, app, &block
-      end
-    end
-
-    describe "Subclass Keyrelease" do
-      it "adds key listener on creation" do
-        app.should_receive(:add_key_listener)
-        Shoes::Swt::Keyrelease.new dsl, app, &block
-      end
-    end
-  end
-
-  CTRL = ::Swt::SWT::CTRL
-  ALT = ::Swt::SWT::ALT
-  SHIFT = ::Swt::SWT::SHIFT
-
-  subject {key_listener}
-
-  def test_character_press(character, state_modifier = 0, result_char = character)
-    expect(block).to receive(:call).with(result_char)
-    event = double  character: character.ord,
-                  stateMask: 0 | state_modifier,
-                  keyCode: character.downcase.ord
-    subject.handle_key_event(event)
-  end
-
-  def test_alt_character_press(character, state_mask_modifier = 0)
-    state_modifier = ALT | state_mask_modifier
-    result = ('alt_' + character).to_sym
-    test_character_press(character, state_modifier, result)
-  end
-
-
-  describe 'works with simple keys such as' do
-    it '"a"' do
-      test_character_press 'a'
-    end
-
-    it '"1"' do
-      test_character_press '1'
-    end
-
-    it '"$"' do
-      test_character_press '$'
-    end
-
-    it 'handles UTF-8 (œ)' do
-      test_character_press 'œ'
-    end
-  end
-
-  describe 'works with shift key pressed such as' do
-    def test_shift_character_press(character)
-      state_modifier = SHIFT
-      test_character_press(character, state_modifier)
-    end
-
-    it '"A"' do
-      test_shift_character_press "A"
-    end
-
-    it '"Z"' do
-      test_shift_character_press "Z"
-    end
-  end
-
-  describe 'works with alt key pressed such as' do
-    it ':alt_a' do
-      test_alt_character_press 'a'
-    end
-
-    it ':alt_z' do
-      test_alt_character_press 'z'
-    end
-
-    it ':alt_/' do
-      test_alt_character_press '/'
-    end
-
-    it 'works with what Macs seem to produce for opt + / (should be alt_/)' do
-      expect(block).to receive(:call).with(:'alt_/')
-      event = double  character: '÷'.ord,
-                      stateMask: ALT,
-                      keyCode: '/'.ord
-      subject.handle_key_event(event)
-    end
-  end
-
-  describe 'works with the ctrl key pressed such as' do
-    def test_ctrl_character_press(character, modifier = 0)
-      result_char = ('control_' + character).to_sym
-      expect(block).to receive(:call).with(result_char)
-      event = double character: 'something weird like \x00',
-                     stateMask: CTRL | modifier,
-                     keyCode:   character.downcase.ord
-      subject.handle_key_event(event)
-    end
-
-    it ':ctrl_a' do
-      test_ctrl_character_press 'a'
-    end
-
-    it 'ctrl_z' do
-      test_ctrl_character_press 'z'
-    end
-
-    describe 'and if we add the shift key' do
-      it ':ctrl_A' do
-        test_ctrl_character_press 'A', SHIFT
-      end
-
-      it ':ctrl_Z' do
-        test_ctrl_character_press 'Z', SHIFT
-      end
-    end
-  end
-
-  describe 'works with shift combined with alt yielding capital letters' do
-    def test_alt_shift_character_press(character)
-      test_alt_character_press(character, SHIFT)
-    end
-
-    it ':alt_A' do
-      test_alt_shift_character_press 'A'
-    end
-
-    it ':alt_Z' do
-      test_alt_shift_character_press 'Z'
-    end
-  end
-
-  describe 'only modifier keys yield nothing' do
-    def test_receive_nothing_with_modifier(modifier, last_key_press = modifier)
-      expect(block).not_to receive :call
-      event = double stateMask: modifier, keyCode: last_key_press, character: 0
-      subject.handle_key_event(event)
-    end
-
-    it 'shift' do
-      test_receive_nothing_with_modifier SHIFT
-    end
-
-    it 'alt' do
-      test_receive_nothing_with_modifier ALT
-    end
-
-    it 'control' do
-      test_receive_nothing_with_modifier CTRL
-    end
-
-    it 'shift + ctrl' do
-      test_receive_nothing_with_modifier SHIFT | CTRL, SHIFT
-    end
-
-    it 'ctrl + alt' do
-      test_receive_nothing_with_modifier CTRL | ALT, CTRL
-    end
-
-    it 'shift + ctrl + alt' do
-      test_receive_nothing_with_modifier CTRL | SHIFT | ALT, ALT
-    end
-  end
-
-  describe 'special keys' do
-
-    ARROW_LEFT = ::Swt::SWT::ARROW_LEFT
-
-    def special_key_test(code, expected, modifier = 0)
-      expect(block).to receive(:call).with(expected)
-      event = double stateMask: modifier,
-                   keyCode: code,
-                   character: 0
-      subject.handle_key_event(event)
-    end
-
-    it '"\n"' do
-      special_key_test(::Swt::SWT::CR, "\n")
-    end
-
-    it ':left' do
-      special_key_test ARROW_LEFT, :left
-    end
-
-    it ':f1' do
-      special_key_test ::Swt::SWT::F1, :f1
-    end
-
-    it ':tab' do
-      special_key_test ::Swt::SWT::TAB, :tab
-    end
-
-    it ':delete' do
-      special_key_test ::Swt::SWT::DEL, :delete
-    end
-
-    describe 'with modifier' do
-      it ':alt_left' do
-        special_key_test ARROW_LEFT, :alt_left, ALT
-      end
-
-      it ':control_left' do
-        special_key_test ARROW_LEFT, :control_left, CTRL
-      end
-
-      it ':shift_left' do
-        special_key_test ARROW_LEFT, :shift_left, SHIFT
-      end
-
-      it ':control_alt_home' do
-        special_key_test ::Swt::SWT::HOME, :control_alt_home, ALT | CTRL
-      end
-
-      it ':control_shift_home' do
-        special_key_test ::Swt::SWT::HOME,
-                         :control_shift_alt_home,
-                         ALT | CTRL | SHIFT
-      end
-    end
-  end
-
-  describe 'Mac command key' do
-    it 'fixes crash of shift option command #584' do
-      event = double 'key event', stateMask: 196608,
-                                  keyCode: 4194304,
-                                  character: "don't care atm"
-      expect {subject.handle_key_event(event)}.not_to raise_error
-    end
-  end
-
-  describe '#ignore_event?' do
-
-    let(:character) {'a'}
-    let(:event) {double 'key event',
-                        widget: widget,
-                        stateMask: 0,
-                        keyCode:  keyCode,
-                        character: character.ord }
-    let(:shell){Java::OrgEclipseSwtWidgets::Shell.new}
-    let(:style) {0}
-    let(:keyCode) {character.downcase.ord}
-
-
-    subject{key_listener.ignore_event? event}
-
-    shared_examples_for 'ignores space and enter' do
-      describe 'with a space' do
-        let(:character) {' '}
-        it {should be_true}
-      end
-
-      describe 'with enter' do
-        let(:keyCode) {::Swt::SWT::CR}
-        it {should be_true}
-      end
-    end
-
-    shared_examples_for 'accepts normal characters' do
-      describe 'with a normal character' do
-        let(:character) {'a'}
-        it{should be_false}
-      end
-    end
-
-    context 'on a Shell' do
-      let(:widget){shell}
-      it {should be_false}
-
-      describe 'even with enter' do
-        let(:keyCode) {::Swt::SWT::CR}
-        it {should be_false}
-      end
-    end
-
-    context 'on a Text' do
-      let(:widget){Java::OrgEclipseSwtWidgets::Text.new(shell, style)}
-      it {should be_true}
-    end
-
-    context 'on a button' do
-      let(:widget) {Java::OrgEclipseSwtWidgets::Button.new(shell, style)}
-
-      it_behaves_like 'ignores space and enter'
-      it_behaves_like 'accepts normal characters'
-    end
-
-    context 'on a Combo' do
-      let(:widget) {Java::OrgEclipseSwtWidgets::Combo.new(shell, style)}
-
-      it_behaves_like 'ignores space and enter'
-
-      describe 'with up' do
-        let(:keyCode) {::Swt::SWT::ARROW_UP}
-        it{should be_true}
-      end
-
-      it_behaves_like 'accepts normal characters'
-    end
-  end
-
-end

data/spec/swt_shoes/line_spec.rb

@@ -1,43 +0,0 @@
-require 'swt_shoes/spec_helper'
-
-describe Shoes::Swt::Line do
-  include_context "swt app"
-
-  let(:container) { double('container', :disposed? => false).as_null_object }
-  let(:dsl) { Shoes::Line.new shoes_app, parent, point_a, point_b }
-  let(:point_a) { Shoes::Point.new(10, 100) }
-  let(:point_b) { Shoes::Point.new(300, 10) }
-
-  subject {
-    Shoes::Swt::Line.new(dsl, swt_app)
-  }
-
-  context "#initialize" do
-    it { should be_instance_of(Shoes::Swt::Line) }
-    its(:dsl) { should be(dsl) }
-  end
-
-  it_behaves_like "paintable"
-  it_behaves_like "togglable"
-
-  it {should respond_to :clear}
-
-  describe "painter" do
-    include_context "painter context"
-
-    let(:shape) { Shoes::Swt::Line.new(dsl, swt_app) }
-    subject { Shoes::Swt::Line::Painter.new(shape) }
-
-    before(:each) do
-      dsl.stub(positioned?: true)
-    end
-
-    it_behaves_like "stroke painter"
-
-    specify "draws line" do
-      # coords as if drawn in box at (0,0)
-      gc.should_receive(:draw_line).with(0, 90, 290, 0)
-      subject.paint_control(event)
-    end
-  end
-end