shoes-swt 4.0.0.pre2 → 4.0.0.pre3

data/spec/shoes/shared_examples/dsl/text_elements.rb

@@ -1,81 +0,0 @@
-shared_examples_for "text element DSL methods" do
-  it "should set banner font size to 48" do
-    text_block = dsl.banner("hello!")
-    expect(text_block.size).to eql 48
-  end
-
-  it "should set title font size to 34" do
-    text_block = dsl.title("hello!")
-    expect(text_block.size).to eql 34
-  end
-
-  it "should set subtitle font size to 26" do
-    text_block = dsl.subtitle("hello!")
-    expect(text_block.size).to eql 26
-  end
-
-  it "should set tagline font size to 18" do
-    text_block = dsl.tagline("hello!")
-    expect(text_block.size).to eql 18
-  end
-
-  it "should set caption font size to 14" do
-    text_block = dsl.caption("hello!")
-    expect(text_block.size).to eql 14
-  end
-
-  it "should set para font size to 12" do
-    text_block = dsl.para("hello!")
-    expect(text_block.size).to eql 12
-  end
-
-  it "should set inscription font size to 10" do
-    text_block = dsl.inscription("hello!")
-    expect(text_block.size).to eql 10
-  end
-
-  describe 'span' do
-    it 'should parse the color' do
-      span = dsl.span 'Hello', stroke: '#ccc'
-      expect(span.style[:stroke]).to eq Shoes::Color.new 204, 204, 204
-    end
-
-    it 'should handle a splatted array of links' do
-      expect{dsl.span *[dsl.link('foo'), dsl.link('foo')]}.not_to raise_error
-    end
-
-    it 'should handle a splatted array of links and parse the color' do
-      span = dsl.span *[dsl.link('foo'), dsl.link('foo')], stroke: '#ccc'
-      expect(span.style[:stroke]).to eq Shoes::Color.new 204, 204, 204
-    end
-
-    it 'should handle a splatted array of links with a block' do
-      link = dsl.link('foo') { "Bar" }
-      expect{dsl.span *[link, link]}.not_to raise_error
-    end
-  end
-
-  describe 'link' do
-    it 'handles multiple texts' do
-      link = dsl.link('one', 'two')
-      expect(link.to_s).to eql('onetwo')
-    end
-
-    it 'handles trailing options' do
-      link = dsl.link('one', 'two', stroke: '#ccc')
-      expect(link.to_s).to eql('onetwo')
-      expect(link.style[:stroke]).to eq Shoes::Color.new 204, 204, 204
-    end
-  end
-
-  describe 'para' do
-    context "with nested text fragments with parameters" do
-      Shoes::DSL::TEXT_STYLES.keys.each do |style|
-        it "handles opts properly for #{style}" do
-          para = dsl.para(dsl.send(style, style, stroke: '#ccc'))
-          expect(para.text).to eq(style.to_s)
-        end
-      end
-    end
-  end
-end

data/spec/shoes/shared_examples/dsl/video.rb

@@ -1,5 +0,0 @@
-shared_examples_for 'video DSL method' do
-  it 'throws a Shoes::NotImplementedError' do
-    expect{dsl.video}.to raise_error Shoes::NotImplementedError
-  end
-end

data/spec/shoes/shared_examples/dsl_app_context.rb

@@ -1,8 +0,0 @@
-shared_context "dsl app" do
-  let(:input_block) { Proc.new {} }
-  let(:input_opts) { Hash.new }
-  let(:user_facing_app) { Shoes::App.new input_opts, &input_block }
-  let(:app) { user_facing_app.instance_variable_get(:@__app__) }
-  let(:parent) { Shoes::Flow.new app, app }
-end
-

data/spec/shoes/shared_examples/hover_leave.rb

@@ -1,11 +0,0 @@
-shared_examples "hover and leave events" do
-  let(:proc) {Proc.new do end}
-
-  it 'can execute hover without raising an error' do
-    expect{subject.hover proc}.not_to raise_error
-  end
-
-  it 'can execute leave without raising an error' do
-    expect{subject.leave proc}.not_to raise_error
-  end
-end

data/spec/shoes/shared_examples/parent.rb

@@ -1,6 +0,0 @@
-# requires you to provide a let(:parent)
-shared_examples_for 'object with parent' do
-  it 'has a getter for the parent' do
-    expect(subject.parent).to eq parent
-  end
-end

