shoes 4.0.0.pre1 → 4.0.0.pre2

data/spec/swt_shoes/shared_examples/pattern.rb

@@ -1,32 +0,0 @@
-shared_examples_for "an swt pattern" do
-  it { should respond_to(:apply_as_stroke) }
-  it { should 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
-        gc.stub(:set_alpha)
-        gc.should_receive(:set_foreground)
-      else
-        gc.should_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
-        gc.stub(:set_foreground)
-        gc.should_receive(:set_alpha)
-      else
-        gc.should_receive(:set_foreground_pattern)
-      end
-      subject.apply_as_stroke(gc, left, top, width, height)
-    end
-  end
-end

data/spec/swt_shoes/shared_examples/swt_app_context.rb

@@ -1,17 +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) { double('swt app real', disposed?: false) }
-  let(:swt_app) { double('swt app', real: swt_app_real, disposed?: false, 
-                         add_paint_listener: true, remove_paint_listener: true,
-                         add_clickable_element: true, add_listener: true,
-                         flush: true, redraw: true) }
-  let(:shoes_app) { double('shoes app', gui: swt_app, rotate: 0) }
-  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/togglable.rb

@@ -1,15 +0,0 @@
-shared_examples_for "togglable" do
-  it "triggers redrawing on the app" do
-    with_redraws do
-      expect(swt_app).to receive(:redraw)
-      subject.toggle
-    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.toggle
-    end
-  end
-end

data/spec/swt_shoes/shell_control_listener_spec.rb

@@ -1,23 +0,0 @@
-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/sound.rb

@@ -1,10 +0,0 @@
-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) { should be(parent) }
-  its(:filepath) { should be(filepath) }
-end

data/spec/swt_shoes/spec_helper.rb

@@ -1,31 +0,0 @@
-require 'code_coverage'
-require "shoes/swt"
-require "spec_helper"
-
-RSpec.configure do |config|
-  config.before(:each) do
-    Swt.stub(:event_loop)
-    Shoes::Swt::App.any_instance.stub(flush: true)
-    Swt::Widgets::Shell.any_instance.stub(:open)
-    Swt::Widgets::MessageBox.any_instance.stub(: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
-    Shoes::Swt::RedrawingAspect.stub 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)
-  Shoes::Swt::RedrawingAspect.unstub :new
-  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

@@ -1,47 +0,0 @@
-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) { should be(dsl) }
-  end
-
-  it_behaves_like "paintable"
-  it_behaves_like "togglable"
-  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
-      gc.should_receive(:fillPolygon)
-      subject.paint_control(event)
-    end
-
-    it "draws star" do
-      gc.should_receive(:drawPolygon)
-      subject.paint_control(event)
-    end
-  end
-end

data/spec/swt_shoes/text_block_cursor_painter_spec.rb

