shoes-swt 4.0.0.pre2

data/spec/swt_shoes/text_block/text_segment_collection_spec.rb

@@ -0,0 +1,256 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::TextBlock::TextSegmentCollection do
+  include_context "swt app"
+
+  let(:first_segment) { create_segment("first", "first") }
+  let(:second_segment) { create_segment("second", "rest") }
+  let(:dsl) { double("dsl", font: "", size: 16, style:{}) }
+
+  let(:gc) { double("gc") }
+  let(:default_text_styles) {
+    {
+      :fg          => :fg,
+      :bg          => :bg,
+      :strikecolor => :strikecolor,
+      :undercolor  => :undercolor,
+      :font_detail => {
+        :name   => "font name",
+        :size   => 12,
+        :styles => [::Swt::SWT::NORMAL]
+      }
+    }
+  }
+
+  describe "with one segment" do
+    subject { Shoes::Swt::TextBlock::TextSegmentCollection.new(dsl,
+                                                         [first_segment],
+                                                         default_text_styles) }
+
+    before do
+      allow(dsl).to receive(:text) { first_segment.text }
+    end
+
+    it "should have length" do
+      expect(subject.length).to eq(1)
+    end
+
+    it "delegates drawing" do
+      subject.draw(gc)
+      expect(first_segment).to have_received(:draw)
+    end
+
+    it "applies segment styling" do
+      styles = [[0..1, [double("segment", style:{stroke: :blue})]]]
+      subject.style_segment_ranges(styles)
+
+      expected_style = style_with(stroke: :blue, fg: :blue)
+      expect(first_segment).to have_received(:set_style).with(expected_style, 0..1)
+    end
+
+    it "only gets default styling if segment is missing opts" do
+      styles = [[0..1, [double("segment")]]]
+      subject.style_segment_ranges(styles)
+      expect(first_segment).to have_received(:set_style).with(default_text_styles, 0..1)
+    end
+
+    describe "links" do
+      it "styles links" do
+        dsl_link = create_link("linky")
+        styles = [[0..1, [dsl_link]]]
+        subject.style_segment_ranges(styles)
+
+        dsl_style = dsl_link.style
+        default_style = default_text_styles.merge(dsl_style)
+        expected_style = default_style.merge({underline: true, stroke: ::Shoes::COLORS[:blue], fill: nil})
+        expect(first_segment).to have_received(:set_style).with(expected_style, 0..1)
+      end
+
+      it "creates a link segment" do
+        link = create_link("f")
+        styles = [[0..1, [link]]]
+        subject.create_links(styles)
+
+        expect(link.gui.link_segments.size).to eq(1)
+      end
+    end
+
+    describe "segment ranges" do
+      it "picks within the first range" do
+        result = subject.segment_ranges(0..2)
+        expect(result).to eql([[first_segment, 0..2]])
+      end
+
+      it "picks the full first range if too large value requested" do
+        result = subject.segment_ranges(0..first_segment.text.length + 10)
+        expect(result).to eql([[first_segment, 0..first_segment.text.length]])
+      end
+    end
+
+    describe "relative text positions" do
+      it "should choose the segment" do
+        expect(subject.relative_text_position(0)).to eq(0)
+      end
+
+      it "should choose segment nearing end" do
+        cursor = first_segment.text.length - 1
+        expect(subject.relative_text_position(cursor)).to eq(cursor)
+      end
+
+      it "should choose segment at end" do
+        cursor = first_segment.text.length
+        expect_relative_position_at_end_of(cursor, first_segment)
+      end
+
+      it "should choose the segment when just past end" do
+        cursor = first_segment.text.length + 1
+        expect_relative_position_at_end_of(cursor, first_segment)
+      end
+
+      it "should choose right past end" do
+        cursor = first_segment.text.length + 3
+        expect_relative_position_at_end_of(cursor, first_segment)
+      end
+
+      it "should chooose the segment for -1" do
+        expect_relative_position_at_end_of(-1, first_segment)
+      end
+
+      it "should allow crazy positions past the end" do
+        expect_relative_position_at_end_of(1000, first_segment)
+      end
+    end
+  end
+
+  describe "with two segments" do
+    subject { Shoes::Swt::TextBlock::TextSegmentCollection.new(dsl,
+                                                         [first_segment, second_segment],
+                                                         default_text_styles) }
+
+    before do
+      allow(dsl).to receive(:text) { first_segment.text + second_segment.text }
+    end
+
+    it "should have length" do
+      expect(subject.length).to eq(2)
+    end
+
+    it "picks range in first segment" do
+      result = subject.segment_ranges(0..2)
+      expect(result).to eql([[first_segment, 0..2]])
+    end
+
+    it "picks range in second segment" do
+      result = subject.segment_ranges(5..7)
+      expect(result).to eql([[second_segment, 0..2]])
+    end
+
+    it "spans both segments" do
+      result = subject.segment_ranges(2..7)
+      expect(result).to eql([[first_segment, 2..5],
+                             [second_segment,  0..2]])
+    end
+
+    it "applies segment styling in first segment" do
+      styles = [[0..2, [double("segment", style:{stroke: :blue})]]]
+      subject.style_segment_ranges(styles)
+
+      expected_style = style_with(stroke: :blue, fg: :blue)
+      expect(first_segment).to have_received(:set_style).with(expected_style, 0..2)
+      expect(second_segment).to_not have_received(:set_style)
+    end
+
+    it "applies segment styling in second segment" do
+      styles = [[5..7, [double("segment", style:{stroke: :blue})]]]
+      subject.style_segment_ranges(styles)
+
+      expected_style = style_with(stroke: :blue, fg: :blue)
+      expect(first_segment).to_not have_received(:set_style)
+      expect(second_segment).to have_received(:set_style).with(expected_style, 0..2)
+    end
+
+    it "applies segment styling in both segments" do
+      styles = [[2..7, [double("segment", style:{stroke: :blue})]]]
+      subject.style_segment_ranges(styles)
+
+      expected_style = style_with(stroke: :blue, fg: :blue)
+      expect(first_segment).to have_received(:set_style).with(expected_style, 2..5)
+      expect(second_segment).to have_received(:set_style).with(expected_style, 0..2)
+    end
+
+    describe "links" do
+      let(:link) { create_link("rstres") }
+
+      it "creates link segments in both segments" do
+        styles = [[2..7, [link]]]
+        subject.create_links(styles)
+
+        expect(link.gui.link_segments.size).to eq(2)
+      end
+
+      it "clears links before re-creating them" do
+        styles = [[2..7, [link]]]
+
+        subject.create_links(styles)
+        subject.create_links(styles)
+
+        expect(link.gui.link_segments.size).to eq(2)
+      end
+    end
+
+    describe "relative text positions" do
+      it "should choose the first segment" do
+        expect(subject.relative_text_position(0)).to eq(0)
+      end
+
+      it "should choose first segment nearing end" do
+        cursor = first_segment.text.length - 1
+        expect(subject.relative_text_position(cursor)).to eq(cursor)
+      end
+
+      it "should choose second segment at end" do
+        cursor = first_segment.text.length
+        expect(subject.relative_text_position(cursor)).to eq(0)
+      end
+
+      it "should choose the second segment" do
+        cursor = first_segment.text.length + 1
+        expect(subject.relative_text_position(cursor)).to eq(1)
+      end
+
+      it "should chooose the second segment for -1" do
+        expect_relative_position_at_end_of(-1, second_segment)
+      end
+
+      it "should allow crazy positions past the end" do
+        expect_relative_position_at_end_of(1000, second_segment)
+      end
+    end
+  end
+
+  def create_segment(name, text)
+    bounds = double("bounds", x: 0, y: 0, height: 0)
+    layout = double(name, text: text,
+                          line_bounds: bounds, line_count: 1)
+
+    segment = Shoes::Swt::TextBlock::TextSegment.new(dsl, text, 1)
+    segment.position_at(0, 0)
+    allow(segment).to receive(:draw)
+    allow(segment).to receive(:set_style)
+    allow(segment).to receive(:get_location).and_return(double("position", x: 0, y: 0))
+    allow(segment).to receive(:layout).and_return(layout)
+    segment
+  end
+
+  def create_link(text)
+    Shoes::Link.new(shoes_app, parent, [text])
+  end
+
+  def style_with(style={})
+    default_text_styles.merge(style)
+  end
+
+  def expect_relative_position_at_end_of(cursor, segment)
+    expect(subject.relative_text_position(cursor)).to eq(segment.text.length)
+  end
+end

