shoes 4.0.0.pre1 → 4.0.0.pre2

data/spec/swt_shoes/fitted_text_layout_collection_spec.rb

@@ -1,174 +0,0 @@
-require 'swt_shoes/spec_helper'
-
-describe Shoes::Swt::FittedTextLayoutCollection do
-  include_context "swt app"
-
-  let(:first_layout) { create_layout("first", "first") }
-  let(:second_layout) { create_layout("second", "rest") }
-
-  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]
-      }
-    }
-  }
-
-  context "with one layout" do
-    subject { Shoes::Swt::FittedTextLayoutCollection.new([first_layout], default_text_styles) }
-
-    it "should have length" do
-      expect(subject.length).to eq(1)
-    end
-
-    it "delegates drawing" do
-      subject.draw(gc)
-      expect(first_layout).to have_received(:draw)
-    end
-
-    it "applies segment styling" do
-      styles = [[0..1, [double("segment", opts:{stroke: :blue})]]]
-      subject.style_segment_ranges(styles)
-
-      expected_style = style_with(stroke: :blue, fg: :blue)
-      expect(first_layout).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_layout).to have_received(:set_style).with(default_text_styles, 0..1)
-    end
-
-    context "links" do
-      it "styles links" do
-        styles = [[0..1, [create_link("linky")]]]
-        subject.style_segment_ranges(styles)
-
-        expected_style = style_with(underline: true, stroke: ::Shoes::COLORS[:blue])
-        expect(first_layout).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).to have(1).item
-      end
-    end
-
-    context "layout ranges" do
-      it "picks within the first range" do
-        result = subject.layout_ranges(0..2)
-        expect(result).to eql([[first_layout, 0..2]])
-      end
-
-      it "picks the full first range if too large value requested" do
-        result = subject.layout_ranges(0..first_layout.text.length + 10)
-        expect(result).to eql([[first_layout, 0..first_layout.text.length]])
-      end
-    end
-  end
-
-  context "with two layouts" do
-    subject { Shoes::Swt::FittedTextLayoutCollection.new([first_layout, second_layout], default_text_styles) }
-
-    it "should have length" do
-      expect(subject.length).to eq(2)
-    end
-
-    it "picks range in first layout" do
-      result = subject.layout_ranges(0..2)
-      expect(result).to eql([[first_layout, 0..2]])
-    end
-
-    it "picks range in second layout" do
-      result = subject.layout_ranges(5..7)
-      expect(result).to eql([[second_layout, 0..2]])
-    end
-
-    it "spans both layouts" do
-      result = subject.layout_ranges(2..7)
-      expect(result).to eql([[first_layout, 2..5],
-                             [second_layout,  0..2]])
-    end
-
-    it "applies segment styling in first layout" do
-      styles = [[0..2, [double("segment", opts:{stroke: :blue})]]]
-      subject.style_segment_ranges(styles)
-
-      expected_style = style_with(stroke: :blue, fg: :blue)
-      expect(first_layout).to have_received(:set_style).with(expected_style, 0..2)
-      expect(second_layout).to_not have_received(:set_style)
-    end
-
-    it "applies segment styling in second layout" do
-      styles = [[5..7, [double("segment", opts:{stroke: :blue})]]]
-      subject.style_segment_ranges(styles)
-
-      expected_style = style_with(stroke: :blue, fg: :blue)
-      expect(first_layout).to_not have_received(:set_style)
-      expect(second_layout).to have_received(:set_style).with(expected_style, 0..2)
-    end
-
-    it "applies segment styling in both layouts" do
-      styles = [[2..7, [double("segment", opts:{stroke: :blue})]]]
-      subject.style_segment_ranges(styles)
-
-      expected_style = style_with(stroke: :blue, fg: :blue)
-      expect(first_layout).to have_received(:set_style).with(expected_style, 2..5)
-      expect(second_layout).to have_received(:set_style).with(expected_style, 0..2)
-    end
-
-    context "links" do
-      let(:link) { create_link("rstres") }
-
-      it "creates link segments in both layouts" do
-        styles = [[2..7, [link]]]
-        subject.create_links(styles)
-
-        expect(link.gui.link_segments).to have(2).items
-      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).to have(2).items
-      end
-    end
-  end
-
-  def create_layout(name, text)
-    bounds = double("bounds", x: 0, y: 0, height: 0)
-    inner_layout = double(name, text: text,
-                          line_bounds: bounds, line_count: 1)
-
-    dsl = double("dsl", font: "", font_size: 16, opts:{})
-    layout = Shoes::Swt::FittedTextLayout.new(dsl, text, 1)
-    layout.position_at(0, 0)
-    layout.stub(:draw)
-    layout.stub(:set_style)
-    layout.stub(:get_location).and_return(double("position", x: 0, y: 0))
-    layout.stub(:layout).and_return(inner_layout)
-    layout
-  end
-
-  def create_link(text)
-    Shoes::Link.new(shoes_app, parent, [text])
-  end
-
-  def style_with(opts={})
-    default_text_styles.merge(opts)
-  end
-end

