shoes-swt 4.0.0.pre2

data/spec/swt_shoes/shared_examples/paintable.rb

@@ -0,0 +1,7 @@
+shared_examples_for "paintable" do
+  it "registers for painting" do
+    expect(swt_app).to receive(:add_paint_listener)
+    subject
+  end
+end
+

data/spec/swt_shoes/shared_examples/painter.rb

@@ -0,0 +1,83 @@
+# Provide `shape` (a double) and `subject` (a Painter)
+
+shared_context "painter context" do
+  let(:event) { double("event", :gc => gc) }
+  let(:gc) { double("gc", :get_line_width => sw).as_null_object }
+  let(:fill) { Shoes::Swt::Color.new(Shoes::Color.new(11, 12, 13, fill_alpha)) }
+  let(:stroke) { Shoes::Swt::Color.new(Shoes::Color.new(111, 112, 113, stroke_alpha)) }
+  let(:fill_alpha) { 70 }
+  let(:stroke_alpha) { 110 }
+  let(:sw) { 10 }
+
+  before :each do
+    allow(shape).to receive(:fill) { fill }
+    allow(shape).to receive(:fill_alpha) { fill_alpha }
+    allow(shape).to receive(:stroke) { stroke }
+    allow(shape).to receive(:stroke_alpha) { stroke_alpha }
+    allow(subject).to receive(:reset_rotate) { double("reset_rotate").as_null_object }
+  end
+end
+
+
+shared_examples_for "movable painter" do
+  describe "when moved" do
+    let(:transform) { double("transform").as_null_object }
+
+    before :each do
+      allow(::Swt::Transform).to receive(:new) { transform }
+      shape.update_position
+    end
+
+    it "applies transform" do
+      expect(gc).to receive(:set_transform).with(transform)
+      subject.paint_control(event)
+    end
+  end
+end
+
+shared_examples_for "stroke painter" do
+  describe "sets stroke" do
+    specify "color" do
+      expect(gc).to receive(:set_foreground).with(stroke.real)
+      subject.paint_control(event)
+    end
+
+    specify "alpha" do
+      allow(gc).to receive(:set_alpha)
+      expect(gc).to receive(:set_alpha).with(stroke_alpha)
+      subject.paint_control(event)
+    end
+  end
+
+  it "sets strokewidth" do
+    allow(shape).to receive(:strokewidth) { 4 }
+    expect(gc).to receive(:set_line_width).with(4)
+    subject.paint_control(event)
+  end
+
+  it "sets antialias" do
+    expect(gc).to receive(:set_antialias).with(Swt::SWT::ON)
+    subject.paint_control(event)
+  end
+
+  it "sets line cap" do
+    expect(gc).to receive(:set_line_cap).with(anything)
+    subject.paint_control(event)
+  end
+end
+
+shared_examples_for "fill painter" do
+  describe "sets fill" do
+    specify "color" do
+      expect(gc).to receive(:set_background).with(fill.real)
+      subject.paint_control(event)
+    end
+
+    specify "alpha" do
+      # Once for stroke, once for fill
+      allow(gc).to receive(:set_alpha)
+      expect(gc).to receive(:set_alpha).with(fill_alpha)
+      subject.paint_control(event)
+    end
+  end
+end

data/spec/swt_shoes/shared_examples/pattern.rb

@@ -0,0 +1,32 @@
+shared_examples_for "an swt pattern" do
+  it { is_expected.to respond_to(:apply_as_stroke) }
+  it { is_expected.to respond_to(:apply_as_fill) }
+
+  describe "#apply_as_stroke" do
+    let(:gc) { double("graphics context") }
+    let(:left) { 0 }
+    let(:top) { 0 }
+    let(:width) { 10 }
+    let(:height) { 10 }
+
+    it "sets foreground" do
+      if subject.is_a? Shoes::Swt::Color
+        allow(gc).to receive(:set_alpha)
+        expect(gc).to receive(:set_foreground)
+      else
+        expect(gc).to receive(:set_foreground_pattern)
+      end
+      subject.apply_as_stroke(gc, left, top, width, height)
+    end
+
+    it "sets alpha" do
+      if subject.is_a? Shoes::Swt::Color
+        allow(gc).to receive(:set_foreground)
+        expect(gc).to receive(:set_alpha)
+      else
+        expect(gc).to receive(:set_foreground_pattern)
+      end
+      subject.apply_as_stroke(gc, left, top, width, height)
+    end
+  end
+end

