shoes-dsl 4.0.0.pre2

data/spec/shoes/shared_examples/state.rb

@@ -0,0 +1,19 @@
+shared_examples_for "object with state" do
+  let(:input_opts) { {:state => "disabled"} }
+
+  it "should initialize" do
+    expect(subject.state).to eq("disabled")
+  end
+
+  it "should enable" do
+    expect(subject.gui).to receive(:enabled).with(true)
+    subject.state = nil
+    expect(subject.state).to eq(nil) 
+  end
+
+  it "should disable" do
+    expect(subject.gui).to receive(:enabled).with(false)
+    subject.state = "disabled"
+    expect(subject.state).to eq("disabled")
+  end
+end

data/spec/shoes/shared_examples/style.rb

@@ -0,0 +1,82 @@
+shared_examples_for "object with style" do
+
+  def uses_app_default?(key)
+    if defined? self.class::STYLES
+      subject.style[key] && !subject.class::STYLES[key]
+    else
+      subject.style[key]
+    end
+  end
+
+  describe 'using app-level styles' do
+    
+    it 'initially uses app defaults' do
+      app.style.each do |key, value|
+        expect(subject.style[key]).to eq(value) if uses_app_default? key
+      end
+    end
+
+    it 'overwrites app defaults' do
+      subject.style(fill: '#fff')
+      expect(subject.style[:fill]).not_to eq(app.style[:fill])
+    end
+  end
+
+  describe 'using element-level styles' do
+    let(:arg_styles) { {jellybean: 'blueberry'} }
+
+    it 'uses element defaults' do
+      user_facing_app.style(subject.class, jellybean: 'pumpkin')
+      expect(subject_without_style.style[:jellybean]).to eq('pumpkin')
+    end
+
+    it 'overwrites element defaults' do
+      user_facing_app.style(subject.class, jellybean: 'pumpkin')
+      expect(subject_with_style.style[:jellybean]).to eq('blueberry')
+    end
+  end
+
+  describe 'using the style method' do
+
+    it "merges new styles" do
+      old_style = subject.style
+      subject.style(left: 100, top: 50)
+      expect(subject.style).to eq(old_style.merge(left: 100, top: 50))
+    end
+
+    it 'calls update_style when the style is changed' do
+      allow(subject).to receive(:update_style)
+      subject.style left: 50
+      expect(subject).to have_received(:update_style)
+    end
+
+    it 'does not call update_style when style is called without args' do
+      allow(subject).to receive(:update_style)
+      subject.style
+      expect(subject).not_to have_received(:update_style)
+    end
+
+    it 'does not call update_style when style is unchanged' do
+      allow(subject).to receive(:update_style)
+      old_left = subject.style[:left]
+      subject.style(left: old_left)
+      expect(subject).not_to have_received(:update_style)
+    end
+  end
+
+  describe 'using setters and getters' do
+
+    it 'has a style setter for all styles' do
+      subject.supported_styles.each do |style|
+        expect(subject).to respond_to("#{style}=".to_sym)
+      end
+    end
+
+    it 'has a style getter for all styles' do
+      subject.supported_styles.each do |style|
+        expect(subject).to respond_to("#{style}".to_sym)
+      end
+    end
+  end
+
+end

data/spec/shoes/slot_spec.rb

