shoes 3.0.1 → 4.0.0.pre1

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,58 @@
+require 'spec_helper'
+
+describe Shoes::Common::Style do
+
+  class StyleTester
+    include Shoes::Common::Style
+
+    def initialize(style = {})
+      @style = style
+    end
+  end
+
+  subject {StyleTester.new}
+
+  its(:style) {should eq Hash.new}
+
+  describe 'changing the style trhough #style(hash)' do
+    let(:changed_style) {{key: 'value'}}
+
+    before :each do
+      subject.style changed_style
+    end
+
+    it 'returns the changed style' do
+      expect(subject.style).to eq 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
+
+    # 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
+
+end

data/spec/shoes/configuration_spec.rb

@@ -0,0 +1,37 @@
+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
+        Shoes.logger.instance_of?(Shoes::Logger::Ruby).should == true
+      end
+    end
+  end
+
+  describe "backend" do
+    include_context "dsl app"
+
+    let(:args) { Hash.new }
+    let(:dsl_object) { Shoes::Shape.new app, args }
+
+    describe "#backend_with_app_for" do
+      it "passes app.gui to backend" do
+        Shoes.configuration.backend::Shape.should_receive(:new).with(dsl_object, app.gui, args)
+        dsl_object
+      end
+
+      it "returns shape backend object" do
+        Shoes.configuration.backend_with_app_for(dsl_object, args).should be_instance_of(Shoes.configuration.backend::Shape)
+      end
+
+      it "raises ArgumentError for a non-Shoes object" do
+        lambda { Shoes.configuration.backend_with_app_for(1..100) }.should 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
+    Shoes::PI.should eq(Math::PI)
+  end
+
+  specify "TWO_PI equals 2 * Math::PI" do
+    Shoes::TWO_PI.should eq(2 * Math::PI)
+  end
+
+  specify "HALF_PI equals 0.5 * Math::PI" do
+    Shoes::HALF_PI.should 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
+      subject.should eq(shoes_home_dir)
+    end
+
+    it "contains lib/shoes.rb" do
+      subject.join("lib/shoes.rb").should exist
+    end
+
+    it "contains static/shoes_icon.png" do
+      subject.join("static/shoes-icon.png").should exist
+    end
+
+    it "remains constant when current directory changes" do
+      Dir.chdir ".." do
+        subject.should eq(shoes_home_dir)
+      end
+    end
+  end
+end

data/spec/shoes/dialog_spec.rb

@@ -0,0 +1,163 @@
+require 'spec/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
+    @dialog.should_not be_nil
+  end
+
+  describe '#alert' do
+    it 'returns nil' do
+      @dialog.alert('something').should be_nil
+    end
+  end
+
+  describe '#confirm' do
+    it 'responds to it' do
+      @dialog.should respond_to :confirm
+    end
+  end
+
+  describe '#ask_open_file' do
+    it 'responds to it' do
+      @dialog.should respond_to :dialog_chooser
+    end
+  end
+
+  describe '#ask_save_file' do
+    it 'responds to it' do
+      @dialog.should respond_to :dialog_chooser
+    end
+  end
+
+  describe '#ask_open_folder' do
+    it 'responds to it' do
+      @dialog.should respond_to :dialog_chooser
+    end
+  end
+
+  describe '#ask_save_folder' do
+    it 'responds to it' do
+      @dialog.should respond_to :dialog_chooser
+    end
+  end
+
+  describe '#ask' do
+    it 'responds to it' do
+      @dialog.should respond_to :ask
+    end
+  end
+
+  describe '#ask_color' do
+    it 'responds to it' do
+      @dialog.should respond_to :ask_color
+    end
+  end
+
+  describe 'nothing monkey patched on to Object' do
+    it 'is not monkey patched on to object' do
+      Object.new.should_not respond_to :alert
+    end
+
+    it 'is not monkey patched on to object' do
+      Object.new.should_not respond_to :confirm
+    end
+
+    it 'is not monkey patched on to object' do
+      Object.new.should_not respond_to :dialog_chooser
+    end
+
+    it 'is not monkey patched on to object' do
+      Object.new.should_not respond_to :ask
+    end
+
+    it 'is not monkey patched on to object' do
+      Object.new.should_not respond_to :ask_color
+    end
+  end
+
+  describe 'the main object' do
+    it 'knows of #alert' do
+      main_object.should respond_to :alert
+    end
+
+    it 'knows of #confirm' do
+      main_object.should respond_to :confirm
+    end
+
+    it 'knows of #confirm?' do
+      main_object.should respond_to :confirm?
+    end
+
+    it 'knows of #ask_open_file' do
+      main_object.should respond_to :ask_open_file
+    end
+
+    it 'knows of #ask_save_file' do
+      main_object.should respond_to :ask_save_file
+    end
+
+    it 'knows of #ask_open_folder' do
+      main_object.should respond_to :ask_open_folder
+    end
+
+    it 'knows of #ask_save_folder' do
+      main_object.should respond_to :ask_save_folder
+    end
+
+    it 'knows of #ask' do
+      main_object.should respond_to :ask
+    end
+
+    it 'knows of #ask' do
+      main_object.should respond_to :ask_color
+    end
+  end
+
+  describe 'Shoes::App' do
+    before :each do
+      @app = Shoes::App.new
+    end
+
+    it 'knows about #alert' do
+      @app.should respond_to :alert
+    end
+
+    it 'knows about #confirm' do
+      @app.should respond_to :confirm
+    end
+
+    it 'knows about #ask_open_file' do
+      @app.should respond_to :ask_open_file
+    end
+
+    it 'knows about #ask_save_file' do
+      @app.should respond_to :ask_save_file
+    end
+
+    it 'knows about #ask_open_folder' do
+      @app.should respond_to :ask_open_folder
+    end
+
+    it 'knows about #ask_save_folder' do
+      @app.should respond_to :ask_save_folder
+    end
+
+    it 'knows about #ask_save_folder' do
+      @app.should respond_to :ask
+    end
+
+    it 'knows about #ask_save_color' do
+      @app.should respond_to :ask_color
+    end
+  end
+
+end

