shoes-core 4.0.0.pre7 → 4.0.0.pre8

data/spec/shoes/line_spec.rb

@@ -1,120 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Line do
-  include_context "dsl app"
-
-  describe "basic" do
-    let(:left) { 20 }
-    let(:top) { 23 }
-    let(:width) { 280 }
-    let(:height) { 407 }
-
-    subject { Shoes::Line.new(app, parent, Shoes::Point.new(left, top), Shoes::Point.new(300, 430), input_opts) }
-    it_behaves_like "movable object"
-    it_behaves_like "object with style" do
-      let(:subject_without_style) { Shoes::Line.new(app, parent, Shoes::Point.new(left, top), Shoes::Point.new(300, 430)) }
-      let(:subject_with_style) { Shoes::Line.new(app, parent, Shoes::Point.new(left, top), Shoes::Point.new(300, 430), arg_styles) }
-    end
-    it_behaves_like "object with dimensions"
-    it_behaves_like "object with parent"
-    it_behaves_like "object with hover"
-  end
-
-  describe "line with point a at leftmost, topmost" do
-    subject { Shoes::Line.new(app, app, Shoes::Point.new(10, 15), Shoes::Point.new(100, 60), input_opts) }
-    its(:left)   { should eq(10) }
-    its(:top)    { should eq(15) }
-    its(:right)  { should eq(100) }
-    its(:bottom) { should eq(60) }
-    its(:width)  { should eq(90) }
-    its(:height) { should eq(45) }
-  end
-
-  describe "specified right-to-left, top-to-bottom" do
-    subject { Shoes::Line.new(app, app, Shoes::Point.new(100, 60), Shoes::Point.new(10, 15), input_opts) }
-    its(:left)   { should eq(100) }
-    its(:top)    { should eq(60) }
-    its(:right)  { should eq(10) }
-    its(:bottom) { should eq(15) }
-    its(:width)  { should eq(-90) }
-    its(:height) { should eq(-45) }
-  end
-
-  describe "setting dimensions" do
-    subject { Shoes::Line.new(app, app, Shoes::Point.new(100, 100), Shoes::Point.new(200, 200), input_opts) }
-
-    it "moves point a with left and top" do
-      subject.left -= 100
-      subject.top  -= 100
-      expect(subject.point_a).to eq(Shoes::Point.new(0, 0))
-    end
-
-    it "moves point a even when it's not leftmost or topmost" do
-      2.times do
-        subject.left += 100
-        subject.top += 100
-      end
-
-      expect(subject.point_a).to eq(Shoes::Point.new(300, 300))
-    end
-
-    it "moves point a with right and bottom" do
-      subject.right  += 100
-      subject.bottom += 100
-      expect(subject.point_b).to eq(Shoes::Point.new(300, 300))
-    end
-
-    it "moves point b even when it's not rightmost or bottommost" do
-      2.times do
-        subject.right  -= 100
-        subject.bottom -= 100
-      end
-
-      expect(subject.point_b).to eq(Shoes::Point.new(0, 0))
-    end
-
-    it "can move point a" do
-      subject.move(10, 10)
-      expect(subject.point_a).to eq(Shoes::Point.new(10, 10))
-      expect(subject.point_b).to eq(Shoes::Point.new(200, 200))
-    end
-
-    it "can move all points" do
-      subject.move(10, 10, 20, 20)
-      expect(subject.point_a).to eq(Shoes::Point.new(10, 10))
-      expect(subject.point_b).to eq(Shoes::Point.new(20, 20))
-    end
-  end
-
-  describe "#in_bounds?" do
-    subject(:line) { Shoes::Line.new(app, app, Shoes::Point.new(100, 100), Shoes::Point.new(50, 50), input_opts) }
-
-    it "returns true if a point is in the end of the line" do
-      expect(subject.in_bounds?(100, 100)).to be true
-    end
-
-    it "returns true if a point is in the end of the line" do
-      expect(subject.in_bounds?(50, 50)).to be true
-    end
-
-    it "returns true if a point is in the middle of the line" do
-      expect(subject.in_bounds?(75, 75)).to be true
-    end
-
-    it "returns false if a point is not in the line" do
-      expect(subject.in_bounds?(201, 200)).to be false
-    end
-
-    it "takes into account :strokewidth style" do
-      line = Shoes::Line.new(app, app, Shoes::Point.new(50, 50), Shoes::Point.new(70, 50), input_opts)
-      line.style(strokewidth: 20)
-      expect(line.in_bounds?(50, 52)).to be true
-      expect(line.in_bounds?(50, 48)).to be true
-      expect(line.in_bounds?(50, 60)).to be true
-      expect(line.in_bounds?(50, 40)).to be true
-      expect(line.in_bounds?(49, 50)).to be false
-      expect(line.in_bounds?(50, 61)).to be false
-      expect(line.in_bounds?(70, 50)).to be true
-    end
-  end
-end

data/spec/shoes/link_spec.rb

