shoes 3.0.1 → 4.0.0.pre1

data/spec/shoes/url_spec.rb

@@ -0,0 +1,66 @@
+require 'shoes/spec_helper'
+
+describe 'Shoes.url' do
+  let(:klazz) do
+    Class.new(Shoes) do
+      url '/', :index
+      url '/path', :path
+      url '/number/(\d+)', :number
+      url '/foo', :foo
+      url '/visit_me', :visit_me
+
+      def index
+      end
+
+      def path
+      end
+
+      def number(i)
+      end
+
+      def foo
+        some_method
+      end
+
+      def visit_me
+        location.should == '/visit_me'
+      end
+
+      def some_method
+      end
+    end
+  end
+
+  subject do
+    Shoes.app
+  end
+
+  it "should call index upon startup" do
+    klazz.any_instance.should_receive(:index)
+    subject
+  end
+
+  it 'should receive path when visitting path' do
+    klazz.any_instance.should_receive(:path)
+    Shoes.app do visit '/path' end
+  end
+
+  it 'handles the arguments given in the regexes' do
+    klazz.any_instance.should_receive(:number).with('7')
+    Shoes.app do visit '/number/7' end
+  end
+
+  it 'can call methods defined in the URL class when visitting a URL' do
+    klazz.any_instance.should_receive(:some_method)
+    Shoes.app do visit '/foo' end
+  end
+
+  it 'has a location method that returns the current URL' do
+    Shoes.app do visit '/visit_me' end
+  end
+
+  it 'instances report class as klazz (regression, do not ask...)' do
+    expect(klazz.new.class).to eq klazz
+  end
+
+end

data/spec/shoes/widget_spec.rb

@@ -0,0 +1,34 @@
+require 'shoes/spec_helper'
+
+class Smile < Shoes::Widget
+  def initialize(caption)
+    banner caption
+  end
+end
+
+describe Shoes::Widget do
+  let(:app) { Shoes::App.new }
+
+  it "creates dsl method on App" do
+    app.should respond_to(:smile)
+  end
+
+  it "generates instances of its subclass" do
+    app.smile("Cheese!").should be_instance_of(Smile)
+  end
+
+  it "passes missing methods to app" do
+    app.should_receive(:banner).with("Pickles!")
+    app.smile("Pickles!")
+  end
+
+  it 'sets the current slot as the parent' do
+    slot = nil
+    widget = nil
+    Shoes.app do
+      slot = instance_variable_get(:@__app__).current_slot
+      widget = smile 'lalala'
+    end
+    expect(widget.parent).to eq slot
+  end
+end

