shoes 4.0.0.pre1 → 4.0.0.pre2

data/spec/shoes/url_spec.rb

@@ -1,66 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,86 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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