data/spec/swt_shoes/shared_examples/removable.rb

@@ -0,0 +1,41 @@
+shared_examples_for "removable" do
+  it "should respond to remove" do
+    expect(subject).to respond_to :remove
+  end
+
+  it "should remove paint listener" do
+    expect(swt_app).to receive(:remove_paint_listener)
+    expect(swt_app).to receive(:remove_listener).at_least(2).times
+    subject.remove
+  end
+
+  it "disposes color factory if present" do
+    swt_app.as_null_object
+
+    color_factory = double("color factory")
+    expect(color_factory).to receive(:dispose)
+    subject.instance_variable_set(:@color_factory, color_factory)
+
+    subject.remove
+  end
+end
+
+shared_examples_for "removable native element" do
+  it "should respond to remove" do
+    expect(subject).to respond_to :remove
+  end
+
+  it "should dispose real when real is not disposed" do
+    allow(swt_app).to receive(:remove_listener)
+    allow(real).to receive(:disposed?) { false }
+    expect(real).to receive(:dispose)
+    subject.remove
+  end
+
+  it "should not dispose real when real is already disposed" do
+    allow(swt_app).to receive(:remove_listener)
+    allow(real).to receive(:disposed?) { true }
+    expect(real).not_to receive(:dispose)
+    subject.remove
+  end
+end

data/spec/swt_shoes/shared_examples/swt_app_context.rb

@@ -0,0 +1,23 @@
+# This is a common context for running Shoes::Swt specs.
+#   - parent:    use for instantiating a Shoes::Swt object
+#   - swt_app:   use for instantiating a Shoes::Swt object
+#   - shoes_app: use for instantiating a Shoes DSL object
+shared_context "swt app" do
+  let(:swt_app_real) { double('swt app real', disposed?: false,
+                              set_visible: true) }
+  let(:clickable_element) { double("clickable_element", delete: nil) }
+  let(:swt_app) do
+    swt_double = double('swt app', real: swt_app_real, disposed?: false,
+                         add_paint_listener: true, remove_paint_listener: true,
+                         add_clickable_element: true, add_listener: true, remove_listener: true,
+                         flush: true, redraw: true, clickable_elements: clickable_element)
+    allow(swt_double).to receive(:app).and_return(swt_double)
+    swt_double
+  end
+  let(:shoes_app) { double('shoes app', gui: swt_app, rotate: 0, style: {}, element_styles: {}) }
+  let(:parent) { double('parent', app: swt_app, add_child: true, real: true) }
+  let(:parent_dsl) {double("parent dsl", add_child: true, contents: [],
+                           gui: parent, x_dimension: double.as_null_object,
+                           y_dimension: double.as_null_object)}
+end
+

data/spec/swt_shoes/shared_examples/visibility.rb

@@ -0,0 +1,15 @@
+shared_examples_for "updating visibility" do
+  it "triggers redrawing on the app" do
+    with_redraws do
+      expect(swt_app).to receive(:redraw)
+      subject.update_visibility
+    end
+  end
+
+  it "passes visibility to real object" do
+    if subject.respond_to?(:gui) && subject.gui.respond_to?(:real)
+      expect(subject.gui.real).to receive(:set_visible)
+      subject.update_visibility
+    end
+  end
+end

data/spec/swt_shoes/shell_control_listener_spec.rb

@@ -0,0 +1,23 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::ShellControlListener do
+  let(:app) {double 'SWT App', dsl: dsl_app, shell: shell, real: real}
+  let(:shell) {double('Shell').as_null_object}
+  let(:resize_callbacks) {[]}
+  let(:dsl_app) {double('DSL App', resize_callbacks: resize_callbacks).as_null_object}
+  let(:block) {double 'Block', call: nil}
+  let(:resize_event) {double'resize_event', widget: shell}
+  let(:real) {double('Swt Real').as_null_object}
+
+  subject {Shoes::Swt::ShellControlListener.new(app)}
+  before :each do
+    subject.controlResized(resize_event)
+  end
+  
+  describe 'resize' do
+    let(:resize_callbacks ){[block]}
+    it 'calls the resize block' do
+      expect(block).to have_received(:call) 
+    end
+  end
+end

