shoes-swt 4.0.0.pre7 → 4.0.0.pre8

data/spec/shoes/swt/shared_examples/painter.rb

@@ -1,82 +0,0 @@
-# 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/shoes/swt/shared_examples/pattern.rb

@@ -1,28 +0,0 @@
-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") }
-
-    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, applied_to)
-    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, applied_to)
-    end
-  end
-end

data/spec/shoes/swt/shared_examples/removable.rb

@@ -1,39 +0,0 @@
-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(click_listener).to receive(:remove_listeners_for)
-    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(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(real).to receive(:disposed?) { true }
-    expect(real).not_to receive(:dispose)
-    subject.remove
-  end
-end

data/spec/shoes/swt/shared_examples/swt_app_context.rb

@@ -1,41 +0,0 @@
-# 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) do
-    double('swt app real', disposed?: false, set_visible: true)
-  end
-
-  let(:clickable_element) { double("clickable_element", delete: nil) }
-
-  let(:click_listener) do
-    double("click listener", add_click_listener: nil, add_release_listener: nil,
-                             remove_listeners_for: nil)
-  end
-
-  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,
-                                   click_listener: click_listener,
-                                   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) do
-    double('parent', app: swt_app, add_child: true, real: true,
-                     absolute_left: 0, absolute_top: 0,
-                     width: 200, height: 100, fixed_height?: true)
-  end
-
-  let(:parent_dsl) do
-    double("parent dsl", add_child: true, contents: [], gui: parent,
-                         x_dimension: double.as_null_object,
-                         y_dimension: double.as_null_object)
-  end
-end

data/spec/shoes/swt/shared_examples/visibility.rb

@@ -1,15 +0,0 @@
-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/shoes/swt/shell_control_listener_spec.rb

@@ -1,23 +0,0 @@
-require '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/shoes/swt/shoes_layout_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Swt::ShoesLayout do
-  subject do
-    result = Shoes::Swt::ShoesLayout.new
-    result.gui_app = gui_app
-    result
-  end
-
-  let(:gui_app)   { double('gui_app', dsl: dsl, real: real, shell: shell) }
-  let(:size)      { double('size', height: 0, width: 0) }
-  let(:location)  { double('location', :y= => nil) }
-  let(:dsl)       { double('dsl', top_slot: top_slot, height: 100, width: 100) }
-  let(:shell)     { double('shell', vertical_bar: vertical_bar) }
-
-  let(:scroll_height) { dsl.height * 2 }
-
-  let(:real) do
-    double('real', set_size: nil, location: location, :location= => nil)
-  end
-
-  let(:top_slot) do
-    double('top_slot', contents_alignment: 0, :width= => nil, :height= => nil)
-  end
-
-  let(:vertical_bar) do
-    double('vertical_bar', :increment= => nil, :visible= => nil,
-                           :maximum= => nil, :thumb= => nil, thumb: 0)
-  end
-
-  before do
-    allow(real).to receive(:compute_trim) do |_, _, width, height|
-      double('size', width: width, height: height)
-    end
-  end
-
-  it "sets size on real element" do
-    expect(real).to receive(:set_size).with(dsl.width, dsl.height)
-    subject.layout
-  end
-
-  it "sets height on real element to scrollable height when that's bigger" do
-    when_contents_scroll
-    expect(real).to receive(:set_size).with(dsl.width, scroll_height)
-    subject.layout
-  end
-
-  it "sets size on top slot" do
-    expect(top_slot).to receive(:width=).with(dsl.width)
-    expect(top_slot).to receive(:height=).with(dsl.height)
-    subject.layout
-  end
-
-  it "sets height on top slot to scrollable height when that's bigger" do
-    when_contents_scroll
-    expect(top_slot).to receive(:width=).with(dsl.width)
-    expect(top_slot).to receive(:height=).with(scroll_height)
-    subject.layout
-  end
-
-  it "shows scrollbar" do
-    when_contents_scroll
-    expect(vertical_bar).to receive(:visible=).with(true)
-    subject.layout
-  end
-
-  it "updates settings on scrollbar when visible" do
-    when_contents_scroll
-    [:thumb=, :maximum=, :increment=].each do |m|
-      expect(vertical_bar).to receive(m)
-    end
-    subject.layout
-  end
-
-  it "hides scrollbar" do
-    expect(vertical_bar).to receive(:visible=).with(false)
-    subject.layout
-  end
-
-  it "sets gui location when scrollbar hidden" do
-    expect(real).to receive(:location=).with(location)
-    subject.layout
-  end
-
-  def when_contents_scroll
-    allow(top_slot).to receive(:contents_alignment) { scroll_height }
-  end
-end