@@ -1,149 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Link do
-  let(:gui) { double("gui").as_null_object }
-  let(:user_facing_app) { double("user facing app") }
-  let(:element_styles) { Hash.new }
-
-  let(:app) do
-    double("app", gui: gui, style: {}, element_styles: element_styles,
-                  warn: true, add_mouse_hover_control: nil)
-  end
-
-  let(:parent) { double("parent") }
-  let(:internal_app) { double("internal app", app: app, gui: gui, style: {}, element_styles: {}) }
-  let(:texts) { ["text", "goes", "first"] }
-  let(:text_block) { double 'text block', visible?: true, hidden?: false }
-
-  subject do
-    link = Shoes::Link.new(app, texts, color: :blue)
-    link.parent = parent
-    link.text_block = text_block
-    link
-  end
-
-  before do
-    allow(user_facing_app).to receive(:style) do |clazz, styles|
-      element_styles[clazz] = styles
-    end
-
-    allow(subject).to receive(:eval_hover_block) do |blk|
-      blk.call(subject) if blk
-    end
-  end
-
-  it_behaves_like "object with hover"
-
-  context "initialize" do
-    it "should set up text" do
-      expect(subject.texts).to eql(texts)
-      expect(subject.to_s).to  eql("textgoesfirst")
-    end
-
-    it "should set color" do
-      expect(subject.color).to eql(:blue)
-    end
-
-    it "should default styles" do
-      expect(subject.style[:underline]).to eql(true)
-      expect(subject.style[:fill]).to eql(nil)
-      expect(subject.style[:stroke]).to eql(Shoes::COLORS[:blue])
-    end
-
-    context "overriding styles" do
-      subject do
-        Shoes::Link.new(app, texts, underline: false, bg: Shoes::COLORS[:green])
-      end
-
-      it "should include defaults" do
-        expect(subject.style).to include(stroke: Shoes::COLORS[:blue])
-      end
-
-      it "should override defaults" do
-        expect(subject.style).to include(underline: false)
-      end
-
-      it "should include other options" do
-        expect(subject.style).to include(bg: Shoes::COLORS[:green])
-      end
-    end
-
-    context "with a block" do
-      let(:callable) { double("callable") }
-      subject { Shoes::Link.new(internal_app, texts, {}, proc { callable.call }) }
-
-      it "sets up for the click" do
-        expect(callable).to receive(:call)
-        subject.blk.call
-      end
-    end
-
-    context "with click option as text" do
-      subject { Shoes::Link.new(internal_app, texts, click: "/url") }
-
-      it "should visit the url" do
-        expect(app).to receive(:visit).with("/url")
-        subject.blk.call
-      end
-    end
-
-    context "with click option as Proc" do
-      let(:callable) { double("callable", call: nil) }
-      subject { Shoes::Link.new(internal_app, texts, click: proc { callable.call }) }
-
-      it "calls the block" do
-        expect(callable).to receive(:call)
-        subject.blk.call
-      end
-    end
-
-    context "calling click explicitly" do
-      let(:original_block)    { double("original") }
-      let(:replacement_block) { double("replacement") }
-      subject { Shoes::Link.new(internal_app, texts) { original_block.call } }
-
-      it "replaces original block" do
-        expect(original_block).to_not receive(:call)
-        expect(replacement_block).to receive(:call)
-
-        subject.click { replacement_block.call }
-        subject.blk.call
-      end
-    end
-  end
-
-  describe 'visibility' do
-    describe 'with a containing text block' do
-      it 'forwards #visible? calls' do
-        subject.visible?
-        expect(text_block).to have_received :visible?
-      end
-
-      it 'forwards #hidden? calls' do
-        subject.hidden?
-        expect(text_block).to have_received :hidden?
-      end
-    end
-
-    describe 'without a containing text block' do
-      it 'does not crash on #visibie?' do
-        expect { subject.visible? }.not_to raise_error
-      end
-
-      it 'does not crash on #hidden?' do
-        expect { subject.hidden? }.not_to raise_error
-      end
-    end
-  end
-
-  # #979
-  describe 'containing text block' do
-    before :each do
-      subject.parent = text_block
-    end
-
-    it 'has the correct parent, namingly he text block' do
-      expect(subject.parent).to eq text_block
-    end
-  end
-end

data/spec/shoes/list_box_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::ListBox do
-  include_context "dsl app"
-  let(:input_opts) do
-    { items: items, left: left, top: top, width: width, height: height }
-  end
-
-  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 'Updating gui' do
-    it "updates the gui when array methods like size are called" do
-      expect(list_box.gui).to receive(:update_items)
-      list_box.items.size
-    end
-
-    it "updates the gui when self-modifying array methods like map! are called" do
-      expect(list_box.gui).to receive(:update_items)
-      list_box.items.map! { "replaced!" }
-    end
-  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 not call @gui.choose when the choose option is passed' do
-      expect_any_instance_of(Shoes.configuration.backend::ListBox).to_not receive(:choose)
-      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,25 +0,0 @@
-require '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_behaves_like "object with hover"
-
-    # it_styles_with :art_styles, :center, :dimensions, :radius
-  end
-end

data/spec/shoes/packager_spec.rb

@@ -1,25 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Packager do
-  subject { Shoes::Packager.new }
-
-  it "creates packages" do
-    expect(subject.backend).to receive(:create_package).and_call_original
-    subject.create_package("program", "swt:app")
-  end
-
-  it "knows to run packaging if it created one" do
-    subject.create_package("program", "swt:app")
-    expect(subject.should_package?).to eq(true)
-  end
-
-  it "delegates run" do
-    expect(subject.backend).to receive(:run)
-    subject.run("path/to/shoes/app.rb")
-  end
-
-  it "delegates help" do
-    expect(subject.backend).to receive(:help)
-    subject.help("program")
-  end
-end