shoes 4.0.0.pre1 → 4.0.0.pre2

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

@@ -1,48 +0,0 @@
-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
-    lambda { dsl.star(30) }.should raise_error(ArgumentError)
-  end
-
-  describe 'instantiation' do
-    let(:left) {10}
-    let(:top) {20}
-    let(:points) {15}
-    let(:outer) {27}
-    let(:inner) {33}
-    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 '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 '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
-
-  end
-end

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
-    dsl.stroke(color).class.should eq(Shoes::Color)
-  end
-
-  # This works differently on a container than on a normal element
-  it "sets on receiver" do
-    dsl.stroke color
-    dsl.style[:stroke].should eq(color)
-  end
-
-  it "applies to subsequently created objects" do
-    dsl.stroke color
-    Shoes::Oval.should_receive(:new).with do |*args|
-      style = args.pop
-      style[:stroke].should eq(color)
-    end
-    dsl.oval(10, 10, 100, 100)
-  end
-
-  context "with hex string" do
-    let(:color) { "#fff" }
-
-    it "sets the color" do
-      dsl.stroke(color).should 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
-    dsl.strokewidth(4).should eq(4)
-  end
-
-  it "sets on receiver" do
-    dsl.strokewidth 4
-    dsl.style[:strokewidth].should eq(4)
-  end
-
-  it "applies to subsequently created objects" do
-    dsl.strokewidth 6
-    Shoes::Oval.should_receive(:new).with do |*args|
-      style = args.pop
-      style[:strokewidth].should eq(6)
-    end
-    dsl.oval(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
-          element.class.should eq(klass)
-        end
-
-        it "sets size" do
-          element.font_size.should eq(size)
-        end
-
-        it "sets font" do
-          element.font.should eq(font)
-        end
-      end
-    end
-  end
-end

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.font_size).to eql 48
-  end
-
-  it "should set title font size to 34" do
-    text_block = dsl.title("hello!")
-    expect(text_block.font_size).to eql 34
-  end
-
-  it "should set subtitle font size to 26" do
-    text_block = dsl.subtitle("hello!")
-    expect(text_block.font_size).to eql 26
-  end
-
-  it "should set tagline font size to 18" do
-    text_block = dsl.tagline("hello!")
-    expect(text_block.font_size).to eql 18
-  end
-
-  it "should set caption font size to 14" do
-    text_block = dsl.caption("hello!")
-    expect(text_block.font_size).to eql 14
-  end
-
-  it "should set para font size to 12" do
-    text_block = dsl.para("hello!")
-    expect(text_block.font_size).to eql 12
-  end
-
-  it "should set inscription font size to 10" do
-    text_block = dsl.inscription("hello!")
-    expect(text_block.font_size).to eql 10
-  end
-
-  describe 'span' do
-    it 'should parse the color' do
-      span = dsl.span 'Hello', stroke: '#ccc'
-      expect(span.opts[: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.opts[: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.opts[: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_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/shared_element_method.rb

@@ -1,52 +0,0 @@
-require 'shoes/color'
-
-shared_examples_for "object with stroke" do
-  let(:color) { Shoes::COLORS.fetch :tomato }
-
-  specify "returns a color" do
-    c = subject.stroke = color
-    c.class.should eq(Shoes::Color)
-  end
-
-  specify "sets on receiver" do
-    subject.stroke = color
-    subject.stroke.should eq(color)
-    subject.style[:stroke].should eq(color)
-  end
-
-  # Be sure the subject does *not* have the stroke set previously
-  specify "defaults to black" do
-    subject.stroke.should eq(Shoes::COLORS.fetch :black)
-  end
-
-  describe "strokewidth" do
-    specify "defaults to 1" do
-      subject.strokewidth.should eq(1)
-    end
-
-    specify "sets" do
-      subject.strokewidth = 2
-      subject.strokewidth.should 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
-    c.class.should eq(Shoes::Color)
-  end
-
-  specify "sets on receiver" do
-    subject.fill = color
-    subject.fill.should eq(color)
-    subject.style[:fill].should eq(color)
-  end
-
-  # Be sure the subject does *not* have the stroke set previously
-  specify "defaults to black" do
-    subject.fill.should eq(Shoes::COLORS.fetch :black)
-  end
-end

data/spec/shoes/shared_examples/slot.rb

@@ -1,272 +0,0 @@
-require 'shoes/spec_helper'
-
-shared_examples_for "Slot" do
-  it "should be able to append" do
-    subject.contents.should be_empty
-    our_subject = subject
-    app.execute_block Proc.new { our_subject.append {para "foo"} }
-    subject.contents.size.should eq(1)
-  end
-
-  it_behaves_like 'prepending'
-  it_behaves_like 'clearing'
-  it_behaves_like 'element one positioned with bottom and right'
-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 '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 '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
-    my_element.stub 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
-    element.absolute_left.should eq subject.absolute_left + ele_left
-  end
-
-  it 'positions the element at its top value' do
-    element.absolute_top.should 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'
-
-  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
-    element.absolute_top.should eq subject.element_top
-  end
-
-  it 'positions a single object at the same left as self' do
-    element.absolute_left.should eq subject.element_left
-  end
-
-  it 'has a slot height of the element height' do
-    subject.height.should 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
-    element2.absolute_top.should eq element.absolute_bottom + 1
-  end
-
-  it 'still positions it at the start of the line (e.g. self.left)' do
-    element2.absolute_left.should eq subject.absolute_left
-  end
-
-  it 'has a stack height according to its contents' do
-    subject.height.should eq (element.height + element2.height)
-  end
-
-  it 'has an absolute_bottom of top + height' do
-    subject.absolute_bottom.should 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
-        element2.absolute_left.should eq subject.absolute_left
-      end
-
-      it 'has the same absolute top as the slot' do
-        element2.absolute_top.should 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
-    subject.contents_alignment.should eq (element.height + element2.height)
-  end
-
-  it 'still has the same height though' do
-    old_height = subject.height
-    subject.contents_alignment
-    subject.height.should 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
-    element.absolute_left.should eq input_opts[:margin]
-  end
-
-  it 'respects the left margin for the second element' do
-    element2.absolute_left.should eq input_opts[:margin]
-  end
-
-  it 'respects the top margin for the first element' do
-    element.absolute_top.should eq input_opts[:margin]
-  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
-      subject.contents.first.should eq prepend1
-    end
-
-    it 'has a total of 3 elements then' do
-      subject.contents.size.should == 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
-      subject.contents.first.should eq prepend1
-    end
-
-    it 'has prepend2 as the second child' do
-      subject.contents[1].should eq prepend2
-    end
-
-    it 'has a total of 4 children' do
-      subject.contents.size.should == 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
-      subject.contents.first.should eq prepend2
-    end
-
-    it 'has the first prepended element as the second' do
-      subject.contents[1].should eq prepend1
-    end
-
-    it 'has a total of 4 children' do
-      subject.contents.size.should == 4
-    end
-  end
-end
-
-shared_examples_for 'clearing' do
-  include_context 'two slot children'
-
-  describe '#clear' do
-    it 'removes all contents' do
-      subject.clear
-      subject.contents.should be_empty
-    end
-  end
-
-  describe 'Element#remove' do
-    it 'removees the element' do
-      element.parent = subject
-      element.remove
-      subject.contents.should_not include element
-    end
-  end
-end