shoes 4.0.0.pre1 → 4.0.0.pre2

data/spec/shoes/shared_examples/state.rb

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

data/spec/shoes/shared_examples/style.rb

@@ -1,24 +0,0 @@
-shared_examples_for "object with style" do
-  it "merges new styles" do
-    old_style = subject.style
-    subject.style :left => 100
-    subject.style :top => 50
-    expect(subject.style).to eq(old_style.merge(:left => 100, :top => 50))
-  end
-
-  describe 'changing style' do
-    before do
-      subject.stub(:update_style)
-    end
-
-    it 'calls change_style when the style is changed' do
-      subject.style :left => 50
-      expect(subject).to have_received(:update_style)
-    end
-
-    it 'does not call change_style when style is called without args' do
-      subject.style
-      expect(subject).not_to have_received(:update_style)
-    end
-  end
-end

data/spec/shoes/slot_spec.rb

@@ -1,60 +0,0 @@
-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 }
-  subject(:slot) { Shoes::Slot.new(app, parent, left: left, top: top, width: width, height: height) }
-
-  it_behaves_like "object with dimensions"
-
-  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'], 20
-    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
-end

data/spec/shoes/sound_spec.rb

@@ -1,15 +0,0 @@
-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
-    subject.gui.should_receive(:play)
-    subject.play
-  end
-end

data/spec/shoes/span_spec.rb