data/spec/shoes/shared_examples/scroll.rb

@@ -1,41 +0,0 @@
-shared_examples_for "scrollable slot" do
-  its(:scroll) { should be_truthy }
-  it "initializes scroll_top to 0" do
-    expect(subject.scroll_top).to eq(0)
-  end
-end
-
-shared_examples_for "scrollable slot with overflowing content" do
-  it "retains the same height" do
-    expect(subject.height).to eq(height)
-  end
-
-  it "has scroll_height larger than height" do
-    expect(subject.scroll_height).to be > height
-  end
-
-  it "has scroll_max = (scroll_height - height)" do
-    expect(subject.scroll_max).to eq(subject.scroll_height - subject.height)
-  end
-
-  it 'adjusts scroll_top' do
-    expect(subject.scroll_top).to eq(new_position)
-  end
-end
-
-shared_context "scroll" do
-  let(:height) { 200 }
-  let(:input_opts) { {left: 40, top: 20, width: 400, height: height} }
-  let(:opts) { input_opts.merge(scroll: scroll) }
-end
-
-shared_context "overflowing content" do
-  let(:new_position) { 300 }
-
-  before :each do
-    200.times do
-      Shoes::TextBlock.new(app, subject, "Fourteen fat chimichangas", size: 18)
-    end
-    subject.scroll_top = new_position
-  end
-end

data/spec/shoes/shared_examples/shared_element_method.rb

@@ -1,60 +0,0 @@
-require 'shoes/color'
-
-shared_examples_for "object with stroke" do
-  let(:color) { Shoes::COLORS.fetch :tomato }
-  let(:color2) { Shoes::COLORS.fetch :forestgreen }
-  let(:gradient) { Shoes::Gradient.new(color, color2) }
-
-  specify "returns a color" do
-    c = subject.stroke = color
-    expect(c.class).to eq(Shoes::Color)
-  end
-
-  specify "sets on receiver" do
-    subject.stroke = color
-    expect(subject.stroke).to eq(color)
-    expect(subject.style[:stroke]).to eq(color)
-  end
-
-  specify "sets with a gradient" do
-    subject.stroke = gradient
-    expect(subject.stroke).to eq(gradient)
-    expect(subject.style[:stroke]).to eq(gradient)
-  end
-
-  # Be sure the subject does *not* have the stroke set previously
-  specify "defaults to black" do
-    expect(subject.stroke).to eq(Shoes::COLORS.fetch :black)
-  end
-
-  describe "strokewidth" do
-    specify "defaults to 1" do
-      expect(subject.strokewidth).to eq(1)
-    end
-
-    specify "sets" do
-      subject.strokewidth = 2
-      expect(subject.strokewidth).to eq(2)
-    end
-  end
-end
-
-shared_examples_for "object with fill" do
-  let(:color) { Shoes::COLORS.fetch :honeydew }
-
-  specify "returns a color" do
-    c = subject.fill = color
-    expect(c.class).to eq(Shoes::Color)
-  end
-
-  specify "sets on receiver" do
-    subject.fill = color
-    expect(subject.fill).to eq(color)
-    expect(subject.style[:fill]).to eq(color)
-  end
-
-  # Be sure the subject does *not* have the stroke set previously
-  specify "defaults to black" do
-    expect(subject.fill).to eq(Shoes::COLORS.fetch :black)
-  end
-end

data/spec/shoes/shared_examples/slot.rb