data/spec/swt_shoes/fitted_text_layout_spec.rb

@@ -1,130 +0,0 @@
-require 'swt_shoes/spec_helper'
-
-describe Shoes::Swt::FittedTextLayout do
-  let(:layout) { double("layout", text: "the text",
-                        :alignment= => nil, :justify= => nil, :spacing= => nil,
-                        :text= => nil, setWidth: 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(:layout_width)  { 10 }
-  let(:layout_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: "", font_size: 16, opts:{}) }
-
-  before(:each) do
-    ::Swt::TextLayout.stub(:new)            { layout }
-    Shoes::Swt::TextFontFactory.stub(:new)  { font_factory }
-    Shoes::Swt::TextStyleFactory.stub(:new) { style_factory }
-  end
-
-  subject do
-    fitted = Shoes::Swt::FittedTextLayout.new(dsl, "text", layout_width)
-    fitted.position_at(element_left, element_top)
-  end
-
-  context "disposal" do
-    it "disposes of underlying layout" do
-      layout.stub(:disposed?) { false }
-      expect(layout).to receive(:dispose)
-      subject.dispose
-    end
-
-    it "doesn't overdispose" do
-      layout.stub(: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
-  end
-
-  describe "shrinking on initialization" do
-    it "should not shrink when enough containing width" do
-      expect(subject.layout).to_not have_received(:setWidth)
-    end
-
-    it "shrinks when too long for container" do
-      bounds.width = layout_width + 10
-      expect(subject.layout).to have_received(:setWidth).with(layout_width)
-    end
-  end
-
-  context "bounds checking" do
-    before(:each) do
-      set_bounds(0, 0, layout_width, layout_height)
-    end
-
-    it "checks boundaries" do
-      expect(subject.in_bounds?(1,1)).to be_true
-    end
-
-    describe "offsets left" do
-      let(:element_left) { left_offset }
-
-      it "checks boundaries" do
-        expect(subject.in_bounds?(layout_width + left_offset - 1, 0)).to be_true
-      end
-    end
-
-    describe "offsets top" do
-      let(:element_top) { top_offset }
-
-      it "checks boundaries" do
-        expect(subject.in_bounds?(0, layout_height + top_offset - 1)).to be_true
-      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/flow_spec.rb

@@ -1,26 +0,0 @@
-require 'swt_shoes/spec_helper'
-
-describe Shoes::Swt::Flow do
-  include_context "swt app"
-
-  let(:dsl) { double('dsl', app: shoes_app).as_null_object }
-  let(:real) { double('real', disposed?: false) }
-  let(:parent_real) { double('parent_real', :get_layout => "ok") }
-
-  subject { Shoes::Swt::Flow.new(dsl, parent) }
-
-  it_behaves_like "togglable"
-
-  describe "#initialize" do
-    before do
-      parent.stub(:real) { parent_real }
-      parent_real.stub(:get_layout){double(top_slot: true)}
-    end
-
-    it "sets readers" do
-      expect(subject.parent).to eq parent
-      expect(subject.dsl).to eq dsl
-      expect(subject.real).to eq parent_real
-    end
-  end
-end

data/spec/swt_shoes/font_spec.rb

@@ -1,33 +0,0 @@
-require 'swt_shoes/spec_helper'
-
-describe Shoes::Swt::Font do
-
-  subject {Shoes::Swt::Font}
-
-  describe 'Shoes::FONTS' do
-    it 'has the FONTS array initially populared' do
-      Shoes::FONTS.should_not be_empty
-    end
-
-    it 'loads the 2 shoes specific fonts' do
-      Shoes::FONTS.should include("Coolvetica", "Lacuna")
-    end
-  end
-
-  describe '.add_font' do
-    it 'returns nil if no font was found' do
-      subject.add_font('/non/existent/font.ttf').should be_nil
-    end
-
-    it 'returns the font name when the font file is present' do
-      subject.add_font(Shoes::FONT_DIR + 'Coolvetica.ttf').should eq 'Coolvetica'
-    end
-
-    it 'calls the Display#load_font method' do
-      font_path = Shoes::FONT_DIR + 'Coolvetica.ttf'
-      ::Swt.display.should_receive(:load_font).with(font_path)
-      subject.add_font font_path
-    end
-  end
-  
-end

data/spec/swt_shoes/gradient_spec.rb

@@ -1,20 +0,0 @@
-require 'swt_shoes/spec_helper'
-
-describe Shoes::Swt::Gradient do
-  let(:color1) { Shoes::Color.create(Shoes::COLORS[:honeydew]) }
-  let(:color2) { Shoes::Color.create(Shoes::COLORS[:salmon]) }
-  let(:dsl) { Shoes::Gradient.new(color1, color2) }
-
-  subject { Shoes::Swt::Gradient.new(dsl) }
-
-  it_behaves_like "an swt pattern"
-
-   describe "#apply_as_fill" do
-    let(:gc) { double("gc") }
-
-    it "sets background" do
-      gc.should_receive(:set_background_pattern)
-      subject.apply_as_fill(gc, 10, 20, 100, 200)
-    end
-  end 
-end

data/spec/swt_shoes/image_pattern_spec.rb

@@ -1,19 +0,0 @@
-require 'swt_shoes/spec_helper'
-
-describe Shoes::Swt::ImagePattern do
-  let(:path) { File.join Shoes::DIR, 'static/shoes-icon.png'  }
-  let(:dsl) { Shoes::ImagePattern.new(path) }
-
-  subject { Shoes::Swt::ImagePattern.new(dsl) }
-
-  it_behaves_like "an swt pattern"
-
-   describe "#apply_as_fill" do
-    let(:gc) { double("gc") }
-
-    it "sets background" do
-      gc.should_receive(:set_background_pattern)
-      subject.apply_as_fill(gc, 10, 20, 100, 200)
-    end
-  end 
-end

data/spec/swt_shoes/image_spec.rb

@@ -1,100 +0,0 @@
-require 'swt_shoes/spec_helper'
-
-describe Shoes::Swt::Image do
-  include_context "swt app"
-
-  IMAGE_WIDTH = 3
-  IMAGE_HEIGHT = 1
-
-  let(:blk) { double("block") }
-  let(:dsl) { Shoes::Image.new shoes_app, parent_dsl, image, opts}
-  let(:opts) {{left: left, top: top, width: width, height: height}}
-  let(:left) { 100 }
-  let(:top) { 200 }
-  let(:height) { nil }
-  let(:width) {nil}
-  let(:image) { "spec/swt_shoes/minimal.png" }
-
-  subject {
-    dsl.stub(:file_path) { image }
-    Shoes::Swt::Image.new(dsl, parent, blk)
-  }
-
-  it_behaves_like "paintable"
-  it_behaves_like "clearable"
-  it_behaves_like "clickable backend"
-  it_behaves_like "togglable"
-
-  describe "paint callback" do
-    let(:event) { double("event", gc: gc) }
-    let(:gc) { double("gc", drawImage: true) }
-
-    before :each do
-      swt_app.should_receive(:add_paint_listener)
-    end
-
-    specify "draws image" do
-      dsl.stub element_left: left, element_top: top
-      gc.should_receive(:drawImage).with(subject.real, 0, 0, 3, 1, left, top, 3, 1)
-      subject.painter.call(event)
-    end
-  end
-
-  describe "painting raw images" do
-    let(:image) { File.read("spec/swt_shoes/minimal.png", :mode => "rb") }
-
-    specify "loads image from raw data" do
-      subject.real.image_data.width = 3
-      subject.real.image_data.height = 1
-    end
-  end
-
-  # note the image used is 3x1 pixel big
-  describe 'dimensions' do
-
-    it 'has the given width' do
-      subject.width.should == IMAGE_WIDTH
-    end
-
-    it 'has the given height' do
-      subject.height.should == IMAGE_HEIGHT
-    end
-
-    it 'can change its width' do
-      subject.width = 7
-      subject.width.should == 7
-    end
-
-    it 'can change its height' do
-      subject.height = 7
-      subject.height.should == 7
-    end
-
-    describe 'with a given width' do
-      let(:width) {(IMAGE_WIDTH * 5.8).to_i}
-      it 'scales the height' do
-        subject.height.should == (IMAGE_HEIGHT * 5.8).to_i
-      end
-    end
-
-    describe 'with a given height' do
-      let(:height) {IMAGE_HEIGHT * 4}
-
-      it 'scales the width' do
-        subject.width.should == IMAGE_WIDTH * 4
-      end
-    end
-
-    describe 'with a given width and height' do
-      let(:width) {1}
-      let(:height) {2}
-      it 'sets the given width' do
-        subject.width.should == 1
-      end
-
-      it 'sets the given height' do
-        subject.height.should == 2
-      end
-    end
-  end
-end