shoes-core 4.0.0.pre7 → 4.0.0.pre8

data/spec/shoes/shared_examples/state.rb

@@ -1,26 +0,0 @@
-shared_examples_for "object with state" do
-  let(:input_opts) { {state: "disabled"} }
-
-  it "should initialize in the right state" do
-    expect_any_instance_of(Shoes.configuration.backend_class(described_class)).to receive(:enabled).with(false)
-    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
-
-  it "does not disable when a string other than disabled is passed" do
-    expect(subject.gui).to receive(:enabled).with(true)
-    subject.state = "enabled"
-    expect(subject.state).to eq("enabled")
-  end
-end

data/spec/shoes/shared_examples/style.rb

@@ -1,77 +0,0 @@
-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_s.to_sym)
-      end
-    end
-  end
-end

data/spec/shoes/slot_spec.rb

@@ -1,176 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Slot do
-  include_context "dsl app"
-  let(:parent) { Shoes::Stack.new(app, 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) }
-
-  before do
-    # In production this is filled in by Stack and Flow, but we don't want to
-    # trip it in our tests against Slot directly.
-    allow(slot).to receive(:position_element) do |element, current_position|
-      slot.send(:move_to_next_line, element, current_position)
-    end
-  end
-
-  it_behaves_like "object with dimensions"
-  it_behaves_like "object with hover"
-
-  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::Para.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' do
-    before :each do
-      Shoes::Para.new app, slot, ['text']
-    end
-
-    it 'removes the child element' do
-      subject.remove
-      expect(subject.contents).to be_empty
-    end
-
-    it 'notifies the gui' do
-      expect(subject.gui).to receive(:remove)
-      subject.remove
-    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 "create_bound_block" do
-    let(:callable) { double("block", call: nil) }
-    let(:block)    { proc { callable.call(self) } }
-
-    it "calls within the slot's context" do
-      expect(subject).to receive(:eval_block).with(block)
-
-      bound = subject.create_bound_block(block)
-      bound.call
-    end
-  end
-
-  describe "compute_content_height" do
-    subject(:slot) { Shoes::Slot.new(app, parent) }
-
-    it "finds 0 without children" do
-      expect(compute_content_height).to eq(0)
-    end
-
-    describe "with children" do
-      let(:child) do
-        child_element = Shoes::FakeElement.new(subject, height: 100)
-        child_element.absolute_top = 0
-        child_element.gui = double('child gui').as_null_object
-        child_element
-      end
-
-      before do
-        subject.add_child(child)
-      end
-
-      it "finds height from child" do
-        expect(compute_content_height).to eq(100)
-      end
-
-      it "ignores unpositioned children" do
-        allow(child).to receive(:absolute_bottom) { nil }
-        expect(compute_content_height).to eq(0)
-      end
-
-      it "ignores hidden child" do
-        child.hide
-        expect(compute_content_height).to eq(0)
-      end
-
-      it "ignores child that doesn't take up space" do
-        allow(child).to receive(:takes_up_space?) { false }
-        expect(compute_content_height).to eq(0)
-      end
-    end
-
-    def compute_content_height
-      subject.send(:compute_content_height)
-    end
-  end
-end

data/spec/shoes/sound_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Sound do
-  let(:app_gui) { double("app gui") }
-  let(:parent) { double("parent", gui: app_gui) }
-  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

@@ -1,112 +0,0 @@
-require '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 = 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 = 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 = 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

@@ -1,24 +0,0 @@
-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 { |s| supported_styles << s }
-    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

@@ -1,79 +0,0 @@
-require '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"
-  it_behaves_like "object with hover"
-
-  describe 'Context' do
-    class ContextObject
-      def initialize(app)
-        @app = app
-      end
-
-      def check_self_inside_stack
-        inside_stack = nil
-        @app.stack { inside_stack = self }
-        inside_stack
-      end
-    end
-
-    it 'does not change the context' do
-      app = Shoes.app { ; }
-      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