shoes-swt 4.0.0.pre2 → 4.0.0.pre3

data/spec/shoes/list_box_spec.rb

@@ -1,74 +0,0 @@
-require 'shoes/spec_helper'
-
-describe Shoes::ListBox do
-  include_context "dsl app"
-  let(:input_opts)  { { items: items, left: left, top: top, width: width,
-                        height: height } }
-
-  let(:items) {["Wine", "Vodka", "Water"]}
-
-  let(:left) { 10 }
-  let(:top) { 20 }
-  let(:width) { 100 }
-  let(:height) { 200 }
-
-  subject(:list_box) { Shoes::ListBox.new(app, parent, input_opts, input_block) }
-
-  it_behaves_like "an element that can respond to change"
-  it_behaves_like "object with style" do
-    let(:subject_without_style) { Shoes::ListBox.new(app, parent) }
-    let(:subject_with_style) { Shoes::ListBox.new(app, parent, arg_styles) }
-  end
-  it_behaves_like "object with state"
-  it_behaves_like "object with dimensions"
-
-  describe "relative dimensions from parent" do
-    subject { Shoes::ListBox.new(app, parent, relative_opts, input_block) }
-    it_behaves_like "object with relative dimensions"
-  end
-
-  describe "negative dimensions" do
-    subject { Shoes::ListBox.new(app, parent, negative_opts, input_block) }
-    it_behaves_like "object with negative dimensions"
-  end
-
-  it "contains the correct items" do
-    expect(subject.items).to eq(["Wine", "Vodka", "Water"])
-  end
-
-  it "changes the items" do
-    list_box.items = ["Pie", "Apple", "Pig"]
-    expect(list_box.items).to eq(["Pie", "Apple", "Pig"])
-  end
-
-  describe 'Choosing' do
-    it "allows us to choose an option" do
-      expect(list_box).to respond_to(:choose)
-    end
-
-    def expect_gui_choose_with(string)
-      expect_any_instance_of(Shoes.configuration.backend::ListBox).
-      to receive(:choose).with string
-    end
-
-    it "should call @gui.choose when we choose something" do
-      expect_gui_choose_with "Wine"
-      list_box.choose "Wine"
-    end
-
-    it 'should call @gui.choose when the choose option is passed' do
-      expect_gui_choose_with 'Wine'
-      Shoes::ListBox.new app, parent, input_opts.merge(choose: 'Wine')
-    end
-  end
-
-  it "should delegate #text to the backend" do
-    expect_any_instance_of(Shoes.configuration.backend::ListBox).
-        to receive(:text).and_return("Sneakers & Sandals")
-    expect(list_box.text).to eq("Sneakers & Sandals")
-  end
-
-  it 'has the initialized text elements' do
-    expect(subject.items).to eq items
-  end
-end

data/spec/shoes/logger/ruby_spec.rb

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Logger::Ruby do
-  it "delegates to a Logger instance" do
-    expect_any_instance_of(::Logger).to receive(:debug).with("Foo bar baz!")
-    subject.debug("Foo bar baz!")
-  end
-end

data/spec/shoes/logger_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Logger do
-  let(:awesome_logger) { Class.new }
-  after { Shoes::Logger.unregister(:awesome_logger) }
-
-  describe ".register" do
-    it "allows new loggers to be registered" do
-      Shoes::Logger.register(:awesome_logger, awesome_logger)
-    end
-  end
-
-  describe ".get" do
-    before { Shoes::Logger.register(:awesome_logger, awesome_logger) }
-
-    it "retrieves a registered logger" do
-      expect(Shoes::Logger.get(:awesome_logger)).to equal(awesome_logger)
-    end
-  end
-
-  describe "default logger" do
-    let(:logger) { Shoes.logger }
-
-    it "is a ruby logger" do
-      expect(logger).to be_an_instance_of(Shoes::Logger::Ruby)
-    end
-  end
-end
-
-describe Shoes::Logger::Ruby do
-  let(:logdevice) { StringIO.new }
-  subject(:logger) { Shoes::Logger::Ruby.new logdevice }
-
-  it "logs messages with format 'LEVEL: Message'" do
-    logger.info "Message"
-    expect(logdevice.string).to eq("INFO: Message\n")
-  end
-
-  it "defaults to STDERR" do
-    allow(STDERR).to receive(:write)
-    logger = Shoes::Logger::Ruby.new
-    logger.error "Message"
-    expect(STDERR).to have_received(:write)
-  end
-end

data/spec/shoes/oval_spec.rb

@@ -1,24 +0,0 @@
-require 'shoes/spec_helper'
-
-describe Shoes::Oval do
-  include_context "dsl app"
-
-  let(:left) { 20 }
-  let(:top) { 30 }
-  let(:width) { 100 }
-  let(:height) { 200 }
-
-  describe "basic" do
-    subject { Shoes::Oval.new(app, parent, left, top, width, height) }
-    it_behaves_like "object with style" do
-      let(:subject_without_style) { Shoes::Oval.new(app, parent, left, top, width, height) }
-      let(:subject_with_style) { Shoes::Oval.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_styles_with :art_styles, :center, :dimensions, :radius
-  end
-end

data/spec/shoes/point_spec.rb

@@ -1,71 +0,0 @@
-require 'shoes/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 "#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 'shoes/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 'shoes/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,39 +0,0 @@
-require 'shoes/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'
-end

data/spec/shoes/renamed_delegate_spec.rb

@@ -1,70 +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,95 +0,0 @@
-require 'shoes/spec_helper'
-
-describe Shoes::Shape do
-  include_context "dsl app"
-
-  let(:style) { Hash.new }
-  let(:draw)  { Proc.new { } }
-
-  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"
-
-  describe "octagon" do
-    let(:draw) {
-      Proc.new {
-        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
-      }
-    }
-
-    its(:left) { should be_nil }
-    its(:top) { should be_nil }
-    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 with left and top values" do
-      let(:style) { {left: 10, 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) {
-      Proc.new {
-        move_to 10, 10
-        curve_to 20, 30, 100, 200, 50, 50
-      }
-    }
-
-    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) {
-      Proc.new {
-        arc 10, 10, 100, 100, Shoes::PI, Shoes::TWO_PI
-      }
-    }
-
-    it_behaves_like "movable object"
-  end
-
-  describe "accesses app" do
-    let(:draw) {
-      Proc.new {
-        background Shoes::COLORS[:red]
-        stroke Shoes::COLORS[:blue]
-        rect 10, 10, 100, 100
-      }
-    }
-
-    it_behaves_like "movable object"
-  end
-end