shoes-swt 4.0.0.pre2 → 4.0.0.pre3

data/spec/shoes/common/inspect_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe "Shoes::Common::Inspect" do
-  let(:test_class) {
-    Class.new {
-      include Shoes::Common::Inspect
-      def self.name
-        "Shoes::InspectableObject"
-      end
-    }
-  }
-
-  describe "when included" do
-    include InspectHelpers
-
-    subject(:object) { test_class.new }
-
-    it "gives a #to_s like (Shoes::Klass)" do
-      expect(object.to_s).to eq("(Shoes::InspectableObject)")
-    end
-
-    it "gives an #inspect like (Shoes::Klass:0x000049e8)" do
-      expect(object.inspect).to match(/^[(]Shoes::InspectableObject:#{shoes_object_id_pattern}[)]$/)
-    end
-  end
-end

data/spec/shoes/common/remove_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Common::Remove do
-
-  let(:parent) {double 'parent', add_child: true, remove_child: true}
-  let(:gui) {double 'gui', remove: true}
-  let(:test_class) {Class.new {include Shoes::Common::Remove}}
-
-  subject {test_class.new}
-
-  before :each do
-    allow(subject).to receive_messages parent: parent, gui: gui
-  end
-
-  describe '#remove' do
-    before :each do
-      subject.remove
-    end
-
-    it 'calls removes itself from the parent' do
-      expect(parent).to have_received(:remove_child).with(subject)
-    end
-
-    it 'calls remove on the gui' do
-      expect(gui).to have_received(:remove)
-    end
-
-    describe 'if the gui does not respond to clear' do
-      # need to stub clear and respond_to because we get a non stubbed method
-      # otherwise on our spies when verifying...
-      let(:gui) {double 'no clear gui', clear: true, respond_to?: false}
-
-      it 'does not call clear on the gui' do
-        expect(gui).not_to have_received(:clear)
-      end
-    end
-  end
-end

data/spec/shoes/common/style_normalizer_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Common::StyleNormalizer do
-  subject {Shoes::Common::StyleNormalizer.new}
-
-  it 'does not modify a simple hash' do
-    input = {left: 100, width: 233}
-    expect(subject.normalize input).to eq input
-  end
-
-  it 'turns hexcodes for fill into colors' do
-    input = {fill: 'ffffff'}
-    expected = {fill: Shoes::Color.new(255, 255, 255)}
-    expect(subject.normalize input).to eq expected
-  end
-  
-  it 'turns hexcodes for stroke into colors' do
-    input = {stroke: 'ffffff'}
-    expected = {stroke: Shoes::Color.new(255, 255, 255)}
-    expect(subject.normalize input).to eq expected
-  end
-
-  it 'does not modify the original hash' do
-    input = {stroke: '333333'}
-    subject.normalize input
-    expect(input).to eq({stroke: '333333'})
-  end
-end

data/spec/shoes/common/style_spec.rb

@@ -1,147 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Common::Style do
-  include_context "dsl app"
-  let(:blue) { Shoes::COLORS[:blue] }
-
-  class StyleTester
-    include Shoes::Common::Style
-    attr_accessor :left
-    style_with :key, :left, :click, :strokewidth, :fill
-    STYLES = {fill: Shoes::COLORS[:blue]}
-
-    def initialize(app, styles = {})
-      @app = app #needed for style init
-      style_init(styles, key: 'value')
-      @left = 15
-    end
-
-    def click(&arg)
-      @click = arg
-    end
-
-    def click_blk
-      @click
-    end
-  end
-  subject {StyleTester.new(app)}
-
-  its(:style) { should eq (initial_style) }
-  let(:initial_style) { {key: 'value', left: 15, click: nil, strokewidth: 1, fill: blue} }
-
-  describe 'reading and writing through #style(hash)' do
-    let(:input_proc) { Proc.new {} }
-    let(:changed_style) { {key: 'changed value'} }
-
-
-    before :each do
-      subject.style changed_style
-    end
-
-    it 'returns the changed style' do
-      expect(subject.style).to eq initial_style.merge changed_style
-    end
-
-    it 'does update values for new values' do
-      subject.style new_key: 'new value'
-      expect(subject.style[:new_key]).to eq 'new value'
-    end
-
-    it 'reads new dimensions' do
-      subject.left = 20
-      expect(subject.style[:left]).to eq 20
-    end
-
-    it 'writes new dimensions' do
-      subject.style(left: 200)
-      expect(subject.left).to eq 200
-    end
-
-    it 'sets click' do
-      subject.style(click: input_proc)
-      expect(subject.click_blk).to eq input_proc
-    end
-
-    it 'sets non dimension non click style via setter' do
-      subject.key = 'silver'
-      expect(subject.style[:key]).to eq 'silver'
-    end
-
-    it 'gets non dimension non click style via getter' do
-      expect(subject.key).to eq 'changed value'
-    end
-
-    # these specs are rather extensive as they are performance critical for
-    # redrawing
-    describe 'calling or not calling #update_style' do
-      it 'does not call #update_style if no key value pairs changed' do
-        expect(subject).not_to receive(:update_style)
-        subject.style changed_style
-      end
-
-      it 'does not call #update_style if called without arg' do
-        expect(subject).not_to receive(:update_style)
-        subject.style
-      end
-
-      it 'does call #update_style if the values change' do
-        expect(subject).to receive(:update_style)
-        subject.style key: 'new value'
-      end
-
-      it 'does call #update_style if there is a new key-value' do
-        expect(subject).to receive(:update_style)
-        subject.style new_key: 'value'
-      end
-    end
-  end
-
-  describe "app-default" do
-    it "reads app-default styles with reader" do
-      expect(subject.strokewidth).to eq 1
-    end
-
-    it "writes app-default styles with writer" do
-      subject.strokewidth = 5
-      expect(subject.strokewidth).to eq 5
-    end
-
-    it "does not read 'default' styles that it doesn't support" do
-      expect(subject).not_to respond_to :stroke
-    end
-
-    it "does not write 'default' styles that it doesn't support" do
-      expect(subject).not_to respond_to :stroke=
-    end
-  end
-
-  describe "style priorities" do
-    subject {StyleTester.new(app, key: 'pumpkin')}
-
-    it 'uses arguments-styles over element-styles' do
-      expect(subject.key).to eq 'pumpkin'
-    end
-
-    it "uses element-defaults over app-defaults" do
-      expect(subject.fill).to eq blue
-    end
-
-    #related priority specs are tested individually in spec/shared_examples/style
-  end
-
-  describe 'StyleWith' do
-    it 'ensures that readers exist for each supported style' do
-      subject.supported_styles.each do |style|
-        expect(subject).to respond_to style
-      end
-    end
-
-    it 'ensures that writers exist for each supported style' do
-      subject.supported_styles.each do |style|
-        expect(subject).to respond_to "#{style}="
-      end
-    end
-
-  end
-
-end

data/spec/shoes/configuration_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Configuration do
-  after { Shoes.configuration.reset }
-
-  describe "#logger" do
-    describe ":ruby" do
-      before { Shoes.configuration.logger = :ruby }
-
-      it "uses the Ruby logger" do
-        expect(Shoes.logger.instance_of?(Shoes::Logger::Ruby)).to eq(true)
-      end
-    end
-  end
-
-  describe "backend" do
-    include_context "dsl app"
-
-    let(:dsl_object) { Shoes::Shape.new app, parent}
-
-    describe "#backend_with_app_for" do
-      it "passes app.gui to backend" do
-        expect(Shoes.configuration.backend::Shape).to receive(:new).with(an_instance_of(Shoes::Shape), app.gui).and_call_original
-        dsl_object
-      end
-
-      it "returns shape backend object" do
-        expect(Shoes.configuration.backend_with_app_for(dsl_object)).to be_instance_of(Shoes.configuration.backend::Shape)
-      end
-
-      it "raises ArgumentError for a non-Shoes object" do
-        expect { Shoes.configuration.backend_with_app_for(1..100) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/shoes/constants_spec.rb

@@ -1,38 +0,0 @@
-require "pathname"
-
-describe "Shoes constants" do
-  specify "PI equals Math::PI" do
-    expect(Shoes::PI).to eq(Math::PI)
-  end
-
-  specify "TWO_PI equals 2 * Math::PI" do
-    expect(Shoes::TWO_PI).to eq(2 * Math::PI)
-  end
-
-  specify "HALF_PI equals 0.5 * Math::PI" do
-    expect(Shoes::HALF_PI).to eq(0.5 * Math::PI)
-  end
-
-  describe "DIR" do
-    let(:shoes_home_dir) { Pathname.new(__FILE__).join("../../..").expand_path }
-    subject { Pathname.new Shoes::DIR }
-
-    it "is the shoes home directory" do
-      expect(subject).to eq(shoes_home_dir)
-    end
-
-    it "contains lib/shoes.rb" do
-      expect(subject.join("lib/shoes.rb")).to exist
-    end
-
-    it "contains static/shoes_icon.png" do
-      expect(subject.join("static/shoes-icon.png")).to exist
-    end
-
-    it "remains constant when current directory changes" do
-      Dir.chdir ".." do
-        expect(subject).to eq(shoes_home_dir)
-      end
-    end
-  end
-end

data/spec/shoes/dialog_spec.rb

@@ -1,163 +0,0 @@
-require 'shoes/spec_helper'
-# NOTE: This spec is sadly circumventing the integration specs since we couldn't
-# figure out how to get rid of the alert - it stopped the running tests
-
-main_object = self
-
-describe Shoes::Dialog do
-
-  before :each do
-    @dialog = Shoes::Dialog.new
-  end
-
-  it 'is not nil' do
-    expect(@dialog).not_to be_nil
-  end
-
-  describe '#alert' do
-    it 'returns nil' do
-      expect(@dialog.alert('something')).to be_nil
-    end
-  end
-
-  describe '#confirm' do
-    it 'responds to it' do
-      expect(@dialog).to respond_to :confirm
-    end
-  end
-
-  describe '#ask_open_file' do
-    it 'responds to it' do
-      expect(@dialog).to respond_to :dialog_chooser
-    end
-  end
-
-  describe '#ask_save_file' do
-    it 'responds to it' do
-      expect(@dialog).to respond_to :dialog_chooser
-    end
-  end
-
-  describe '#ask_open_folder' do
-    it 'responds to it' do
-      expect(@dialog).to respond_to :dialog_chooser
-    end
-  end
-
-  describe '#ask_save_folder' do
-    it 'responds to it' do
-      expect(@dialog).to respond_to :dialog_chooser
-    end
-  end
-
-  describe '#ask' do
-    it 'responds to it' do
-      expect(@dialog).to respond_to :ask
-    end
-  end
-
-  describe '#ask_color' do
-    it 'responds to it' do
-      expect(@dialog).to respond_to :ask_color
-    end
-  end
-
-  describe 'nothing monkey patched on to Object' do
-    it 'is not monkey patched on to object' do
-      expect(Object.new).not_to respond_to :alert
-    end
-
-    it 'is not monkey patched on to object' do
-      expect(Object.new).not_to respond_to :confirm
-    end
-
-    it 'is not monkey patched on to object' do
-      expect(Object.new).not_to respond_to :dialog_chooser
-    end
-
-    it 'is not monkey patched on to object' do
-      expect(Object.new).not_to respond_to :ask
-    end
-
-    it 'is not monkey patched on to object' do
-      expect(Object.new).not_to respond_to :ask_color
-    end
-  end
-
-  describe 'the main object' do
-    it 'knows of #alert' do
-      expect(main_object).to respond_to :alert
-    end
-
-    it 'knows of #confirm' do
-      expect(main_object).to respond_to :confirm
-    end
-
-    it 'knows of #confirm?' do
-      expect(main_object).to respond_to :confirm?
-    end
-
-    it 'knows of #ask_open_file' do
-      expect(main_object).to respond_to :ask_open_file
-    end
-
-    it 'knows of #ask_save_file' do
-      expect(main_object).to respond_to :ask_save_file
-    end
-
-    it 'knows of #ask_open_folder' do
-      expect(main_object).to respond_to :ask_open_folder
-    end
-
-    it 'knows of #ask_save_folder' do
-      expect(main_object).to respond_to :ask_save_folder
-    end
-
-    it 'knows of #ask' do
-      expect(main_object).to respond_to :ask
-    end
-
-    it 'knows of #ask' do
-      expect(main_object).to respond_to :ask_color
-    end
-  end
-
-  describe 'Shoes::App' do
-    before :each do
-      @app = Shoes::App.new
-    end
-
-    it 'knows about #alert' do
-      expect(@app).to respond_to :alert
-    end
-
-    it 'knows about #confirm' do
-      expect(@app).to respond_to :confirm
-    end
-
-    it 'knows about #ask_open_file' do
-      expect(@app).to respond_to :ask_open_file
-    end
-
-    it 'knows about #ask_save_file' do
-      expect(@app).to respond_to :ask_save_file
-    end
-
-    it 'knows about #ask_open_folder' do
-      expect(@app).to respond_to :ask_open_folder
-    end
-
-    it 'knows about #ask_save_folder' do
-      expect(@app).to respond_to :ask_save_folder
-    end
-
-    it 'knows about #ask_save_folder' do
-      expect(@app).to respond_to :ask
-    end
-
-    it 'knows about #ask_save_color' do
-      expect(@app).to respond_to :ask_color
-    end
-  end
-
-end