@@ -1,202 +0,0 @@
-require 'swt_shoes/spec_helper'
-require 'shoes/swt/text_block_cursor_painter'
-
-describe Shoes::Swt::TextBlockCursorPainter 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(:text_layout) { double("text layout",
-                             get_line_bounds: double("line bounds", height: 10)) }
-  let(:fitted_layouts) { [] }
-
-  subject { Shoes::Swt::TextBlockCursorPainter.new(dsl, fitted_layouts) }
-
-  describe "missing cursor" do
-    before(:each) do
-      dsl.stub(:cursor) { nil }
-      dsl.stub(:textcursor=)
-      textcursor.stub(:remove)
-      textcursor.stub(:textcursor=)
-    end
-
-    it "shouldn't do anything without text cursor" do
-      dsl.stub(: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_layout) { double("first layout", text: "first",
-                                get_location: position,
-                                get_line_bounds: text_layout, height: 10,
-                                element_left: left, element_top: top) }
-
-    before(:each) do
-      textcursor.stub(:move)
-      textcursor.stub(:show)
-      dsl.stub(:text).and_return(first_layout.text)
-      fitted_layouts << first_layout
-    end
-
-    context "with one layout" do
-      it "should choose the layout" do
-        position_cursor(0)
-        expect(subject.choose_layout).to eq(first_layout)
-        expect(subject.relative_cursor).to eq(0)
-      end
-
-      it "should choose layout at very end" do
-        cursor = first_layout.text.length
-        position_cursor(cursor)
-        expect(subject.choose_layout).to eq(first_layout)
-        expect(subject.relative_cursor).to eq(cursor)
-      end
-
-      it "should choose the layout when just past end" do
-        position_cursor(first_layout.text.length + 1)
-        expect_cursor_at_end_of(first_layout)
-      end
-
-      it "should chooose the layout for -1" do
-        position_cursor(-1)
-        expect_cursor_at_end_of(first_layout)
-      end
-
-      it "should choose right past end" do
-        position_cursor(first_layout.text.length + 3)
-        expect_cursor_at_end_of(first_layout)
-      end
-
-      it "should allow crazy positions past the end" do
-        position_cursor(1_000)
-        expect_cursor_at_end_of(first_layout)
-      end
-    end
-
-    context "with two layouts" do
-      let(:second_layout) { double("second layout", text: "second",
-                                   get_location: position,
-                                   element_left: left, element_top: top + 100) }
-      before(:each) do
-        dsl.stub(:text).and_return(first_layout.text + second_layout.text)
-        fitted_layouts << second_layout
-      end
-
-      it "should choose the first layout" do
-        position_cursor(0)
-        expect(subject.choose_layout).to eq(first_layout)
-        expect(subject.relative_cursor).to eq(0)
-      end
-
-      it "should choose first layout at very end" do
-        cursor = first_layout.text.length
-        position_cursor(cursor)
-        expect(subject.choose_layout).to eq(first_layout)
-        expect(subject.relative_cursor).to eq(cursor)
-      end
-
-      it "should choose the second layout" do
-        position_cursor(first_layout.text.length + 1)
-        expect(subject.choose_layout).to eq(second_layout)
-        expect(subject.relative_cursor).to eq(1)
-      end
-
-      it "should chooose the second layout for -1" do
-        position_cursor(-1)
-        expect_cursor_at_end_of(second_layout)
-      end
-
-      it "should allow crazy positions past the end" do
-        position_cursor(1_000)
-        expect_cursor_at_end_of(second_layout)
-      end
-
-      context "when moving" do
-        before :each do
-          subject.stub(:cursor_height) { 12 }
-        end
-
-        context "in the first layout" do
-          before :each do
-            position_cursor(1)
-          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
-            textcursor.stub(:left) { left + position.x }
-            textcursor.stub(:top)  { top + position.y }
-            subject.stub(:move_textcursor)
-
-            subject.draw
-
-            expect(subject).to_not have_received(:move_textcursor)
-          end
-        end
-
-        context "in the second layout" do
-          before :each do
-            position_cursor(-1)
-          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
-            textcursor.stub(:left) { left + position.x }
-            textcursor.stub(:top)  { top + 100 + position.y }
-            subject.stub(:move_textcursor)
-
-            subject.draw
-
-            expect(subject).to_not have_received(:move_textcursor)
-          end
-        end
-      end
-    end
-
-    def position_cursor(index)
-      dsl.stub(:cursor) { index }
-    end
-
-    def expect_cursor_at_end_of(layout)
-      expect(subject.choose_layout).to eq(layout)
-      expect(subject.relative_cursor).to eq(layout.text.length)
-    end
-  end
-
-  describe "textcursor management" do
-    let(:first_layout) { double("first layout", layout: text_layout) }
-
-    before(:each) do
-      shoes_app.stub(:textcursor)
-      fitted_layouts << first_layout
-    end
-
-    it "delegates to dsl" do
-      dsl.stub(:textcursor) { textcursor }
-      result = subject.textcursor
-      expect(result).to eq(textcursor)
-    end
-  end
-end

data/spec/swt_shoes/text_block_fitter_spec.rb

