shoes-core 4.0.0.pre7 → 4.0.0.pre8

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

@@ -1,30 +0,0 @@
-shared_examples_for "stroke DSL method" do
-  let(:color) { Shoes::COLORS.fetch :tomato }
-
-  it "returns a color" do
-    expect(dsl.stroke(color).class).to eq(Shoes::Color)
-  end
-
-  # This works differently on a container than on a normal element
-  it "sets on receiver" do
-    dsl.stroke color
-    expect(dsl.style[:stroke]).to eq(color)
-  end
-
-  it "applies to subsequently created objects" do
-    dsl.stroke color
-    expect(Shoes::Rect).to receive(:new) do |*args|
-      style = args[-2]
-      expect(style[:stroke]).to eq(color)
-    end
-    dsl.rect(10, 10, 100, 100)
-  end
-
-  context "with hex string" do
-    let(:color) { "#fff" }
-
-    it "sets the color" do
-      expect(dsl.stroke(color)).to eq(Shoes::COLORS[:white])
-    end
-  end
-end

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

@@ -1,19 +0,0 @@
-shared_examples_for "strokewidth DSL method" do
-  it "returns a number" do
-    expect(dsl.strokewidth(4)).to eq(4)
-  end
-
-  it "sets on receiver" do
-    dsl.strokewidth 4
-    expect(dsl.style[:strokewidth]).to eq(4)
-  end
-
-  it "applies to subsequently created objects" do
-    dsl.strokewidth 6
-    expect(Shoes::Rect).to receive(:new) do |*args|
-      style = args[-2]
-      expect(style[:strokewidth]).to eq(6)
-    end
-    dsl.rect(10, 10, 100, 100)
-  end
-end

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

@@ -1,32 +0,0 @@
-shared_examples_for "style DSL method" do
-  describe "setting new defaults for text block" do
-    let(:stroke) { Shoes::COLORS[:chartreuse] }
-    let(:size)   { 42 }
-    let(:fill)   { Shoes::COLORS[:peru] }
-    let(:font)   { "SOME FONT" }
-    let(:style)  { {stroke: stroke, size: size, fill: fill, font: font} }
-
-    %w(Banner Title Subtitle Tagline Caption Para Inscription).each do |text_block|
-      describe text_block do
-        let(:element) { dsl.public_send text_block.downcase, "Hello!" }
-        let(:klass) { Shoes.const_get(text_block) }
-
-        before :each do
-          dsl.style klass, style
-        end
-
-        it "creates element with appropriate class" do
-          expect(element.class).to eq(klass)
-        end
-
-        it "sets size" do
-          expect(element.size).to eq(size)
-        end
-
-        it "sets font" do
-          expect(element.font).to eq(font)
-        end
-      end
-    end
-  end
-end

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

@@ -1,84 +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
-    let(:link_array) { [dsl.link('foo'), dsl.link('foo')] }
-
-    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(*link_array) }.not_to raise_error
-    end
-
-    it 'should handle a splatted array of links and parse the color' do
-      span = dsl.span(*link_array, 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" }
-      array = [link, link]
-      expect { dsl.span(*array) }.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,11 +0,0 @@
-shared_context "dsl app" do
-  let(:input_block) { proc {} }
-  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) do
-    Shoes::Flow.new app, app,
-                    width: Shoes::InternalApp::DEFAULT_OPTIONS[:width],
-                    height: Shoes::InternalApp::DEFAULT_OPTIONS[:height]
-  end
-end

data/spec/shoes/shared_examples/hover.rb