data/spec/shoes_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Shoes, 'load_backend' do
+  it "raises ArgumentError on bad input" do
+    expect { Shoes.load_backend :bogus }.to raise_error
+  end
+end
+
+describe Shoes, 'setup' do
+
+  it 'knows this method' do
+    Shoes.should respond_to :setup
+  end
+
+  describe 'outputting on standard error' do
+
+    def expect_stderr_puts(regex)
+      $stderr.should_receive(:puts).with(regex)
+    end
+
+    before :each do
+      expect_stderr_puts(/WARN.+deprecated/)
+    end
+
+    it 'puts a warning message to $stderr' do
+      Shoes.setup do end
+    end
+
+    it 'warns for individual gems' do
+      expect_stderr_puts(/WARN.+foo.+gem install foo/)
+      Shoes.setup do
+        gem 'foo'
+      end
+    end
+
+    it 'even reports the version number' do
+      expect_stderr_puts(/gem install foo --version \"~>2.10.0\"/)
+      Shoes.setup do
+        gem 'foo ~>2.10.0'
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+SHOESSPEC_ROOT = File.expand_path('..', __FILE__)
+$LOAD_PATH << File.join('../lib', SHOESSPEC_ROOT)
+
+require 'code_coverage'
+require 'rspec'
+require 'pry'
+require 'shoes'
+require 'async_helper'
+require 'shoes/helpers/fake_element'
+
+RSpec.configure do |c|
+  c.treat_symbols_as_metadata_keys_with_true_values = true
+end
+
+shared_examples = File.expand_path('../shoes/shared_examples/**/*.rb', __FILE__)
+Dir[shared_examples].each { |f| require f }

data/spec/swt_shoes/animation_spec.rb

@@ -0,0 +1,86 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Animation do
+  include_context 'swt app'
+  let(:dsl) { double('dsl', :stopped? => false, :removed? => false,
+                     :framerate => 10, :current_frame => nil,
+                     :increment_frame => nil, :blk => block) }
+  let(:block) { double 'block', call: nil }
+  let(:display) { ::Swt.display }
+  subject { Shoes::Swt::Animation.new dsl, swt_app }
+
+  before :each do
+    display.stub(:timer_exec)
+  end
+
+  it "triggers an Swt timer" do
+    display.should_receive(:timer_exec)
+    subject
+  end
+
+  it "gets framerate" do
+    expect(dsl).to receive(:framerate)
+    subject
+  end
+
+  describe "task" do
+    let(:task) { subject.task }
+
+    it "calls block" do
+      expect(block).to receive(:call)
+      task.call
+    end
+
+    it "gets framerate" do
+      expect(dsl).to receive(:framerate)
+      task.call
+    end
+
+    it "triggers redraw" do
+      with_redraws do
+        expect(swt_app).to receive(:flush)
+        task.call
+      end
+    end
+
+    it "counts frames" do
+      expect(dsl).to receive(:increment_frame)
+      task.call
+    end
+
+    describe 'disabled' do
+      describe 'stopped?' do
+        before :each do
+          dsl.stub :stopped? => true
+          task.call
+        end
+
+        it 'does not call the block' do
+          expect(block).to_not have_received :call
+        end
+
+        it 'continues calling the task' do
+          # one for initialize, one for the call in the task call
+          expect(display).to have_received(:timer_exec).exactly(2).times
+        end
+      end
+
+      describe 'removed?' do
+        before :each do
+          dsl.stub :removed? => true
+          task.call
+        end
+
+        it 'does not call the block when removed' do
+          expect(block).to_not have_received :call
+        end
+
+        it 'does not continue calling itself when removed' do
+          # one time is initialize
+          expect(display).to have_received(:timer_exec).exactly(1).times
+        end
+      end
+    end
+
+  end
+end

data/spec/swt_shoes/app_spec.rb

@@ -0,0 +1,75 @@
+require "swt_shoes/spec_helper"
+
+describe Shoes::Swt::App do
+  let(:opts) { {:background => Shoes::COLORS[:salmon], :resizable => true} }
+  let(:app) { double('app', :opts => opts,
+                            :width => width,
+                            :height => 0,
+                            :app_title => 'double') }
+
+  let(:opts_unresizable) { {:background => Shoes::COLORS[:salmon],
+                            :resizable => false} }
+  let(:app_unresizable) { double('app', :opts => opts_unresizable,
+                                        :width => 0,
+                                        :height => 0,
+                                        :app_title => 'double') }
+  let(:width) {0}
+
+  subject { Shoes::Swt::App.new(app) }
+
+  it { should respond_to :clipboard }
+  it { should respond_to :clipboard= }
+
+  before :each do
+    Shoes::Swt.unregister_all
+  end
+
+  context "when registering" do
+    it "registers" do
+      old_apps_length = Shoes::Swt.apps.length
+      subject
+      Shoes::Swt.apps.length.should eq(old_apps_length + 1)
+      Shoes::Swt.apps.include?(subject).should be_true
+    end
+  end
+
+  context "when running on a mac" do
+    let(:the_display) { ::Swt::Widgets::Display }
+
+    it "should set the menubar title" do
+      the_display.should_receive(:app_name=).with('double')
+      subject
+    end
+  end
+
+  context "main window style" do
+    BASE_BITMASK =  Swt::SWT::CLOSE   |
+                    Swt::SWT::MIN     |
+                    Swt::SWT::MAX     |
+                    Swt::SWT::RESIZE  |
+                    Swt::SWT::V_SCROLL
+
+    it "should return a bitmask that represents being resizable" do
+      subject.send(:main_window_style).should eq(BASE_BITMASK)
+    end
+
+    it "should return a bitmask that represents not being resizable" do
+      resizable = Shoes::Swt::App.new app_unresizable
+      resizable.send(:main_window_style).should eq(BASE_BITMASK & ~Swt::SWT::RESIZE )
+    end
+  end
+
+  context "when attempting to copy text" do
+    it "copies text to clipboard" do
+      pending 'Seems to be broken with tmux please see/fix #398'
+      text = "test"
+      subject.clipboard = text
+      subject.clipboard.should eq(text)
+    end
+  end
+
+  # fully testing the behavior would require stubbing for all of the open logic
+  # which at the time is overkill imo
+  it {should respond_to :started?}
+
+end

data/spec/swt_shoes/arc_spec.rb

@@ -0,0 +1,101 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Arc do
+  include_context "swt app"
+
+  let(:left) { 100 }
+  let(:top) { 200 }
+  let(:width) { 300 }
+  let(:height) { 400 }
+  let(:angle1) { Shoes::PI }
+  let(:angle2) { Shoes::HALF_PI }
+  let(:dsl) { double("dsl object", app: shoes_app, element_width: width,
+                     element_height: height, element_left: left,
+                     element_top: top, angle1: angle1, angle2: angle2,
+                     wedge?: false,  hidden: false).as_null_object }
+  let(:fill_color) { Shoes::Color.new(40, 50, 60, 70) }
+  let(:stroke_color) { Shoes::Color.new(80, 90, 100, 110) }
+
+  subject { Shoes::Swt::Arc.new(dsl, swt_app) }
+
+  describe "basics" do
+    specify "converts angle1 to degrees" do
+      subject.angle1.should eq(180.0)
+    end
+
+    specify "converts angle2 to degrees" do
+      subject.angle2.should eq(90.0)
+    end
+
+    specify "delegates #wedge? to dsl object" do
+      dsl.should_receive(:wedge?) { false }
+      subject.should_not be_wedge
+    end
+  end
+
+  it_behaves_like "paintable"
+  it_behaves_like "togglable"
+
+  describe "painter" do
+    include_context "painter context"
+
+    let(:shape) { Shoes::Swt::Arc.new(dsl, swt_app) }
+    subject { Shoes::Swt::Arc::Painter.new(shape) }
+
+    it_behaves_like "stroke painter"
+    it_behaves_like "fill painter"
+
+    context "normal fill style" do
+      before :each do
+        shape.stub(wedge?: false)
+      end
+
+      specify "fills arc using path" do
+        gc.should_receive(:fill_path)
+        subject.paint_control(event)
+      end
+
+      specify "draws arc" do
+        gc.should_receive(:draw_arc)
+        subject.paint_control(event)
+      end
+
+      # Swt measures the arc counterclockwise, while Shoes measures it clockwise.
+      specify "translates DSL values for Swt" do
+        path = double('path')
+        ::Swt::Path.stub(:new) { path }
+        args = [100, 200, width, height, 180.0, -90.0]
+        path.should_receive(:add_arc).with(*args)
+        sw = 10
+        args = [100+sw/2, 200+sw/2, width-sw, height-sw, 180, -90.0]
+        gc.should_receive(:draw_arc).with(*args)
+        subject.paint_control(gc)
+      end
+    end
+
+    context "wedge fill style" do
+      before :each do
+        shape.stub(wedge?: true)
+      end
+
+      specify "fills arc" do
+        gc.should_receive(:fill_arc)
+        subject.paint_control(event)
+      end
+
+      specify "draws arc" do
+        gc.should_receive(:draw_arc)
+        subject.paint_control(event)
+      end
+
+      specify "translates DSL values for Swt" do
+        args = [100, 200, width, height, 180, -90.0]
+        gc.should_receive(:fill_arc).with(*args)
+        sw = 10
+        args = [100+sw/2, 200+sw/2, width-sw, height-sw, 180, -90.0]
+        gc.should_receive(:draw_arc).with(*args)
+        subject.paint_control(gc)
+      end
+    end
+  end
+end

data/spec/swt_shoes/background_spec.rb

@@ -0,0 +1,56 @@
+require 'swt_shoes/spec_helper'
+
+describe Shoes::Swt::Background do
+  include_context "swt app"
+
+  let(:left) { 55 }
+  let(:top) { 77 }
+  let(:width) { 222 }
+  let(:height) { 111 }
+  let(:corners) { 0 }
+  let(:dsl) { double("dsl object", app: shoes_app,
+                     element_left: left, element_top: top,
+                     element_width: width, element_height: height,
+                     strokewidth: 1, corners: corners,
+                     hidden: false).as_null_object }
+
+  subject {
+    Shoes::Swt::Background.new dsl, swt_app
+  }
+
+  context "#initialize" do
+    it { should be_an_instance_of(Shoes::Swt::Background) }
+    its(:dsl) { should be(dsl) }
+  end
+
+  it_behaves_like "paintable"
+  it_behaves_like "togglable"
+
+  describe "painter" do
+    include_context "painter context"
+
+    let(:corners) { 0 }
+    let(:shape) { Shoes::Swt::Background.new dsl, swt_app}
+    subject { Shoes::Swt::Background::Painter.new shape }
+
+    it_behaves_like "fill painter"
+
+    describe "square corners" do
+      let(:corners) { 0 }
+
+      it "fills rect" do
+        gc.should_receive(:fill_round_rectangle).with(left, top, width, height, corners*2, corners*2)
+        subject.paint_control(event)
+      end
+    end
+
+    describe "round corners" do
+      let(:corners) { 13 }
+
+      it "fills rect" do
+        gc.should_receive(:fill_round_rectangle).with(left, top, width, height, corners*2, corners*2)
+        subject.paint_control(event)
+      end
+    end
+  end
+end