data/spec/swt_shoes/text_block/text_segment_spec.rb

@@ -0,0 +1,135 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::TextBlock::TextSegment do
+  let(:layout) { double("layout", text: "the text",
+                        :alignment= => nil, :justify= => nil, :spacing= => nil,
+                        :text= => nil, :width= => nil,
+                        disposed?: false, dispose: nil,
+                        set_style: nil, bounds: bounds) }
+  let(:bounds) { Java::OrgEclipseSwtGraphics::Rectangle.new(0, 0, 0, 0) }
+  let(:element_left) { 0 }
+  let(:element_top)  { 0 }
+  let(:segment_width)  { 10 }
+  let(:segment_height) { 10 }
+  let(:left_offset)   { 5 }
+  let(:top_offset)    { 5 }
+
+  let(:font_factory) { double("font factory", create_font: font, dispose: nil) }
+  let(:style_factory) { double("style factory", create_style: style, dispose: nil) }
+  let(:font)   { double("font") }
+  let(:style)  { double("style") }
+
+  let(:style_hash) {
+    {
+      bg: double("bg"),
+      fg: double("fg"),
+      font_detail: {
+        name: "Comic Sans",
+        size: 18,
+        styles: nil
+      }
+    }
+  }
+
+  let(:dsl) { double("dsl", font: "", size: 16, style:{}) }
+
+  before(:each) do
+    allow(::Swt::TextLayout).to receive(:new)            { layout }
+    allow(Shoes::Swt::TextFontFactory).to receive(:new)  { font_factory }
+    allow(Shoes::Swt::TextStyleFactory).to receive(:new) { style_factory }
+  end
+
+  subject do
+    segment = Shoes::Swt::TextBlock::TextSegment.new(dsl, "text", segment_width)
+    segment.position_at(element_left, element_top)
+  end
+
+  context "disposal" do
+    it "disposes of underlying layout" do
+      allow(layout).to receive(:disposed?) { false }
+      expect(layout).to receive(:dispose)
+      subject.dispose
+    end
+
+    it "doesn't overdispose" do
+      allow(layout).to receive(:disposed?) { true }
+      expect(layout).to_not receive(:dispose)
+      subject.dispose
+    end
+  end
+
+  context "setting style" do
+    it "on full range" do
+      subject.set_style(style_hash)
+      expect(layout).to have_received(:set_style).
+                          with(style, 0, layout.text.length - 1).
+                          at_least(1).times
+    end
+
+    it "with a range" do
+      subject.set_style(style_hash, 1..2)
+      expect(layout).to have_received(:set_style).with(style, 1, 2)
+    end
+
+    it "ignores empty ranges" do
+      subject.set_style(style_hash, 0...0)
+      expect(layout).to_not have_received(:set_style).with(style, 0, 0)
+    end
+  end
+
+  describe "shrinking on initialization" do
+    it "should not shrink when enough containing width" do
+      expect(subject.layout).to_not have_received(:width=)
+    end
+
+    it "shrinks when too long for container" do
+      bounds.width = segment_width + 10
+      expect(subject.layout).to have_received(:width=).with(segment_width)
+    end
+  end
+
+  context "bounds checking" do
+    before(:each) do
+      set_bounds(0, 0, segment_width, segment_height)
+    end
+
+    it "checks boundaries" do
+      expect(subject.in_bounds?(1,1)).to be_truthy
+    end
+
+    describe "offsets left" do
+      let(:element_left) { left_offset }
+
+      it "checks boundaries" do
+        expect(subject.in_bounds?(segment_width + left_offset - 1, 0)).to be_truthy
+      end
+    end
+
+    describe "offsets top" do
+      let(:element_top) { top_offset }
+
+      it "checks boundaries" do
+        expect(subject.in_bounds?(0, segment_height + top_offset - 1)).to be_truthy
+      end
+    end
+
+    def set_bounds(x, y, width, height)
+      bounds.x = x
+      bounds.y = y
+      bounds.width = width
+      bounds.height = height
+    end
+  end
+
+  describe "dispose" do
+    it "should dispose its Swt fonts" do
+      subject.dispose
+      expect(font_factory).to have_received(:dispose)
+    end
+
+    it "should dispose its Swt colors" do
+      subject.dispose
+      expect(style_factory).to have_received(:dispose)
+    end
+  end
+end