@@ -1,78 +0,0 @@
-shared_examples "object with hover" do
-  let(:teal) { Shoes::COLORS[:teal] }
-  let(:gold) { Shoes::COLORS[:gold] }
-
-  let(:hover_class) { subject.hover_class }
-
-  it "registers hover" do
-    expect(subject).to receive(:add_mouse_hover_control)
-    subject.hover {}
-  end
-
-  it "registers with leave" do
-    expect(subject).to receive(:add_mouse_hover_control)
-    subject.leave {}
-  end
-
-  it "marks itself as hovered" do
-    subject.mouse_hovered
-    expect(subject.hovered?).to eq(true)
-  end
-
-  it "marks itself not hovered after leaving" do
-    subject.mouse_hovered
-    expect(subject.hovered?).to eq(true)
-
-    subject.mouse_left
-    expect(subject.hovered?).to eq(false)
-  end
-
-  it "only calls hover block once" do
-    count = 0
-    subject.hover do
-      count += 1
-    end
-
-    subject.mouse_hovered
-    subject.mouse_hovered
-
-    expect(count).to eq(1)
-  end
-
-  it "only calls leave block once after we're hovering" do
-    count = 0
-    subject.leave do
-      count += 1
-    end
-
-    subject.mouse_hovered
-    subject.mouse_left
-    subject.mouse_left
-
-    expect(count).to eq(1)
-  end
-
-  it "doesn't update styles on hover by default" do
-    original_style = subject.style.dup
-    subject.mouse_hovered
-
-    expect(subject.style).to eq(original_style)
-  end
-
-  it "updates styles on hover" do
-    user_facing_app.style(hover_class, stroke: teal)
-
-    subject.mouse_hovered
-    expect(subject.style[:stroke]).to eq(teal)
-  end
-
-  it "restores style after hover's done" do
-    user_facing_app.style(hover_class, stroke: teal)
-
-    subject.style[:stroke] = gold
-    subject.mouse_hovered
-    subject.mouse_left
-
-    expect(subject.style[:stroke]).to eq(gold)
-  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,441 +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 { 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'
-  it_behaves_like 'margin and positioning'
-  it_behaves_like 'margin with a relative positioned child'
-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 'slot with a top margin' do
-  let(:margin_top) { 70 }
-  let(:input_opts) { {margin_top: margin_top} }
-end
-
-shared_context 'slot with a left margin' do
-  let(:margin_left) { 30 }
-  let(:input_opts) { {margin_left: margin_left} }
-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 send _position if element does not need positioning' do
-    allow(element).to receive(:takes_up_space?)    { false }
-    allow(element).to receive(:needs_positioning?) { false }
-    expect(element).not_to receive(:_position)
-    add_child_and_align
-  end
-
-  it 'sends _position even when element does not take up space' do
-    allow(element).to receive(:takes_up_space?)    { false }
-    allow(element).to receive(:needs_positioning?) { true }
-    expect(element).to receive(:_position).and_call_original
-    add_child_and_align
-  end
-
-  it 'is resilient to exceptions during positioning' do
-    allow(element).to receive(:contents_alignment).and_raise("O_o")
-    allow(subject).to receive(:puts) # Quiet, you
-    add_child_and_align
-  end
-
-  describe 'attached' do
-    let(:attached_to) { double('attached slot', absolute_left: 101, absolute_top: 101) }
-    let(:element) { Shoes::FakeElement.new nil }
-
-    it "gets positioned where it's attached" do
-      element.style[:attach] = attached_to
-      expect(element).to receive(:_position).with(101, 101).at_least(1)
-      add_child_and_align
-    end
-  end
-
-  describe 'absolute dimensions' do
-    let(:element) { Shoes::FakeAbsoluteElement.new }
-
-    it 'positions element via _position' do
-      expect(element).to receive(:_position).and_call_original
-      add_child_and_align
-    end
-  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) { Shoes::FakeElement.new(nil, width: 100) }
-  let(:prepend2) { Shoes::FakeElement.new(nil, width: 100) }
-
-  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 'removes the element' do
-      element.parent = subject
-      element.remove
-      expect(subject.contents).not_to include element
-    end
-  end
-end
-
-shared_examples_for 'margin with a relative positioned child' do
-  include_context 'one slot child'
-  include_context 'element one with top and left'
-  include_context 'contents_alignment'
-
-  describe 'margin top' do
-    include_context 'slot with a top margin'
-
-    it 'positions the first element taking the top margin into account' do
-      expect(element.absolute_top).to eq ele_top + margin_top
-    end
-
-    it 'still keeps the left value intact (only margin_top)' do
-      expect(element.absolute_left).to eq ele_left
-    end
-  end
-
-  describe 'left margin' do
-    include_context 'slot with a left margin'
-
-    it 'positions the element to take the left margin into account' do
-      expect(element.absolute_left).to eq ele_left + margin_left
-    end
-
-    it 'keeps the top margin intact' do
-      expect(element.absolute_top).to eq ele_top
-    end
-  end
-end
-
-shared_examples_for 'margin and positioning' do
-  include_context 'one slot child'
-  include_context 'contents_alignment'
-
-  describe 'margin top' do
-    include_context 'slot with a top margin'
-
-    it 'positions the element after margin_top' do
-      expect(element.absolute_top).to eq margin_top
-    end
-
-    it 'leaves the left value as zero' do
-      expect(element.absolute_left).to eq 0
-    end
-
-    it 'sets the slot element_height to the height of the child + adjustment' do
-      expect(subject.element_height).to eq element.height
-    end
-
-    it 'sets the slot total height to element height + margin' do
-      expect(subject.height).to eq element.height + margin_top
-    end
-  end
-
-  describe 'margin left' do
-    include_context 'slot with a left margin'
-
-    it 'positions the element after margin_left' do
-      expect(element.absolute_left).to eq margin_left
-    end
-
-    it 'leaves the top value as zero' do
-      expect(element.absolute_top).to eq 0
-    end
-  end
-end