@@ -1,181 +0,0 @@
-require 'swt_shoes/spec_helper'
-require 'shoes/swt/text_block_fitter'
-
-describe Shoes::Swt::TextBlockFitter do
-  let(:dsl) { double('dsl', parent: parent_dsl, text: "Text goes here",
-                     absolute_left: 25, absolute_top: 75,
-                     desired_width: 85,
-                     element_left: 26, element_top: 76,
-                     margin_left: 1, margin_top: 1) }
-
-  let(:parent_dsl) { double('parent_dsl', parent: grandparent_dsl,
-                            absolute_left: 0, absolute_right: 100,
-                            width: parent_width, height: 200) }
-
-  let(:grandparent_dsl) { double('grandparent_dsl', parent: app,
-                                 width: grandparent_width) }
-
-  let(:app) { double('app', width: app_width) }
-
-  let(:parent_width)      { 100 }
-  let(:grandparent_width) { 1000 }
-  let(:app_width)         { 2000 }
-
-  let(:text_block) { double('text_block', dsl: dsl) }
-  let(:layout)     { double('layout') }
-
-  let(:current_position) { double('current_position') }
-
-  subject { Shoes::Swt::TextBlockFitter.new(text_block, current_position) }
-
-  before(:each) do
-    Shoes::Swt::FittedTextLayout.stub(:new) { layout }
-  end
-
-  describe "determining available space" do
-    it "should offset by parent with current position" do
-      when_positioned_at(x: 15, y: 5, next_line_start: 30)
-      expect(subject.available_space).to eq([85, 24])
-    end
-
-    it "should move to next line with at very end of vertical space" do
-      when_positioned_at(x: 15, y: 5, next_line_start: 5)
-      expect(subject.available_space).to eq([85, :unbounded])
-    end
-
-    it "should move to next line when top is past the projected next line" do
-      when_positioned_at(x: 15, y: 100, next_line_start: 5)
-      expect(subject.available_space).to eq([85, :unbounded])
-    end
-
-    context "positioned outside parent" do
-      before(:each) do
-        dsl.stub(:desired_width) { -1 }
-      end
-
-      it "bumps to parent width when at end of vertical space" do
-        when_positioned_at(x: 110, y: 5, next_line_start: 5)
-        dsl.stub(:desired_width).with(grandparent_width) { 890 }
-
-        expect(subject.available_space).to eq([890, :unbounded])
-      end
-
-      it "bumps out until it fits" do
-        when_positioned_at(x:1010, y: 5, next_line_start: 5)
-        dsl.stub(:desired_width).with(app_width) { 990 }
-
-        expect(subject.available_space).to eq([990, :unbounded])
-      end
-
-      it "just gives up if it still won't fit" do
-        when_positioned_at(x:1010, y: 5, next_line_start: 5)
-        expect(subject.available_space).to eq([0, 0])
-      end
-    end
-  end
-
-  describe "finding what didn't fit" do
-    it "should tell split text by offsets and heights" do
-      layout = double('layout', line_offsets: [0, 5, 9], text: "Text Split")
-      layout.stub(:line_metrics) { double('line_metrics', height: 50)}
-
-      subject.split_text(layout, 55).should eq(["Text ", "Split"])
-    end
-
-    it "should be able to split text when too small" do
-      layout = double('layout', line_offsets: [0, 10], text: "Text Split")
-      layout.stub(:line_metrics).with(0) { double('line_metrics', height: 21)}
-      layout.stub(:line_metrics).with(1) { raise "Boom" }
-
-      subject.split_text(layout, 33).should eq(["Text Split", ""])
-    end
-  end
-
-  describe "fit it in" do
-    let(:bounds) { double('bounds', width: 100, height: 50)}
-    let(:layout) { double('layout', text: "something something",
-                          line_count: 1, line_offsets:[], get_bounds: bounds) }
-
-    before(:each) do
-      layout.stub(:position_at) { layout }
-    end
-
-    context "to one layout" do
-      it "should work" do
-        fitted_layouts = when_fit_at(x: 25, y: 75, next_line_start: 130)
-        expect_fitted_layouts(fitted_layouts, [26, 76])
-      end
-
-      it "with one line, even if height is bigger" do
-        bounds.stub(width: 50)
-        fitted_layouts = when_fit_at(x: 25, y: 75, next_line_start: 95)
-        expect_fitted_layouts(fitted_layouts, [26, 76])
-      end
-    end
-
-    context "to two layouts" do
-      before(:each) do
-        layout.stub(line_count: 2, line_metrics: double(height: 15))
-        bounds.stub(width: 50)
-        dsl.stub(containing_width: :unused)
-      end
-
-      it "should split text and overflow to second layout" do
-        with_text_split("something ", "something")
-        fitted_layouts = when_fit_at(x: 25, y: 75, next_line_start: 95)
-        expect_fitted_layouts(fitted_layouts, [26, 76], [1, 126])
-      end
-
-      it "should overflow all text to second layout" do
-        with_text_split("", "something something")
-        fitted_layouts = when_fit_at(x: 25, y: 75, next_line_start: 95)
-        expect_fitted_layouts(fitted_layouts, [26, 76], [1, 95])
-      end
-    end
-
-    context "to empty first layout" do
-      before(:each) do
-        dsl.stub(containing_width: 100)
-        layout.stub(:text= => nil)
-      end
-
-      it "rolls to second layout when 0 remaining width" do
-        dsl.stub(desired_width: 0)
-        fitted_layouts = when_fit_at(x: 0, y: 75, next_line_start: 95)
-        expect_fitted_layouts(fitted_layouts, [26, 76], [1, 96])
-      end
-
-      it "rolls to second layout when negative remaining width" do
-        dsl.stub(desired_width: -1)
-        fitted_layouts = when_fit_at(x: 0, y: 75, next_line_start: 95)
-        expect_fitted_layouts(fitted_layouts, [26, 76], [1, 96])
-      end
-    end
-  end
-
-  def with_text_split(first, second)
-    dsl.stub(text: first + second)
-    layout.stub(line_offsets: [0, first.length, first.length + second.length])
-  end
-
-  def when_positioned_at(args)
-    x = args.fetch(:x)
-    y = args.fetch(:y)
-    next_line_start = args.fetch(:next_line_start)
-
-    dsl.stub(absolute_left: x, absolute_top: y)
-    current_position.stub(:next_line_start) { next_line_start }
-  end
-
-  def when_fit_at(args)
-    when_positioned_at(args)
-    subject.fit_it_in
-  end
-
-  def expect_fitted_layouts(fitted_layouts, *coordinates)
-    fitted_layouts.each_with_index do |fitted, index|
-      x, y = coordinates[index]
-      expect(fitted).to have_received(:position_at).with(x, y)
-    end
-  end
-end