data/spec/swt_shoes/slot_spec.rb

@@ -0,0 +1,24 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Slot do
+  include_context "swt app"
+  let(:dsl) {instance_double Shoes::Slot, hidden?: true,
+                             visible?: false, contents: [content] }
+  let(:content) {double 'content', show: true, hide: true}
+
+  subject {Shoes::Swt::Slot.new dsl, swt_app}
+
+  describe '#update_visibility' do
+    it 'does not set visibility on the parent #904' do
+      subject.update_visibility
+      expect(swt_app.real).not_to have_received(:set_visible)
+    end
+
+    # spec may be deleted if we can hide slots as a whole and not each element
+    # on its own
+    it 'tries to hide the content' do
+      subject.update_visibility
+      expect(content).to have_received :hide
+    end
+  end
+end

data/spec/swt_shoes/sound.rb

@@ -0,0 +1,10 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Sound do
+  let(:dsl) { double('dsl') }
+  let(:filepath) { double('filepath') }
+  subject { Shoes::Swt::Sound.new(dsl, filepath) }
+
+  its(:dsl) { is_expected.to be(parent) }
+  its(:filepath) { is_expected.to be(filepath) }
+end

data/spec/swt_shoes/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'code_coverage'
+require "shoes/swt"
+require "spec_helper"
+
+RSpec.configure do |config|
+  config.before(:each) do
+    allow(Swt).to receive(:event_loop)
+    allow_any_instance_of(Shoes::Swt::App).to receive_messages(flush: true)
+    allow_any_instance_of(Swt::Widgets::Shell).to receive(:open)
+    allow_any_instance_of(Swt::Widgets::MessageBox).to receive(:open)
+    # stubbed as otherwise all sorts of callbacks are added during certain specs,
+    # which then fail because some doubles are not made for the methods called
+    allow(Shoes::Swt::RedrawingAspect).to receive_messages new: true
+  end
+end
+
+# as we do not create real apps most of the time there are no redraws and we
+# we don't really want that during test execution either way as it adds stuff to
+# methods that might break
+def with_redraws(&blk)
+  allow(Shoes::Swt::RedrawingAspect).to receive(:new).and_call_original
+  aspect = Shoes::Swt::RedrawingAspect.new swt_app, double
+  begin
+    yield
+  ensure
+    aspect.remove_redraws
+  end
+end
+
+shared_examples = File.expand_path('../shared_examples/**/*.rb', __FILE__)
+Dir[shared_examples].each { |f| require f }

data/spec/swt_shoes/star_spec.rb

@@ -0,0 +1,47 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Star do
+  include_context "swt app"
+
+  let(:left) { 55 }
+  let(:top) { 77 }
+  let(:points) { 7 }
+  let(:outer) { 100 }
+  let(:inner) { 20 }
+  let(:dsl) { Shoes::Star.new shoes_app, parent, left, top, points, outer, inner }
+
+  subject { Shoes::Swt::Star.new dsl, swt_app }
+
+  context "#initialize" do
+    its(:dsl) { is_expected.to be(dsl) }
+  end
+
+  it_behaves_like "paintable"
+  it_behaves_like "updating visibility"
+  it_behaves_like 'clickable backend'
+
+  describe "painter" do
+    include_context "painter context"
+
+    let(:corners) { 0 }
+    let(:dsl) { double("dsl object", hidden: false, points: points, outer: outer,
+                       inner: inner, element_width: outer * 2.0,
+                       element_height: outer * 2.0, element_left: left,
+                       element_top: top).as_null_object }
+    let(:shape) { Shoes::Swt::Star.new dsl, swt_app }
+    subject { Shoes::Swt::Star::Painter.new shape }
+
+    it_behaves_like "fill painter"
+    it_behaves_like "stroke painter"
+
+    it "fills star" do
+      expect(gc).to receive(:fillPolygon)
+      subject.paint_control(event)
+    end
+
+    it "draws star" do
+      expect(gc).to receive(:drawPolygon)
+      subject.paint_control(event)
+    end
+  end
+end

data/spec/swt_shoes/text_block/centered_text_segment_spec.rb