@@ -1,331 +0,0 @@
-shared_examples_for "Slot" do
-  it "should be able to append" do
-    expect(subject.contents).to be_empty
-    our_subject = subject
-    app.execute_block Proc.new { our_subject.append {para "foo"} }
-    expect(subject.contents.size).to eq(1)
-  end
-
-  it 'has a height of 0 as it is empty although it has a top' do
-    subject.absolute_top = 100
-    subject.contents_alignment
-    expect(subject.height).to eq 0
-  end
-
-  it_behaves_like 'prepending'
-  it_behaves_like 'clearing'
-  it_behaves_like 'element one positioned with bottom and right'
-  it_behaves_like 'growing although relatively positioned elements'
-end
-
-shared_context 'one slot child' do
-  let(:ele_opts) {Hash.new}
-  let(:element) {Shoes::FakeElement.new(nil, {height: 100,width: 50}.merge(ele_opts))}
-
-  before :each do
-    subject.add_child element
-  end
-end
-
-shared_context 'two slot children' do
-  include_context 'one slot child'
-  let(:element2) {Shoes::FakeElement.new nil, height: 200, width: 70}
-
-  before :each do
-    subject.add_child element2
-  end
-end
-
-shared_context 'hidden child' do
-  let(:hidden_element) {Shoes::FakeElement.new nil, height: 200, width: 70}
-
-  before :each do
-    subject.add_child hidden_element
-    hidden_element.gui = double("hidden gui", update_visibility: nil)
-    hidden_element.hide
-  end
-end
-
-shared_context 'three slot children' do
-  include_context 'two slot children'
-  let(:element3) {Shoes::FakeElement.new(nil, height: 50, width: 20)}
-
-  before :each do
-    subject.add_child element3
-  end
-end
-
-shared_context 'contents_alignment' do
-  before :each do
-    subject.contents_alignment
-  end
-end
-
-shared_context 'element one with top and left' do
-  let(:ele_top) {22}
-  let(:ele_left) {47}
-  let(:ele_opts) {{left: ele_left, top: ele_top}}
-end
-
-shared_context 'slot with set height and width' do
-  let(:input_opts) {{width: 250, height: 300}}
-end
-
-shared_context 'element one with bottom and right' do
-  let(:ele_bottom) {24}
-  let(:ele_right) {49}
-  let(:ele_opts) {{right: ele_right, bottom: ele_bottom}}
-end
-
-shared_examples_for 'positioning through :_position' do
-
-  let(:element) {Shoes::FakeElement.new nil, height: 100, width: 50}
-
-  def add_child_and_align
-    subject.add_child element
-    subject.contents_alignment
-  end
-
-  it 'sends the child the :_position method to position it' do
-    expect(element).to receive(:_position).and_call_original
-    add_child_and_align
-  end
-
-  it 'does not send _position again if the position did not change' do
-    add_child_and_align
-    expect(element).not_to receive(:_position)
-    subject.contents_alignment
-  end
-
-  it 'does not position an element if it does not need positioning' do
-    my_element = element
-    allow(my_element).to receive_messages needs_to_be_positioned?: false
-    expect(my_element).not_to receive :_position
-    subject.add_child my_element
-    subject.contents_alignment
-  end
-end
-
-shared_examples_for 'element one positioned with top and left' do
-  it 'positions the element at its left value' do
-    expect(element.absolute_left).to eq subject.absolute_left + ele_left
-  end
-
-  it 'positions the element at its top value' do
-    expect(element.absolute_top).to eq subject.absolute_top + ele_top
-  end
-end
-
-shared_examples_for 'element one positioned with bottom and right' do
-  include_context 'one slot child'
-  include_context 'contents_alignment'
-  include_context 'element one with bottom and right'
-  include_context 'slot with set height and width'
-
-  it 'positions the element from its right' do
-    expect(element.absolute_right).to eq (subject.absolute_right - ele_right - 1)
-  end
-
-  it 'positions the element from its bottom' do
-    expect(element.absolute_bottom).to eq (subject.absolute_bottom - ele_bottom - 1)
-  end
-end
-
-shared_examples_for 'positions the first element in the top left' do
-  include_context 'one slot child'
-  include_context 'contents_alignment'
-  it 'positions a single object at the same top as self' do
-    expect(element.absolute_top).to eq subject.element_top
-  end
-
-  it 'positions a single object at the same left as self' do
-    expect(element.absolute_left).to eq subject.element_left
-  end
-
-  it 'has a slot height of the element height' do
-    expect(subject.height).to eq element.height
-  end
-
-  describe 'top and left' do
-    include_context 'element one with top and left'
-    it_behaves_like 'element one positioned with top and left'
-  end
-end
-
-shared_examples_for 'arranges elements underneath each other' do
-  include_context 'two slot children'
-  include_context 'contents_alignment'
-
-  it 'positions an element beneath a previous element' do
-    expect(element2.absolute_top).to eq element.absolute_bottom + 1
-  end
-
-  it 'still positions it at the start of the line (e.g. self.left)' do
-    expect(element2.absolute_left).to eq subject.absolute_left
-  end
-
-  it 'has a stack height according to its contents' do
-    expect(subject.height).to eq (element.height + element2.height)
-  end
-
-  it 'has an absolute_bottom of top + height' do
-    expect(subject.absolute_bottom).to eq (subject.absolute_top + subject.height - 1)
-  end
-
-  describe 'element one with top and left' do
-    include_context 'element one with top and left'
-    it_behaves_like 'element one positioned with top and left'
-
-    describe 'positions element2 disregarding element1' do
-      it 'has the same absolute left as the slot' do
-        expect(element2.absolute_left).to eq subject.absolute_left
-      end
-
-      it 'has the same absolute top as the slot' do
-        expect(element2.absolute_top).to eq subject.absolute_top
-      end
-    end
-  end
-end
-
-shared_examples_for 'set height and contents alignment' do
-  include_context 'two slot children'
-
-  it 'contents_alignment returns the height of the content' do
-    expect(subject.contents_alignment).to eq (element.height + element2.height)
-  end
-
-  it 'still has the same height though' do
-    old_height = subject.height
-    subject.contents_alignment
-    expect(subject.height).to eq old_height
-  end
-end
-
-shared_examples_for 'taking care of margin' do
-  include_context 'two slot children'
-  include_context 'contents_alignment'
-
-  it 'respects the left margin for the first element' do
-    expect(element.absolute_left).to eq input_opts[:margin]
-  end
-
-  it 'respects the left margin for the second element' do
-    expect(element2.absolute_left).to eq input_opts[:margin]
-  end
-
-  it 'respects the top margin for the first element' do
-    expect(element.absolute_top).to eq input_opts[:margin]
-  end
-end
-
-shared_examples_for 'growing although relatively positioned elements' do
-  include_context 'one slot child'
-  include_context 'contents_alignment'
-
-  describe 'positioned at the very beginning' do
-    let(:ele_opts) {{top: 0}}
-
-    it 'grows the slot height' do
-      expect(subject.height).to eq element.height
-    end
-  end
-
-  describe 'positioned with a good offset' do
-    let(:ele_opts) {{top: 70}}
-
-    it 'grows the height even further' do
-      expect(subject.height).to eq element.height + 70
-    end
-  end
-
-  describe 'positioning with hidden elements' do
-    include_context 'hidden child'
-
-    it 'grows only to height of first child' do
-      subject.contents_alignment
-      expect(subject.height).to eq element.height
-    end
-  end
-end
-
-shared_examples_for 'prepending' do
-  include_context 'two slot children'
-  let(:prepend1) {double 'prepend1'}
-  let(:prepend2) {double 'prepend2'}
-
-  describe 'one element' do
-    before :each do
-      subject.prepend do
-        subject.add_child prepend1
-      end
-    end
-
-    it 'as the first' do
-      expect(subject.contents.first).to eq prepend1
-    end
-
-    it 'has a total of 3 elements then' do
-      expect(subject.contents.size).to eq(3)
-    end
-  end
-
-  describe 'two elements' do
-    before :each do
-      subject.prepend do
-        subject.add_child prepend1
-        subject.add_child prepend2
-      end
-    end
-
-    it 'has prepend1 as the first child' do
-      expect(subject.contents.first).to eq prepend1
-    end
-
-    it 'has prepend2 as the second child' do
-      expect(subject.contents[1]).to eq prepend2
-    end
-
-    it 'has a total of 4 children' do
-      expect(subject.contents.size).to eq(4)
-    end
-  end
-
-  describe 'two times' do
-    before :each do
-      subject.prepend { subject.add_child prepend1 }
-      subject.prepend {subject.add_child prepend2 }
-    end
-
-    it 'has the last prepended element as the first' do
-      expect(subject.contents.first).to eq prepend2
-    end
-
-    it 'has the first prepended element as the second' do
-      expect(subject.contents[1]).to eq prepend1
-    end
-
-    it 'has a total of 4 children' do
-      expect(subject.contents.size).to eq(4)
-    end
-  end
-end
-
-shared_examples_for 'clearing' do
-  include_context 'two slot children'
-
-  describe '#clear' do
-    it 'removes all contents' do
-      subject.clear
-      expect(subject.contents).to be_empty
-    end
-  end
-
-  describe 'Element#remove' do
-    it 'removees the element' do
-      element.parent = subject
-      element.remove
-      expect(subject.contents).not_to include element
-    end
-  end
-end