shoes 4.0.0.pre1 → 4.0.0.pre2

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

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

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

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

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