@@ -0,0 +1,16 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::TextBlock::CenteredTextSegment do
+  let(:width) { 200 }
+  let(:dsl)   { double("dsl", text: "boo", font: "", size: 16, style:{}) }
+
+  subject { Shoes::Swt::TextBlock::CenteredTextSegment.new(dsl, width)}
+
+  it "takes all the width it can get" do
+    expect(subject.width).to eq(width)
+  end
+
+  it "calls last line width the full width" do
+    expect(subject.last_line_width).to eq(width)
+  end
+end

data/spec/swt_shoes/text_block/cursor_painter_spec.rb

@@ -0,0 +1,120 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::TextBlock::CursorPainter do
+  include_context "swt app"
+
+  let(:dsl) { double("dsl", app: shoes_app, textcursor: textcursor, has_textcursor?: true) }
+  let(:textcursor) { double("textcursor", left:0, top: 0) }
+  let(:segment_collection) { double('segment collection',
+                                   cursor_height: 12,
+                                   relative_text_position: 0)}
+
+  subject { Shoes::Swt::TextBlock::CursorPainter.new(dsl,
+                                                     segment_collection) }
+
+  describe "missing cursor" do
+    before(:each) do
+      allow(dsl).to receive(:cursor) { nil }
+      allow(dsl).to receive(:textcursor=)
+      allow(textcursor).to receive(:remove)
+      allow(textcursor).to receive(:textcursor=)
+    end
+
+    it "shouldn't do anything without text cursor" do
+      allow(dsl).to receive(:has_textcursor?) { nil}
+      subject.draw
+      expect(dsl).to_not have_received(:textcursor=)
+    end
+
+    it "should remove leftover text cursor" do
+      subject.draw
+      expect(dsl).to have_received(:textcursor=)
+      expect(textcursor).to have_received(:remove)
+    end
+  end
+
+  describe "cursor positioning" do
+    let(:left) { 10 }
+    let(:top)  { 20 }
+    let(:position) { double(x: 5, y: 5) }
+    let(:first_segment) { double("first segment", text: "first",
+                                 get_location: position, height: 10,
+                                 element_left: left, element_top: top) }
+
+    before(:each) do
+      allow(textcursor).to receive(:move)
+      allow(textcursor).to receive(:show)
+    end
+
+    context "with two segments" do
+      let(:second_segment) { double("second segment", text: "second",
+                                    get_location: position,
+                                    element_left: left, element_top: top + 100) }
+      before(:each) do
+        allow(dsl).to receive(:text).and_return(first_segment.text + second_segment.text)
+      end
+
+      context "when moving" do
+        context "in the first segment" do
+          before :each do
+            allow(dsl).to receive(:cursor) { 1 }
+            allow(segment_collection).to receive(:segment_at_text_position) { first_segment }
+          end
+
+          it "moves" do
+            subject.draw
+            expect(textcursor).to have_received(:move).with(left + position.x,
+                                                            top + position.y)
+            expect(textcursor).to have_received(:show)
+          end
+
+          it "does not move when already in position" do
+            allow(textcursor).to receive(:left) { left + position.x }
+            allow(textcursor).to receive(:top)  { top + position.y }
+            allow(subject).to receive(:move_textcursor)
+
+            subject.draw
+
+            expect(subject).to_not have_received(:move_textcursor)
+          end
+        end
+
+        context "in the second segment" do
+          before :each do
+            allow(dsl).to receive(:cursor) { -1 }
+            allow(segment_collection).to receive(:segment_at_text_position) { second_segment }
+          end
+
+          it "moves" do
+            subject.draw
+            expect(textcursor).to have_received(:move).with(left + position.x,
+                                                            top + 100 + position.y)
+            expect(textcursor).to have_received(:show)
+          end
+
+          it "does not move when already in position" do
+            allow(textcursor).to receive(:left) { left + position.x }
+            allow(textcursor).to receive(:top)  { top + 100 + position.y }
+            allow(subject).to receive(:move_textcursor)
+
+            subject.draw
+
+            expect(subject).to_not have_received(:move_textcursor)
+          end
+        end
+      end
+    end
+  end
+
+  describe "textcursor management" do
+    before(:each) do
+      allow(shoes_app).to receive(:textcursor)
+    end
+
+    it "delegates to dsl" do
+      allow(dsl).to receive(:textcursor) { textcursor }
+      result = subject.textcursor
+      expect(result).to eq(textcursor)
+    end
+  end
+end