shoes-core 4.0.0.pre3

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

@@ -0,0 +1,111 @@
+shared_examples_for "star DSL method" do
+  it "creates a Shoes::Star" do
+    expect(dsl.star(30, 20)).to be_an_instance_of(Shoes::Star)
+  end
+
+  it "raises an ArgumentError with just one argument" do
+    expect { dsl.star(30) }.to raise_error(ArgumentError)
+  end
+
+  describe 'instantiation' do
+    let(:left) {10}
+    let(:top) {20}
+    let(:points) {15}
+    let(:outer) {27}
+    let(:inner) {33}
+    let(:clickable) { proc { } }
+
+    DEFAULT_POINTS = 10
+    DEFAULT_OUTER = 100.0
+    DEFAULT_INNER = 50.0
+
+    describe '2 arguments' do
+      subject {dsl.star left, top}
+      its(:left) {should eq left}
+      its(:top) {should eq top}
+      its(:points) {should eq DEFAULT_POINTS}
+      its(:outer) {should eq DEFAULT_OUTER}
+      its(:inner) {should eq DEFAULT_INNER}
+    end
+
+    describe '2 arguments with hash' do
+      subject { dsl.star left, top, click: clickable }
+      its(:left)   {should eq left}
+      its(:top)    {should eq top}
+      its(:points) {should eq DEFAULT_POINTS}
+      its(:outer)  {should eq DEFAULT_OUTER}
+      its(:inner)  {should eq DEFAULT_INNER}
+
+      it "gets the click" do
+        expect(subject.style[:click]).to eq(clickable)
+      end
+    end
+
+    describe '3 arguments with hash' do
+      subject { dsl.star left, top, points, click: clickable }
+      its(:left)   {should eq left}
+      its(:top)    {should eq top}
+      its(:points) {should eq points}
+      its(:outer)  {should eq DEFAULT_OUTER}
+      its(:inner)  {should eq DEFAULT_INNER}
+
+      it "gets the click" do
+        expect(subject.style[:click]).to eq(clickable)
+      end
+    end
+
+    describe '4 arguments' do
+      subject {dsl.star left, top, points, outer}
+      its(:left) {should eq left}
+      its(:top) {should eq top}
+      its(:points) {should eq points}
+      its(:outer) {should eq outer}
+      its(:inner) {should eq DEFAULT_INNER}
+    end
+
+    describe '4 arguments with hash' do
+      subject { dsl.star left, top, points, outer, click: clickable }
+      its(:left)   {should eq left}
+      its(:top)    {should eq top}
+      its(:points) {should eq points}
+      its(:outer)  {should eq outer}
+      its(:inner)  {should eq DEFAULT_INNER}
+
+      it "gets the click" do
+        expect(subject.style[:click]).to eq(clickable)
+      end
+    end
+
+    describe '5 arguments' do
+      subject {dsl.star left, top, points, outer, inner}
+      its(:left) {should eq left}
+      its(:top) {should eq top}
+      its(:points) {should eq points}
+      its(:outer) {should eq outer}
+      its(:inner) {should eq inner}
+    end
+
+    describe '5 arguments with hash' do
+      subject { dsl.star left, top, points, outer, inner, click: clickable }
+      its(:left)   {should eq left}
+      its(:top)    {should eq top}
+      its(:points) {should eq points}
+      its(:outer)  {should eq outer}
+      its(:inner)  {should eq inner}
+
+      it "gets the click" do
+        expect(subject.style[:click]).to eq(clickable)
+      end
+    end
+
+    describe 'too many arguments' do
+      oops = 1000
+      subject { dsl.star left, top, points, outer, inner, oops }
+
+      it "raises on construction" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,30 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,6 @@
+# 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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,60 @@
+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

@@ -0,0 +1,394 @@
+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'
+  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
+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 '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
+  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