@@ -0,0 +1,130 @@
+require 'shoes/spec_helper'
+
+describe Shoes::Slot do
+  include_context "dsl app"
+  let(:parent) { app }
+
+  let(:left) { 44 }
+  let(:top) { 66 }
+  let(:width) { 111 }
+  let(:height) { 333 }
+  let(:input_opts) { {left: left, top: top, width: width, height: height} }
+  subject(:slot) { Shoes::Slot.new(app, parent, input_opts) }
+
+  it_behaves_like "object with dimensions"
+
+  it_behaves_like "object with style" do
+    let(:subject_without_style) { Shoes::Slot.new(app, parent) }
+    let(:subject_with_style) { Shoes::Slot.new(app, parent, arg_styles) }
+  end
+
+  describe "relative dimensions from parent" do
+    subject { Shoes::Slot.new(app, parent, relative_opts) }
+    it_behaves_like "object with relative dimensions"
+  end
+
+  describe "negative dimensions" do
+    subject { Shoes::Slot.new(app, parent, negative_opts) }
+    it_behaves_like "object with negative dimensions"
+  end
+
+  describe '#clear' do
+
+    def add_text_block
+      Shoes::TextBlock.new app, slot, ['text']
+    end
+
+    before :each do
+      10.times do
+        add_text_block
+      end
+    end
+
+    it 'sends remove to all children' do
+      subject.contents.each do |element|
+        expect(element).to receive(:remove).and_call_original
+      end
+      subject.clear
+    end
+
+    it 'removes everything' do
+      subject.clear
+      expect(subject.contents).to be_empty
+    end
+
+    describe 'with a block' do
+      before :each do
+        subject.clear {add_text_block}
+      end
+
+      it 'has one element afterwards' do
+        expect(subject.contents.size).to eq 1
+      end
+    end
+
+  end
+
+  describe '#remove_child' do
+    let(:element) {Shoes::FakeElement.new subject}
+
+    before :each do
+      subject.add_child element
+    end
+
+    it 'removes the element' do
+      subject.remove_child element
+      expect(subject.contents).to be_empty
+    end
+
+    describe '2 elements' do
+      let(:element2) {Shoes::FakeElement.new subject}
+
+      before :each do
+        subject.add_child element2
+        subject.remove_child element
+      end
+
+      it 'has one element remaining' do
+        expect(subject.contents.size).to eq 1
+      end
+
+      it 'has the second element remaining' do
+        expect(subject.contents).to include element2
+      end
+    end
+  end
+
+  describe "hover" do
+    let(:callable) { double("block", call: nil) }
+    let(:block)    { Proc.new { callable.call } }
+
+    it "doesn't need hover proc to be called" do
+      expect(callable).to_not receive(:call)
+      subject.mouse_hovered
+    end
+
+    it "calls block on mouse_hovered" do
+      expect(callable).to receive(:call)
+
+      subject.hover(block)
+      subject.mouse_hovered
+    end
+  end
+
+  describe "leave" do
+    let(:callable) { double("block", call: nil) }
+    let(:block)    { Proc.new { callable.call } }
+
+    it "doesn't need leave proc to be called" do
+      expect(callable).to_not receive(:call)
+      subject.mouse_left
+    end
+
+    it "calls block on mouse_left" do
+      expect(callable).to receive(:call)
+
+      subject.leave(block)
+      subject.mouse_left
+    end
+  end
+end

data/spec/shoes/sound_spec.rb

@@ -0,0 +1,15 @@
+require 'shoes/spec_helper'
+
+describe Shoes::Sound do
+  let(:parent) { double("parent") }
+  let(:filepath) { "../../samples/sounds/61847__simon-rue__boink-v3.wav" }
+  subject { Shoes::Sound.new(parent, filepath) }
+
+  its(:filepath) { should eq(filepath) }
+  its(:parent) { should be(parent) }
+
+  it "delegates play to gui" do
+    expect(subject.gui).to receive(:play)
+    subject.play
+  end
+end

data/spec/shoes/span_spec.rb