@@ -1,94 +0,0 @@
-require 'shoes/spec_helper'
-
-describe Shoes::Span do
-  let(:app) { Shoes::App.new }
-  let(:opts) { {} }
-  let(:text) { ['test'] }
-  subject(:span) { Shoes::Span.new(text, opts) }
-
-  describe 'span' do
-    it 'sets style to Span block' do
-      expect(app.style[:strikethrough]).not_to be_true
-
-      opts = { strikethrough: true }
-      result = app.span('test', opts)
-      expect(result.opts[:strikethrough]).to be_true
-
-      expect(app.style[:strikethrough]).not_to be_true
-    end
-  end
-
-  describe 'Looking up parent styles' do
-    let(:white) {Shoes::COLORS[:white]}
-    let(:red) {Shoes::COLORS[:red]}
-    it 'does not try to merge with parent opts when there are none' do
-      parent = double 'parent'
-      span.parent = parent
-      expect {span.opts}.to_not raise_error()
-    end
-
-    it 'merges with the styles of the parent' do
-      parent = double 'parent', opts: {stroke: white}
-      span.parent = parent
-      expect(span.opts[:stroke]).to eq(white)
-    end
-
-    describe 'with own opts' do
-      let(:opts) {{stroke: red}}
-      it 'prefers own values over parent values' do
-        parent = double 'parent', opts: {stroke: white}
-        span.parent = parent
-        expect(span.opts[:stroke]).to eq(red)
-      end
-    end
-  end
-
-  describe 'code' do
-    it 'sets font to Lucida Console' do
-      result = app.code 'test'
-      expect(result.opts[:font]).to eq(('Lucida Console'))
-    end
-  end
-
-  describe 'del' do
-    it 'sets strikethrough to true' do
-      result = app.del 'test'
-      expect(result.opts[:strikethrough]).to be_true
-    end
-  end
-
-  describe 'em' do
-    it 'sets emphasis to true' do
-      result = app.em 'test'
-      expect(result.opts[:emphasis]).to be_true
-    end
-  end
-
-  describe 'ins' do
-    it 'sets underline to true' do
-      result = app.ins 'test'
-      expect(result.opts[:underline]).to be_true
-    end
-  end
-
-  describe 'sub' do
-    it 'sets rise to -10 and multiplies font size by 0.8' do
-      result = app.sub 'test'
-      expect(result.opts[: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.opts[:rise]).to eq(10)
-    end
-  end
-
-  describe 'strong' do
-    it 'sets weight to true' do
-      result = app.strong 'test'
-      expect(result.opts[:weight]).to be_true
-    end
-  end
-end

data/spec/shoes/spec_helper.rb

@@ -1 +0,0 @@
-require 'spec_helper'

data/spec/shoes/stack_spec.rb

@@ -1,53 +0,0 @@
-require 'shoes/spec_helper'
-require_relative '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
-      inside_stack.should 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
-end

data/spec/shoes/star_spec.rb

@@ -1,30 +0,0 @@
-require 'shoes/spec_helper'
-
-shared_examples_for "basic star" do
-  it "retains app" do
-    expect(subject.app).to eq(app)
-  end
-
-  it "creates gui object" do
-    expect(subject.gui).not_to be_nil
-  end
-end
-
-describe Shoes::Star do
-  include_context "dsl app"
-
-  let(:left) { 44 }
-  let(:top) { 66 }
-  let(:width) { 100 }
-  let(:height) { 100 }
-
-  subject { Shoes::Star.new(app, parent, left, top, 5, 50, 30) }
-
-  it_behaves_like "basic star"
-  it_behaves_like "object with fill"
-  it_behaves_like "object with stroke"
-  it_behaves_like "object with style"
-  it_behaves_like "object with dimensions"
-  it_behaves_like "movable object"
-  it_behaves_like 'object with parent'
-end

data/spec/shoes/text_block_spec.rb

@@ -1,242 +0,0 @@
-require 'shoes/spec_helper'
-require 'shoes/helpers/sample17_helper'
-
-describe Shoes::TextBlock do
-  include_context "dsl app"
-
-  let(:text_link) { Shoes::Link.new(app, parent, ['Hello']) }
-  let(:text) { [text_link, ", world!"] }
-  subject(:text_block) { Shoes::TextBlock.new(app, parent, text, 99, {app: app}) }
-
-  describe "initialize" do
-    it "creates gui object" do
-      expect(text_block.gui).not_to be_nil
-    end
-  end
-
-  describe "text" do
-    context "with an array of [Shoes::Link, String]" do
-      it "sets text" do
-        expect(text_block.text).to eq "Hello, world!"
-      end
-
-      it "changes the text" do
-        text_block.text = "Goodbye Cruel World"
-        expect(text_block.text).to eq "Goodbye Cruel World"
-      end
-    end
-
-    context "with a single string" do
-      let(:text) { "Hello, world!" }
-
-      it "sets text" do
-        expect(text_block.text).to eq "Hello, world!"
-      end
-
-      it "changes the text" do
-        text_block.text = "Goodbye Cruel World"
-        expect(text_block.text).to eq "Goodbye Cruel World"
-      end
-    end
-  end
-
-  describe "#to_s" do
-    it "is the same as #text" do
-      text = text_block.text
-      expect(text_block.to_s).to eq(text)
-    end
-  end
-
-  describe "#replace" do
-    it "replaces text" do
-      text_block.replace "Goodbye Cruel World"
-      expect(text_block.text).to eq("Goodbye Cruel World")
-    end
-
-    it "allows two arguments" do
-      text_block.replace "Goodbye Cruel World, ", text_link
-      expect(text_block.text).to eq("Goodbye Cruel World, Hello")
-    end
-  end
-
-  describe "#contents" do
-    it "returns text elements" do
-      expect(text_block.contents).to eql([text_link, ", world!"])
-    end
-  end
-
-  describe "font" do
-    let(:size) { 99 }
-    let(:text_block) { Shoes::TextBlock.new(app, parent, ["Hello, world!"], size, opts) }
-
-    context "with defaults" do
-      let(:opts) { Hash.new }
-
-      it "sets the default font to Arial" do
-        expect(text_block.font).to eq "Arial"
-      end
-
-      it "sets the size from explicit argument" do
-        expect(text_block.font_size).to eq size
-      end
-    end
-
-    context "with a font family string" do
-      let(:opts) { { font: "Helvetica" } }
-
-      it "sets the font family" do
-        expect(text_block.font).to eq "Helvetica"
-      end
-
-      it "sets the size from explicit argument" do
-        expect(text_block.font_size).to eq size
-      end
-    end
-
-    context "with a font family string and size with 'px'" do
-      let(:opts) { { font: "Helvetica 33px" } }
-
-      it "sets the font family" do
-        expect(text_block.font).to eq "Helvetica"
-      end
-
-      it "sets the font size" do
-        expect(text_block.font_size).to eq 33
-      end
-    end
-
-    context "with a font family string and size with ' px'" do
-      let(:opts) { { font: "Helvetica 33 px" } }
-
-      it "sets the font family" do
-        expect(text_block.font).to eq "Helvetica"
-      end
-
-      it "sets the font size" do
-        expect(text_block.font_size).to eq 33
-      end
-    end
-
-    context "with a quoted font family string and size with 'px'" do
-      let(:opts) { { font: '"Comic Sans" 13px' } }
-
-      it "sets the font family" do
-        expect(text_block.font).to eq "Comic Sans"
-      end
-
-      it "sets the size" do
-        expect(text_block.font_size).to eq 13
-      end
-    end
-  end
-
-  describe "stroke" do
-    it "should accept a hex code" do
-      s = Shoes::TextBlock.new(app, parent, ["Hello, world!"], 99, { stroke: "#fda", app: app })
-      color = s.opts[:stroke]
-      expect(color.red).to eql 255
-      expect(color.green).to eql 221
-      expect(color.blue).to eql 170
-    end
-  end
-
-  describe "width" do
-    before(:each) do
-      parent.stub(:width)         { 300 }
-      parent.stub(:absolute_left) { 0 }
-    end
-
-    context "when not explicitly set" do
-      subject(:text_block) { Shoes::TextBlock.new(app, parent, ["text"], 42) }
-
-      it "delegates to calculated width" do
-        subject.calculated_width = 240
-        expect(subject.width).to eql 240
-      end
-
-      it "bases desired width off parent" do
-        subject.absolute_left = 20
-        expect(subject.desired_width).to eql 280
-      end
-
-      it "can base desired off explicit containing width" do
-        subject.absolute_left = 20
-        expect(subject.desired_width(1000)).to eql(980)
-      end
-    end
-
-    context "when explicitly set" do
-      subject(:text_block) { Shoes::TextBlock.new(app, parent, ["text"], 42, { width: 120 }) }
-
-      it "gets returned" do
-        expect(subject.width).to eql 120
-      end
-
-      it "is used for desired width" do
-        subject.absolute_left = 20
-        expect(subject.desired_width).to eql 100
-      end
-    end
-
-  end
-
-  context "cursor management" do
-    let(:textcursor) { double("textcursor") }
-
-    before(:each) do
-      app.stub(:textcursor) { textcursor }
-    end
-
-    it "creates a textcursor" do
-      expect(subject.textcursor).to eq(textcursor)
-      expect(app).to have_received(:textcursor)
-    end
-
-    it "only creates textcursor" do
-      original = subject.textcursor
-      app.stub(:textcursor) { double("new cursor") }
-
-      expect(subject.textcursor).to eq(original)
-      expect(app).to have_received(:textcursor).once
-    end
-  end
-
-  # Emulates samples/sample17.rb
-  #
-  #   Shoes.app width: 240, height: 95 do
-  #     para 'Testing, test, test. ',
-  #       strong('Breadsticks. '),
-  #       em('Breadsticks. '),
-  #       code('Breadsticks. '),
-  #       bg(fg(strong(ins('EVEN BETTER.')), white), rgb(255, 0, 192)),
-  #       sub('fine!')
-  #   end
-  #
-  context "with nested text fragments" do
-    let(:helper) {Sample17Helper.new(app)}
-    let!(:para) { helper.create_para }
-
-    it "has full text of fragments" do
-      expect(para.text).to eq("Testing, test, test. Breadsticks. Breadsticks. Breadsticks. EVEN BETTER.fine!")
-    end
-
-    it "has fragment styles" do
-      text_styles = {
-                     21..33 => [helper.strong_breadsticks],
-                     34..46 => [helper.em],
-                     47..59 => [helper.code],
-                     60..71 => [helper.bg, helper.fg, helper.strong, helper.ins],
-                     72..76 => [helper.sub]
-                    }
-      expect(para.text_styles).to eq(text_styles)
-    end
-
-    it 'sets the parent of the non nested texts to the para' do
-      expect(helper.strong_breadsticks.parent).to eq para
-    end
-
-    it 'sets the parent of nested fragments correctly' do
-      expect(helper.ins.parent).to eq helper.strong
-    end
-  end
-end