data/spec/shoes/dimension_spec.rb

@@ -0,0 +1,381 @@
+require 'spec_helper'
+
+describe Shoes::Dimension do
+
+  subject {Shoes::Dimension.new parent_dimension}
+  let(:start) {10}
+  let(:extent) {21}
+  let(:parent_element_start) {34}
+  let(:parent_element_end) {83}
+  let(:parent_element_extent) {600}
+  let(:parent_dimension) { double 'parent_dimension',
+                                  element_start:  parent_element_start,
+                                  element_end:    parent_element_end,
+                                  element_extent: parent_element_extent }
+
+  ONE_PIXEL = 1
+
+  describe 'initialization' do
+    describe 'without arguments (even no parent)' do
+      subject {Shoes::Dimension.new nil}
+
+      its(:start) {should eq nil}
+      its(:end) {should eq nil}
+      its(:extent) {should eq nil}
+      its(:margin_start) {should eq 0}
+      its(:margin_end) {should eq 0}
+      its(:displace_start) {should eq 0}
+      it {should_not be_positioned}
+      it {should_not be_absolute_position}
+      it {should_not be_start_as_center}
+    end
+
+    describe 'with a parent and being positioned itself' do
+      subject {Shoes::Dimension.new parent_dimension}
+
+      TESTING_OFFSET = 11
+
+      before :each do
+        subject.absolute_start = parent_element_start + TESTING_OFFSET
+        subject.extent = 10
+      end
+
+      its(:start) {should eq TESTING_OFFSET}
+      its(:end) {should eq parent_element_end - subject.element_end}
+    end
+
+    describe 'start as center' do
+      subject {Shoes::Dimension.new parent_dimension, true}
+      it {should be_start_as_center}
+
+      it 'takes start as the center' do
+        subject.extent = 100
+        subject.start = 60
+        expect(subject.start).to eq 10
+      end
+    end
+  end
+
+  describe 'extent' do
+    let(:parent_element_extent) {600}
+    let(:parent_extent) {580}
+    let(:parent) {double 'parent', element_extent: parent_element_extent,
+                                   extent: parent_extent}
+
+    subject {Shoes::Dimension.new parent}
+
+    it 'gets and sets' do
+      subject.extent = extent
+      expect(subject.extent).to eq extent
+    end
+
+    describe 'negative values' do
+      it 'subtracts them from the parent taking margins into account' do
+        subject.extent = -70
+        expect(subject.extent).to eq parent_element_extent - 70
+      end
+    end
+
+    describe 'relative values from the parent taking margins into account' do
+      it 'takes them relative to the parent for smaller values' do
+        subject.extent = 0.8
+        expect(subject.extent).to be_within(ONE_PIXEL).of 0.8 *
+                                                          parent_element_extent
+      end
+
+      it 'handles negative relative values' do
+        subject.extent = -0.3
+        expect(subject.extent).to be_within(ONE_PIXEL).of 0.7 *
+                                                          parent_element_extent
+      end
+
+      it 'equal parent extent for 1.0' do
+        subject.extent = 1.0
+        expect(subject.extent).to eq parent_element_extent
+      end
+
+      it 'does not take them relative to the parent for bigger values' do
+        subject.extent = 1.3
+        expect(subject.extent).to eq 1.3
+      end
+    end
+
+    describe 'string values' do
+      it 'handles pure number strings' do
+        subject.extent = '100'
+        expect(subject.extent).to eq 100
+      end
+
+      it 'handles px strings' do
+        subject.extent = '80px'
+        expect(subject.extent).to eq 80
+      end
+
+      it 'takes care of some px white space' do
+        subject.extent = '70 px'
+        expect(subject.extent).to eq 70
+      end
+
+      it 'also handles negative values' do
+        subject.extent = '-50px'
+        expect(subject.extent).to eq parent_element_extent - 50
+      end
+
+      it 'handles percent as relative value' do
+        subject.extent = '75%'
+        expect(subject.extent).to be_within(ONE_PIXEL).of 0.75 *
+                                                          parent_element_extent
+      end
+
+      it 'handles negative percent values' do
+        subject.extent = '-10%'
+        expect(subject.extent).to be_within(ONE_PIXEL).of 0.9 *
+                                                           parent_element_extent
+      end
+
+      it 'handles percent values with floats' do
+        subject.extent = '20.5%'
+        expect(subject.extent).to be_within(ONE_PIXEL).of 0.205 *
+                                                           parent_element_extent
+      end
+
+      it 'returns nil for invalid strings' do
+        subject.extent = 'hell0'
+        expect(subject.extent).to be_nil
+      end
+    end
+  end
+
+  describe 'start' do
+    let(:start) {23}
+
+    before :each do
+      subject.start = start
+    end
+
+    its(:start) {should eq start}
+    it {should be_absolute_position}
+
+    it 'can set a start relative to parent element_extent' do
+      subject.start = 0.3
+      expected = 0.3 * parent_element_extent
+      expect(subject.start).to be_within(ONE_PIXEL).of expected
+    end
+
+    # might be surprising if people do calculations that result in a float
+    # and all of a sudden they have 10.4 and the button is nowhere to be found
+    it 'uses literal float values for values over 1.0' do
+      subject.start = 1.01
+      expect(subject.start).to eq 1.01
+    end
+
+    context 'without a parent' do
+      let(:parent_dimension) {nil}
+
+      it 'just takes the relative value' do
+        subject.start = 0.8
+        expect(subject.start).to eq 0.8
+      end
+    end
+  end
+
+  describe 'absolute_start' do
+    let(:absolute_start) {8}
+
+    before :each do
+      subject.absolute_start = absolute_start
+    end
+
+    it 'gets and sets absolute_start' do
+      expect(subject.absolute_start).to eq absolute_start
+    end
+
+    it {should be_positioned}
+  end
+
+  describe 'absolute_end' do
+    it 'is the sum of start and extent' do
+      subject.absolute_start = 7
+      subject.extent = 22
+      expect(subject.absolute_end).to eq 29 - ONE_PIXEL # pixel counting adjustment
+    end
+  end
+
+  describe 'margins' do
+
+    let(:margin_start) {11}
+    let(:margin_end) {17}
+
+    before :each do
+      subject.margin_start = margin_start
+      subject.margin_end = margin_end
+    end
+
+    its(:margin_start) {should eq margin_start}
+    its(:margin_end) {should eq margin_end}
+
+    context 'absolute_start set' do
+      let(:absolute_start) {7}
+
+      before :each do
+        subject.absolute_start = absolute_start
+      end
+
+      it 'does not influence absolute_start' do
+        expect(subject.absolute_start).to eq absolute_start
+      end
+
+      it 'does influence element_start' do
+        expect(subject.element_start).to eq absolute_start + margin_start
+      end
+
+      context 'extent set' do
+        let(:extent) {67}
+
+        before :each do
+          subject.extent = extent
+        end
+
+        it 'does not influence absolute_end' do
+          expect(subject.absolute_end).to eq absolute_start + extent - ONE_PIXEL
+        end
+
+        it 'does influence element_end' do
+          expect(subject.element_end).to eq absolute_start + extent -
+                                              margin_end - ONE_PIXEL
+        end
+      end
+
+      context 'element_extent set' do
+        let(:element_extent) {77}
+
+        before :each do
+          subject.element_extent = element_extent
+        end
+
+        its(:element_extent) {should eq element_extent}
+        its(:extent) {should eq element_extent + margin_start + margin_end}
+        its(:element_end) {should eq subject.element_start + element_extent -
+                                       ONE_PIXEL}
+      end
+    end
+  end
+
+  describe 'in_bounds?' do
+    let(:absolute_start) {20}
+    let(:extent) {100}
+    let(:absolute_end) {20 + 100 -ONE_PIXEL} # -1 due to pixel counting adjustment
+
+    before :each do
+      subject.absolute_start = absolute_start
+      subject.extent = extent
+    end
+
+    its(:absolute_end) {should eq absolute_end}
+
+    it {should be_in_bounds absolute_start}
+    it {should be_in_bounds absolute_end}
+    it {should be_in_bounds absolute_start + ONE_PIXEL}
+    it {should be_in_bounds absolute_end - ONE_PIXEL}
+    it {should be_in_bounds 40}
+    it {should be_in_bounds 105}
+    it {should be_in_bounds 20.021}
+    it {should_not be_in_bounds absolute_end + ONE_PIXEL}
+    it {should_not be_in_bounds absolute_start - ONE_PIXEL
+    }
+    it {should_not be_in_bounds -5}
+    it {should_not be_in_bounds 0}
+    it {should_not be_in_bounds 150}
+    it {should_not be_in_bounds 123178}
+  end
+
+  it 'can displace the placement' do
+    subject.displace_start = 5
+    subject.absolute_start = 10
+    expect(subject.element_start).to eq 15
+  end
+
+  describe 'start/end/margin and other values parse simple string values' do
+    it 'parses a normal number' do
+      subject.start = '50'
+      expect(subject.start).to eq 50
+    end
+
+    it 'parses pixel values' do
+      subject.start = '77px'
+      expect(subject.start).to eq 77
+    end
+
+    it 'parses negative values' do
+      subject.start = '-13'
+      expect(subject.start).to eq -13
+    end
+
+    it 'even parses negative values with px' do
+      subject.start = '-22px'
+      expect(subject.start).to eq -22
+    end
+
+    it 'returns nil for unknown values' do
+      subject.start = []
+      expect(subject.start).to be_nil
+    end
+  end
+
+  describe Shoes::ParentDimension do
+    let(:parent) {Shoes::Dimension.new}
+    let(:parent_start) {7}
+    let(:parent_extent) {27}
+    let(:margin) {5}
+
+    subject {Shoes::ParentDimension.new parent}
+
+    before :each do
+      parent.start        = parent_start
+      parent.extent       = parent_extent
+      parent.margin_start = margin
+      parent.margin_end   = margin
+    end
+
+    describe 'it takes its parent values if no values are set' do
+      its(:start) {should eq parent_start}
+      its(:extent) {should eq parent_extent}
+      its(:margin_start) {should eq margin}
+      its(:margin_end) {should eq margin}
+
+      context 'with parent absolute_start set' do
+        before :each do
+          parent.absolute_start = 11
+        end
+
+        its(:absolute_start) {should eq 11}
+        its(:element_start) {should eq parent.element_start}
+        its(:element_end) {should eq parent.element_end}
+      end
+    end
+
+    describe 'otherwise it takes its own values' do
+      before :each do
+        subject.start = start
+        subject.extent = extent
+        subject.absolute_start = 17
+      end
+
+      its(:start) {should eq start}
+      its(:extent) {should eq extent}
+      its(:absolute_start) {should eq 17}
+
+      it 'can still handle special values like a negative extent' do
+        subject.extent = -10
+        expect(subject.extent).to eq (parent_extent - 2 * margin) - 10
+      end
+
+      it 'can also still handle special values like relative values' do
+        subject.extent = 0.8
+        expect(subject.extent).to be_within(ONE_PIXEL).of(0.8 * parent.element_extent)
+      end
+    end
+  end
+
+end
+