data/spec/shoes/swt/slot_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Swt::Slot do
-  include_context "swt app"
-
-  let(:dsl) do
-    instance_double Shoes::Slot, hidden?: true, visible?: false,
-                                 contents: [content]
-  end
-
-  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 entire rather than their contents
-    it 'tries to hide the content' do
-      subject.update_visibility
-      expect(content).to have_received :hide
-    end
-
-    # spec may be deleted if we can hide entire rather than their contents
-    it 'only hides on visibility changes' do
-      subject.update_visibility
-      subject.update_visibility
-      expect(content).to have_received(:hide).once
-    end
-  end
-
-  describe '#remove' do
-    it 'cleans up click listeners' do
-      expect(swt_app.click_listener).to receive(:remove_listeners_for).with(dsl)
-      subject.remove
-    end
-  end
-end

data/spec/shoes/swt/spec_helper.rb

@@ -1,43 +0,0 @@
-require "shoes/swt"
-require "spec_helper"
-
-Shoes.load_backend("swt").initialize_backend
-
-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
-
-  # https://github.com/jruby/jruby/wiki/Persistence
-  # mostly to allow stubbing/mocking of said java classes
-  config.before(:all) do
-    Swt::Widgets::Shell.__persistent__      = true
-    Swt::Widgets::MessageBox.__persistent__ = true
-    Swt::Path.__persistent__                = true
-    Swt::Transform.__persistent__           = true
-    Swt::Font.__persistent__                = true
-    Swt::Widgets::Display.__persistent__    = 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
-  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/shoes/swt/star_painter_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Swt::StarPainter do
-  include_context "swt app"
-  include_context "painter context"
-
-  let(:left) { 55 }
-  let(:top) { 77 }
-  let(:points) { 7 }
-  let(:outer) { 100 }
-  let(:inner) { 20 }
-  let(:corners) { 0 }
-
-  let(:dsl) do
-    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
-  end
-
-  let(:shape) { Shoes::Swt::Star.new dsl, swt_app }
-  subject { Shoes::Swt::StarPainter.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

data/spec/shoes/swt/star_spec.rb

@@ -1,22 +0,0 @@
-require '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'
-end

data/spec/shoes/swt/text_block/centered_text_segment_spec.rb

@@ -1,16 +0,0 @@
-require '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/shoes/swt/text_block/cursor_painter_spec.rb

@@ -1,128 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Swt::TextBlock::CursorPainter do
-  include_context "swt app"
-
-  let(:dsl) { double("dsl", app: shoes_app, textcursor: textcursor, textcursor?: true) }
-  let(:textcursor) { double("textcursor", left: 0, top: 0, height: 10) }
-
-  let(:segment_collection) do
-    double('segment collection', cursor_height: 12, relative_text_position: 0)
-  end
-
-  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(: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) do
-      double("first segment", text: "first", get_location: position, height: 10,
-                              element_left: left, element_top: top)
-    end
-
-    before(:each) do
-      allow(textcursor).to receive(:move)
-      allow(textcursor).to receive(:show)
-    end
-
-    context "with two segments" do
-      let(:second_segment) do
-        double("second segment", text: "second", get_location: position,
-                                 element_left: left, element_top: top + 100)
-      end
-
-      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,
-                                                            left + position.x,
-                                                            top + position.y + textcursor.height)
-            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,
-                                                            left + position.x,
-                                                            top + 100 + position.y + textcursor.height)
-            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