data/spec/swt_shoes/text_block_spec.rb

@@ -0,0 +1,199 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::TextBlock do
+  include_context "swt app"
+
+  let(:height) { 100 }
+  let(:width)  { 200 }
+  let(:margin) { 10 }
+  let(:dsl) { double("dsl", app: shoes_app, text: "text",
+                     margin_left: 0, margin_right: 0,
+                     margin_top: 0, margin_bottom: 0,
+                     pass_coordinates?: nil).as_null_object }
+
+  subject { Shoes::Swt::TextBlock.new(dsl, swt_app) }
+
+  it_behaves_like "paintable"
+  it_behaves_like "updating visibility"
+  it_behaves_like "clickable backend"
+
+  # reported nil, caused trouble in simple-downloader.rb
+  it 'initially responds with empty segments' do
+    expect(subject.segments).to be_empty
+  end
+
+  describe "bounds checking" do
+    it "delegates to segment" do
+      segment = double()
+      subject.segments = [segment]
+      expect(segment).to receive(:in_bounds?)
+
+      subject.in_bounds?(1,1)
+    end
+  end
+
+  describe "contents alignment" do
+    let(:layout_width) { 100 }
+    let(:layout_height) { 200 }
+    let(:line_height) { 10 }
+
+    let(:bounds) { double("bounds", height: layout_height, width: layout_width) }
+    let(:unused_bounds) { double("unused bounds", height: 0, width: 0) }
+
+    let(:fitter) { double("fitter") }
+    let(:segment) { create_segment }
+    let(:second_segment) { create_segment }
+
+    let(:current_position) { Shoes::Slot::CurrentPosition.new(0, 0) }
+
+    before(:each) do
+      allow(::Shoes::Swt::TextBlock::Fitter).to receive(:new) { fitter }
+      allow(fitter).to receive(:fit_it_in).and_return([segment], [second_segment])
+    end
+
+    describe "with single segment" do
+      before(:each) do
+        allow(dsl).to receive(:absolute_left)   { 50 }
+        allow(dsl).to receive(:absolute_top)    { 0 }
+        allow(dsl).to receive(:absolute_bottom) { layout_height }
+      end
+
+      it "positions single line of text" do
+        expect(dsl).to receive(:absolute_right=).with(layout_width + 50)
+        expect(dsl).to receive(:absolute_bottom=).with(layout_height)
+
+        when_aligns_and_positions
+
+        expect(current_position.y).to eq(layout_height - line_height)
+      end
+
+      it "positions single line with margin" do
+        allow(dsl).to receive_messages(margin_left: margin, margin_right: margin,
+                 margin_top: margin, margin_bottom: margin)
+
+        expect(dsl).to receive(:absolute_right=).with(layout_width + 50 + margin)
+        expect(dsl).to receive(:absolute_bottom=).with(layout_height + 2 * margin)
+
+        when_aligns_and_positions
+
+        expect(current_position.y).to eq(layout_height - line_height)
+      end
+
+      it "pushes to next line if ends in newline" do
+        allow(dsl).to receive(:text) { "text\n" }
+
+        expect(dsl).to receive(:absolute_right=).with(50)
+        expect(dsl).to receive(:absolute_bottom=).with(layout_height)
+
+        when_aligns_and_positions
+
+        expect(current_position.y).to eq(layout_height)
+      end
+
+      it "disposes of prior segments" do
+        subject.contents_alignment(current_position)
+        expect(segment).to receive(:dispose)
+
+        subject.contents_alignment(current_position)
+      end
+
+      it "should not dispose any segments" do
+        expect(segment).not_to receive(:dispose)
+        expect(second_segment).not_to receive(:dispose)
+
+        subject.contents_alignment(current_position)
+      end
+
+      context "on the second call" do
+        before(:each) do
+          subject.contents_alignment(current_position)
+        end
+
+        it "should only dispose old segment" do
+          expect(segment).to receive(:dispose)
+          expect(second_segment).not_to receive(:dispose)
+
+          subject.contents_alignment(current_position)
+        end
+
+        it "should dispose all segments on remove" do
+          allow(swt_app).to receive(:remove_listener)
+
+          expect(segment).to receive(:dispose).at_least(1).times
+          expect(second_segment).to receive(:dispose).at_least(1).times
+
+          subject.contents_alignment(current_position)
+          subject.remove
+        end
+      end
+    end
+
+    describe "with two segments" do
+      before(:each) do
+        allow(dsl).to receive(:parent) { double("dsl parent", absolute_left: 0) }
+        allow(dsl).to receive(:absolute_bottom) { layout_height }
+
+        current_position.next_line_start = 0
+
+        allow(fitter).to receive(:fit_it_in) {
+          [create_segment("unused segment"),
+           create_segment("segment")]
+        }
+      end
+
+      it "positions in two segments" do
+        expect(dsl).to receive(:absolute_right=).with(layout_width)
+        expect(dsl).to receive(:absolute_bottom=).with(layout_height)
+
+        when_aligns_and_positions
+
+        expect(current_position.y).to eq(layout_height - line_height)
+      end
+
+      it "positions in two segments with margins" do
+        allow(dsl).to receive_messages(margin_left: margin, margin_right: margin,
+                 margin_top: margin, margin_bottom: margin)
+
+        expect(dsl).to receive(:absolute_right=).with(layout_width + margin)
+        expect(dsl).to receive(:absolute_bottom=).with(layout_height + 2 * margin)
+
+        when_aligns_and_positions
+
+        expect(current_position.y).to eq(layout_height - line_height)
+      end
+    end
+  end
+
+  context "links" do
+    let(:link)     { Shoes::Link.new(shoes_app, subject, ["link"])  }
+
+    before(:each) do
+      allow(dsl).to receive(:links) { [link] }
+      allow(swt_app).to receive(:remove_listener)
+    end
+
+    it "clears links" do
+      expect(link).to receive(:remove)
+      subject.remove
+    end
+
+    it "clears links on replace" do
+      expect(link).to receive(:remove)
+      subject.replace("text")
+    end
+  end
+
+  def create_segment(name="segment", width=layout_width,
+                    height=layout_height, line_height=line_height)
+    bounds = double("bounds", width: width, height: height)
+    double(name, disposed?: false,
+           width: width, height: height,
+           last_line_width: width, last_line_height: line_height,
+           bounds: bounds)
+  end
+
+  def when_aligns_and_positions
+    subject.contents_alignment(current_position)
+    subject.adjust_current_position(current_position)
+  end
+end