shoes-core 4.0.0.pre7 → 4.0.0.pre8

data/spec/shoes/common/attachable_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Common::Attachable do
-  include_context "dsl app"
-
-  subject do
-    Class.new do
-      include Shoes::Common::Attachable
-
-      attr_reader :style
-
-      def initialize(app, attached_to)
-        @app   = app
-        @style = { attach: attached_to }
-      end
-    end
-  end
-
-  let(:slot) { double('slot') }
-
-  it "isn't attached" do
-    expect(subject.new(app, nil).attached_to).to eq(nil)
-  end
-
-  it "attaches" do
-    expect(subject.new(app, slot).attached_to).to eq(slot)
-  end
-
-  it "attaches to Shoes::Window" do
-    expect(subject.new(app, Shoes::Window).attached_to).to eq(app.top_slot)
-  end
-end

data/spec/shoes/common/inspect_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-describe "Shoes::Common::Inspect" do
-  let(:test_class) do
-    Class.new do
-      include Shoes::Common::Inspect
-      def self.name
-        "Shoes::InspectableObject"
-      end
-    end
-  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,37 +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/rotate_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Common::Rotate do
-  let(:test_class) { Class.new { include Shoes::Common::Rotate } }
-
-  subject { test_class.new }
-
-  describe '#needs_rotate?' do
-    it 'defaults to falsey value' do
-      expect(subject.needs_rotate?).to be_falsey
-    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,197 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Common::Style do
-  include_context "dsl app"
-  let(:blue) { Shoes::COLORS[:blue] }
-
-  class StyleTester
-    include Shoes::Common::Visibility
-    include Shoes::DimensionsDelegations
-    include Shoes::Common::Style
-    include Shoes::Common::Hover
-
-    attr_reader :app, :dimensions
-    style_with :key, :left, :click, :strokewidth, :fill
-
-    STYLES = { fill: Shoes::COLORS[:blue] }.freeze
-
-    def initialize(app, styles = {})
-      @app = app # needed for style init
-      @dimensions = Shoes::Dimensions.new(@app, left: 15)
-
-      # Would normally be done by Common::Initialization
-      style_init(styles, key: 'value')
-      update_dimensions
-    end
-
-    def click(&arg)
-      @click = arg
-    end
-
-    def click_blk
-      @click
-    end
-
-    def update_visibility
-    end
-  end
-
-  subject { StyleTester.new(app) }
-
-  its(:style) { should eq(initial_style) }
-  let(:initial_style) do
-    {
-      key: 'value', left: 15, click: nil, strokewidth: 1, fill: blue, margin: [0, 0, 0, 0],
-      margin_left: 0, margin_top: 0, margin_right: 0, margin_bottom: 0
-    }
-  end
-
-  describe 'reading and writing through #style(hash)' do
-    let(:input_proc) { proc {} }
-    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 'reads visibility' do
-      subject.hide
-      expect(subject.style[:hidden]).to be true
-    end
-
-    it 'writes visibility' do
-      subject.style(hidden: true)
-      expect(subject.hidden?).to be true
-    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') }
-    let(:green) { Shoes::COLORS[:green] }
-
-    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
-
-    describe "with app level styles applied" do
-      let(:app) { Shoes::App.new }
-
-      it "should override class level defaults with app level styles provided those app styles are supported by the class" do
-        app.style(fill: green)
-        expect(app.line(0, 0, 10, 10).fill).to eq green
-      end
-
-      it "should not override class level defaults with app level styles for already instanciated objects" do
-        line_instance = app.line(0, 0, 10, 10)
-        app.style(fill: green)
-        expect(line_instance.fill).not_to eq green
-      end
-    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
-
-  describe 'sets hover and leave from styles' do
-    let(:hover_blk) { proc {} }
-    let(:leave_blk) { proc {} }
-
-    subject { StyleTester.new(app, hover: hover_blk, leave: leave_blk) }
-
-    its(:hover_blk) { should eq(hover_blk) }
-    its(:leave_blk) { should eq(leave_blk) }
-  end
-end

data/spec/shoes/common/translate_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Common::Translate do
-  let(:test_class) do
-    Class.new do
-      include Shoes::Common::Translate
-
-      attr_reader :translate
-
-      def initialize(translate)
-        @translate = translate
-      end
-    end
-  end
-
-  it 'allows nil' do
-    subject = test_class.new(nil)
-    expect(subject.translate_left).to eq(0)
-    expect(subject.translate_top).to eq(0)
-  end
-
-  it 'sets values' do
-    subject = test_class.new([10, 20])
-    expect(subject.translate_left).to eq(10)
-    expect(subject.translate_top).to eq(20)
-  end
-end

data/spec/shoes/configuration_spec.rb

@@ -1,51 +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_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.backend_for(dsl_object)).to be_instance_of(Shoes.configuration.backend::Shape)
-      end
-
-      it "raises ArgumentError for a non-Shoes object" do
-        expect { Shoes.backend_for(1..100) }.to raise_error(ArgumentError)
-      end
-    end
-
-    describe '#backend_class' do
-      it 'returns the backend class for a dsl object' do
-        expect(Shoes.configuration.backend_class(dsl_object)).to eq(Shoes.configuration.backend::Shape)
-      end
-
-      it 'returns the backend class if fed with a class' do
-        expect(Shoes.configuration.backend_class(Shoes::Shape)).to eq(Shoes.configuration
-                                                .backend::Shape)
-      end
-
-      it 'raises an error when fed with a non existant class' do
-        expect { Shoes.configuration.backend_class(Array) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/shoes/constants_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-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