shoes-core 4.0.0.pre7 → 4.0.0.pre8

data/spec/shoes/point_spec.rb

@@ -1,99 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Point do
-  subject { Shoes::Point.new(40, 50) }
-  let(:other_point) { Shoes::Point.new(10, 60) }
-
-  its(:x) { should eq(40) }
-  its(:y) { should eq(50) }
-
-  it "#left works on either point" do
-    expect(subject.left(other_point)).to eq(10)
-    expect(other_point.left(subject)).to eq(10)
-  end
-
-  it "#top works on either point" do
-    expect(subject.top(other_point)).to eq(50)
-    expect(other_point.top(subject)).to eq(50)
-  end
-
-  describe "equality" do
-    it "requires x and y to be equal" do
-      expect(subject).to eq(Shoes::Point.new(40, 50))
-      expect(subject).not_to eq(Shoes::Point.new(41, 50))
-      expect(subject).not_to eq(Shoes::Point.new(40, 51))
-    end
-
-    it "works with other (x,y) objects" do
-      expect(subject).to eq(Struct.new(:x, :y).new(40, 50))
-    end
-  end
-
-  describe "#+" do
-    it "performs element-wise addition with other point" do
-      expect(subject + Shoes::Point.new(40, 50)).to eq(Shoes::Point.new(80, 100))
-    end
-
-    it "performs element-wise addition with an array" do
-      expect(subject + [40, 50]).to eq(Shoes::Point.new(80, 100))
-    end
-
-    it "doesn't perform addition when dimensions don't match" do
-      expect { subject + [40, 50, 60] }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#-" do
-    it "performs element-wise subtraction with other point" do
-      expect(subject - Shoes::Point.new(40, 50)).to eq(Shoes::Point.new(0, 0))
-    end
-
-    it "performs element-wise subtraction with an array" do
-      expect(subject - [40, 50]).to eq(Shoes::Point.new(0, 0))
-    end
-
-    it "doesn't perform subtraction when dimensions don't match" do
-      expect { subject - [40, 50, 60] }.to raise_error(ArgumentError)
-    end
-  end
-
-  describe "#to" do
-    it "positive" do
-      expect(subject.to(24, 166)).to eq(Shoes::Point.new(64, 216))
-    end
-
-    it "negative" do
-      expect(subject.to(-24, -166)).to eq(Shoes::Point.new(16, -116))
-    end
-  end
-
-  it "calculates width of rectangle created with other point" do
-    expect(subject.width(other_point)).to eq(30)
-    expect(other_point.width(subject)).to eq(30)
-  end
-
-  it "calculates height of rectangle created with other point" do
-    expect(subject.height(other_point)).to eq(10)
-    expect(other_point.height(subject)).to eq(10)
-  end
-
-  describe "converting to string" do
-    include InspectHelpers
-
-    it "looks like (x,y)" do
-      expect(subject.to_s).to eq("(40,50)")
-    end
-
-    it "inspects like (Shoes::Point:0x01234567 (x,y))" do
-      expect(subject.inspect).to match(/[(]Shoes::Point:#{shoes_object_id_pattern} [(]40,50[)][)]/)
-    end
-
-    describe "with nil values" do
-      subject { Shoes::Point.new(nil, nil) }
-
-      it "looks like (nil,nil)" do
-        expect(subject.to_s).to eq("(_,_)")
-      end
-    end
-  end
-end

data/spec/shoes/progress_spec.rb

@@ -1,54 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Progress do
-  include_context "dsl app"
-  let(:input_opts) { { left: left, top: top, width: width, height: height } }
-
-  let(:left) { 10 }
-  let(:top) { 20 }
-  let(:width) { 100 }
-  let(:height) { 200 }
-
-  subject(:progress) { Shoes::Progress.new(app, parent, input_opts, input_block) }
-
-  it { is_expected.to respond_to :fraction }
-  it { is_expected.to respond_to :fraction= }
-
-  it_behaves_like "object with dimensions"
-
-  it_behaves_like "object with style" do
-    let(:subject_without_style) { Shoes::Progress.new(app, parent) }
-    let(:subject_with_style) { Shoes::Progress.new(app, parent, arg_styles) }
-  end
-
-  context "initialize" do
-    let(:input_opts) { { fraction: 50 } }
-
-    it "sets fraction" do
-      expect_any_instance_of(Shoes.configuration.backend::Progress).to receive(:fraction=).with(50)
-      expect(progress).not_to be_nil
-    end
-  end
-
-  context "setting fraction" do
-    it "sets on gui" do
-      expect(progress.gui).to receive(:fraction=).with(0.5)
-      progress.fraction = 0.5
-    end
-
-    it "sets on self" do
-      progress.fraction = 0.5
-      expect(progress.fraction).to eq(0.5)
-    end
-  end
-
-  describe "relative dimensions from parent" do
-    subject { Shoes::Progress.new(app, parent, relative_opts, input_block) }
-    it_behaves_like "object with relative dimensions"
-  end
-
-  describe "negative dimensions" do
-    subject { Shoes::Progress.new(app, parent, negative_opts, input_block) }
-    it_behaves_like "object with negative dimensions"
-  end
-end

data/spec/shoes/radio_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Radio do
-  include_context "dsl app"
-
-  subject(:radio) { Shoes::Radio.new(app, parent, group, input_opts, input_block) }
-  let(:group) { :a_group }
-
-  it_behaves_like "checkable"
-  it_behaves_like "object with state"
-
-  it_behaves_like "object with style" do
-    let(:subject_without_style) { Shoes::Radio.new(app, parent, group) }
-    let(:subject_with_style) { Shoes::Radio.new(app, parent, group, arg_styles) }
-  end
-
-  # only one radio in a group can be checked
-
-  describe "#initialize" do
-    it "sets accessors" do
-      expect(radio.parent).to eq(parent)
-      expect(radio.group).to eq(group)
-    end
-  end
-
-  describe "#group=" do
-    it "changes the group" do
-      radio.group = "New Group"
-      expect(radio.group).to eq("New Group")
-    end
-  end
-end

data/spec/shoes/rect_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for "basic rect" do
-  it "retains app" do
-    expect(rect.app).to eq(app)
-  end
-
-  it "creates gui object" do
-    expect(rect.gui).not_to be_nil
-  end
-end
-
-describe Shoes::Rect do
-  include_context "dsl app"
-
-  let(:parent) { app }
-  let(:left) { 44 }
-  let(:top) { 66 }
-  let(:width) { 111 }
-  let(:height) { 333 }
-  subject(:rect) { Shoes::Rect.new(app, parent, left, top, width, height) }
-
-  describe '#style' do
-    it 'restyles handed in fill colors (even the weird ones)' do
-      subject.style fill: 'fff'
-      expect(subject.style[:fill]).to eq Shoes::Color.new 255, 255, 255
-    end
-  end
-
-  it_behaves_like "basic rect"
-  it_behaves_like "object with style" do
-    let(:subject_without_style) { Shoes::Rect.new(app, parent, left, top, width, height) }
-    let(:subject_with_style) { Shoes::Rect.new(app, parent, left, top, width, height, arg_styles) }
-  end
-  it_behaves_like "object with dimensions"
-  it_behaves_like "movable object"
-  it_behaves_like "left, top as center"
-  it_behaves_like 'object with parent'
-  it_behaves_like "object with hover"
-end

data/spec/shoes/renamed_delegate_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-describe RenamedDelegate do
-  class ToDelegate
-    def method_key
-    end
-
-    def abcd
-    end
-
-    def key
-    end
-
-    def bla_key
-    end
-
-    def method_something
-    end
-
-    def key_something
-    end
-  end
-
-  class TestClass
-    extend RenamedDelegate
-
-    attr_reader :delegate
-
-    def initialize(delegate)
-      @delegate = delegate
-    end
-  end
-
-  TestClass.renamed_delegate_to :delegate,
-                                ToDelegate.public_instance_methods(false),
-                                'key' => 'shoes', 'something' => 'awesome'
-
-  let(:delegate) { double('delegate').as_null_object }
-  subject { TestClass.new delegate }
-
-  def test_renaming(new_name, old_name)
-    subject.public_send new_name
-    expect(delegate).to have_received old_name
-  end
-
-  it 'delegates method_shoes to method_key' do
-    test_renaming :method_shoes, :method_key
-  end
-
-  it 'delegates shoes to key' do
-    test_renaming :shoes, :key
-  end
-
-  it 'delegates bla_shoes to bla_key' do
-    test_renaming :bla_shoes, :bla_key
-  end
-
-  it 'delegates method_awesome to method_something' do
-    test_renaming :method_awesome, :method_something
-  end
-
-  it 'also applies multiple renamings' do
-    test_renaming :shoes_awesome, :key_something
-  end
-
-  it 'does not define a method for methods without renamings' do
-    expect(subject).not_to respond_to :abcd
-  end
-end

data/spec/shoes/shape_spec.rb

@@ -1,119 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Shape do
-  include_context "dsl app"
-
-  let(:left) { 0 }
-  let(:top) { 0 }
-  let(:style) { {translate_left: 0, translate_top: 0, left: left, top: top} }
-  let(:draw)  { proc {} }
-
-  subject { Shoes::Shape.new app, parent, style, draw }
-
-  it_behaves_like "object with style" do
-    let(:subject_without_style) { Shoes::Shape.new(app, parent) }
-    let(:subject_with_style) { Shoes::Shape.new(app, parent, arg_styles) }
-  end
-
-  it_behaves_like "movable object"
-  it_behaves_like "clickable object"
-
-  describe "octagon" do
-    let(:draw) do
-      proc do
-        xs = [200, 300, 370, 370, 300, 200, 130, 130]
-        ys = [100, 100, 170, 270, 340, 340, 270, 170]
-        move_to xs.first, ys.first
-        xs.zip(ys).each do |x, y|
-          line_to(x, y)
-        end
-        line_to xs.first, ys.first
-      end
-    end
-
-    its(:left) { should eq(0) }
-    its(:top) { should eq(0) }
-    its(:left_bound) { should eq(130) }
-    its(:top_bound) { should eq(100) }
-    its(:right_bound) { should eq(370) }
-    its(:bottom_bound) { should eq(340) }
-    its(:width) { should eq(app.width) }
-    its(:height) { should eq app.height }
-
-    it_behaves_like "movable object"
-
-    describe "when created without left and top values" do
-      let(:left) { nil }
-      let(:top) { nil }
-
-      its(:left) { should eq(nil) }
-      its(:top) { should eq(nil) }
-    end
-
-    describe "when created with left and top values" do
-      let(:left) { 10 }
-      let(:top) { 100 }
-
-      its(:left) { should eq(10) }
-      its(:top) { should eq(100) }
-      its(:left_bound) { should eq(130) }
-      its(:top_bound) { should eq(100) }
-      its(:right_bound) { should eq(370) }
-      its(:bottom_bound) { should eq(340) }
-      its(:width) { should eq(app.width) }
-      its(:height) { should eq app.height }
-    end
-  end
-
-  describe "curve" do
-    let(:draw) do
-      proc do
-        move_to 10, 10
-        curve_to 20, 30, 100, 200, 50, 50
-      end
-    end
-
-    its(:left_bound)   { should eq(10) }
-    its(:top_bound)    { should eq(10) }
-    its(:right_bound)  { should eq(100) }
-    its(:bottom_bound) { should eq(200) }
-    its(:width) { should eq(app.width) }
-    its(:height) { should eq app.height }
-
-    it_behaves_like "movable object"
-  end
-
-  describe "arc" do
-    let(:draw) do
-      proc do
-        arc_to 10, 10, 100, 100, Shoes::PI, Shoes::TWO_PI
-      end
-    end
-
-    it_behaves_like "movable object"
-  end
-
-  describe "in_bounds?" do
-    let(:draw) { proc { line_to 100, 100 } }
-
-    it "is in bounds" do
-      expect(subject.in_bounds?(10, 10)).to be true
-    end
-
-    it "is out of bounds" do
-      expect(subject.in_bounds?(101, 101)).to be false
-    end
-  end
-
-  describe "accesses app" do
-    let(:draw) do
-      proc do
-        background Shoes::COLORS[:red]
-        stroke Shoes::COLORS[:blue]
-        rect 10, 10, 100, 100
-      end
-    end
-
-    it_behaves_like "movable object"
-  end
-end

data/spec/shoes/shared_examples/button.rb

@@ -1,6 +0,0 @@
-shared_examples "checkable" do
-  it { is_expected.to respond_to :checked= }
-  it { is_expected.to respond_to :checked? }
-  it { is_expected.to respond_to :focus }
-  it { is_expected.to respond_to :click }
-end

data/spec/shoes/shared_examples/changeable.rb

@@ -1,26 +0,0 @@
-shared_examples "an element that can respond to change" do
-  describe "when passing a block to the constructor" do
-    it "should notify the block of change events" do
-      expect(input_block).to receive(:call).with(subject)
-      subject.call_change_listeners
-    end
-  end
-
-  describe "when setting up a callback with #change" do
-    it "should notify the callback of change events" do
-      called = false
-      subject.change do
-        called = true
-      end
-      subject.call_change_listeners
-      expect(called).to be_truthy
-    end
-
-    it "should pass the element itself to the callback" do
-      subject.change do |element|
-        expect(element).to eq(subject)
-      end
-      subject.call_change_listeners
-    end
-  end
-end