@@ -0,0 +1,112 @@
+require 'shoes/spec_helper'
+
+describe Shoes::Span do
+  let(:app) { Shoes::App.new }
+  let(:style) { {} }
+  let(:text) { ['test'] }
+  subject(:span) { Shoes::Span.new(text, style) }
+
+  describe 'span' do
+    include InspectHelpers
+
+    it 'sets style to Span block' do
+      expect(app.style[:strikethrough]).not_to be_truthy
+
+      style = { strikethrough: true }
+      result = app.span('test', style)
+      expect(result.style[:strikethrough]).to be_truthy
+
+      expect(app.style[:strikethrough]).not_to be_truthy
+    end
+
+    it 'displays text for #to_s' do
+      expect(span.to_s).to eq(text.join)
+    end
+
+    it 'displays (Shoes::Span:0x01234567 "text") for #inspect' do
+      expect(span.inspect).to match(/[(]Shoes::Span:#{shoes_object_id_pattern} "#{text.join}"[)]/)
+    end
+  end
+
+  describe 'Looking up styles of the parent text' do
+    let(:white) {Shoes::COLORS[:white]}
+    let(:red) {Shoes::COLORS[:red]}
+    it 'does not try to merge with parent style when there are none' do
+      parent = double 'parent'
+      span.parent_text = parent
+      expect {span.style}.to_not raise_error()
+    end
+
+    it 'merges with the styles of the parent text' do
+      parent = double 'parent', style: {stroke: white}
+      span.parent_text = parent
+      expect(span.style[:stroke]).to eq(white)
+    end
+
+    describe 'with own style' do
+      let(:style) {{stroke: red}}
+      it 'prefers own values over parent text values' do
+        parent = double 'parent', style: {stroke: white}
+        span.parent_text = parent
+        expect(span.style[:stroke]).to eq(red)
+      end
+    end
+  end
+
+  describe 'setting the text block a span belongs to' do
+    it 'can set it' do
+      text_block = double 'text block'
+      subject.text_block = text_block
+      expect(subject.text_block).to eq text_block
+    end
+  end
+
+  describe 'code' do
+    it 'sets font to Lucida Console' do
+      result = app.code 'test'
+      expect(result.style[:font]).to eq(('Lucida Console'))
+    end
+  end
+
+  describe 'del' do
+    it 'sets strikethrough to true' do
+      result = app.del 'test'
+      expect(result.style[:strikethrough]).to be_truthy
+    end
+  end
+
+  describe 'em' do
+    it 'sets emphasis to true' do
+      result = app.em 'test'
+      expect(result.style[:emphasis]).to be_truthy
+    end
+  end
+
+  describe 'ins' do
+    it 'sets underline to true' do
+      result = app.ins 'test'
+      expect(result.style[:underline]).to be_truthy
+    end
+  end
+
+  describe 'sub' do
+    it 'sets rise to -10 and multiplies font size by 0.8' do
+      result = app.sub 'test'
+      expect(result.style[:rise]).to eq(-10)
+    end
+  end
+
+  describe 'sup' do
+    it 'sets rise to 10 and multiplies font size by 0.8' do
+      result = app.sup 'test'
+      expect(result.style[:rise]).to eq(10)
+    end
+  end
+
+  describe 'strong' do
+    it 'sets weight to true' do
+      result = app.strong 'test'
+      expect(result.style[:weight]).to be_truthy
+    end
+  end
+end

data/spec/shoes/spec_helper.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+def it_styles_with(*styles)
+  supported_styles = unpack_styles(styles)
+  spec_styles(supported_styles)
+end
+
+def unpack_styles(styles)
+  supported_styles = []
+  styles.each do |style|
+    if Shoes::Common::Style::STYLE_GROUPS[style]
+      Shoes::Common::Style::STYLE_GROUPS[style].each{|style| supported_styles << style}
+    else
+      supported_styles << style
+    end
+  end
+  supported_styles
+end
+
+def spec_styles(supported_styles)
+  supported_styles.each do |style|
+    it_behaves_like "object that styles with #{style}"
+  end
+end

data/spec/shoes/stack_spec.rb

@@ -0,0 +1,79 @@
+require 'shoes/spec_helper'
+require 'shoes/helpers/fake_element'
+
+describe Shoes::Stack do
+  include_context "dsl app"
+
+  subject(:stack) { Shoes::Stack.new(app, app, input_opts) }
+
+  it_behaves_like "Slot"
+
+  describe 'Context' do
+
+    class ContextObject
+      def initialize(app)
+        @app = app
+      end
+
+      def check_self_inside_stack
+        inside_stack = nil
+        @app.stack do inside_stack = self end
+        inside_stack
+      end
+    end
+
+    it 'does not change the context' do
+      app = Shoes.app do ; end
+      context_object = ContextObject.new app
+      inside_stack = context_object.check_self_inside_stack
+      expect(inside_stack).to be context_object
+    end
+  end
+
+  describe 'positioning' do
+    it_behaves_like 'positioning through :_position'
+    it_behaves_like 'positions the first element in the top left'
+    it_behaves_like 'arranges elements underneath each other'
+
+    describe 'small stack height' do
+      let(:input_opts){{height: element.height + 10}}
+      it_behaves_like 'set height and contents alignment'
+    end
+
+    describe 'big stack height' do
+      let(:input_opts){{height: 1000}}
+      it_behaves_like 'set height and contents alignment'
+    end
+
+    describe 'with margin' do
+      let(:input_opts){{margin: 27}}
+      it_behaves_like 'taking care of margin'
+    end
+  end
+
+  describe 'scrolling' do
+    include_context "scroll"
+    subject { Shoes::Stack.new(app, parent, opts) }
+
+    context 'when scrollable' do
+      let(:scroll) { true }
+
+      it_behaves_like "scrollable slot"
+
+      context 'when content overflows' do
+        include_context "overflowing content"
+        it_behaves_like "scrollable slot with overflowing content"
+      end
+    end
+
+    context 'when slot is not scrollable' do
+      let(:scroll) { false }
+
+      its(:scroll) { should be_falsey }
+
+      it "initializes scroll_top to 0" do
+        expect(subject.scroll_top).to eq(0)
+      end
+    end
+  end
+end