shoes-core 4.0.0.pre3

data/spec/shoes/common/inspect_spec.rb

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

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

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

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

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

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

@@ -0,0 +1,171 @@
+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
+
+    it 'runs ask dialog' do
+      # Prevent the backend from actually running by stubbing out this method
+      allow_any_instance_of(Shoes.backend::App).to receive(:wait_until_closed)
+
+      result = @dialog.ask("What?", {})
+      expect(result).to be_nil
+    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