shoes-core 4.0.0.pre7 → 4.0.0.pre8

data/spec/shoes/arc_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Arc do
-  include_context "dsl app"
-  let(:parent) { app }
-
-  let(:left)        { 13 }
-  let(:top)         { 44 }
-  let(:width)       { 200 }
-  let(:height)      { 300 }
-  let(:start_angle) { 0 }
-  let(:end_angle)   { Shoes::TWO_PI }
-
-  context "basic" do
-    subject(:arc) { Shoes::Arc.new(app, parent, left, top, width, height, start_angle, end_angle) }
-
-    it_behaves_like "object with style" do
-      let(:subject_without_style) { Shoes::Arc.new(app, parent, left, top, width, height, start_angle, end_angle) }
-      let(:subject_with_style) { Shoes::Arc.new(app, parent, left, top, width, height, start_angle, end_angle, arg_styles) }
-    end
-    it_behaves_like "object with dimensions"
-    it_behaves_like "left, top as center", :start_angle, :end_angle
-    it_behaves_like "object with parent"
-    it_behaves_like "object with hover"
-
-    # it_styles_with :art_styles, :center, :dimensions, :radius
-
-    it "is a Shoes::Arc" do
-      expect(arc.class).to be(Shoes::Arc)
-    end
-
-    its(:angle1) { should eq(0) }
-    its(:angle2) { should eq(Shoes::TWO_PI) }
-    its(:wedge)  { should eq(false) }
-  end
-
-  context "relative dimensions" do
-    subject(:arc) { Shoes::Arc.new(app, parent, left, top, relative_width, relative_height, start_angle, end_angle) }
-    it_behaves_like "object with relative dimensions"
-  end
-
-  context "negative dimensions" do
-    subject(:arc) { Shoes::Arc.new(app, parent, left, top, -width, -height, 0, Shoes::TWO_PI) }
-    it_behaves_like "object with negative dimensions"
-  end
-
-  context "with wedge: true" do
-    subject(:arc) { Shoes::Arc.new(app, parent, left, top, width, height, start_angle, end_angle, wedge: true) }
-
-    its(:wedge) { should eq(true) }
-  end
-end

data/spec/shoes/arrow_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Arrow do
-  include_context "dsl app"
-
-  let(:parent) { app }
-  let(:left) { 44 }
-  let(:top) { 66 }
-  let(:width) { 111 }
-  let(:height) { 111 }
-  subject(:arrow) { Shoes::Arrow.new(app, parent, left, top, width) }
-
-  describe '#style' do
-    it 'restyles handed in fill colors (even the weird ones)' do
-      subject.style fill: 'fff'
-      expect(subject.style[:fill]).to eq Shoes::Color.new 255, 255, 255
-    end
-  end
-
-  it_behaves_like "object with style" do
-    let(:subject_without_style) { Shoes::Arrow.new(app, parent, left, top, width) }
-    let(:subject_with_style) { Shoes::Arrow.new(app, parent, left, top, width, arg_styles) }
-  end
-  it_behaves_like "object with dimensions"
-  it_behaves_like "movable object"
-  it_behaves_like 'object with parent'
-  it_behaves_like "object with hover"
-end

data/spec/shoes/background_spec.rb

@@ -1,47 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Background do
-  include_context "dsl app"
-
-  let(:left) { 10 }
-  let(:top) { 20 }
-  let(:width) { 100 }
-  let(:height) { 200 }
-
-  let(:blue) { Shoes::COLORS[:blue] }
-  let(:input_opts) { {left: left, top: top, width: width, height: height, color: blue} }
-  subject(:background) { Shoes::Background.new(app, parent, blue, input_opts) }
-
-  before do
-    parent.height = height + 2
-    parent.width  = width + 2
-  end
-
-  it "retains app" do
-    expect(background.app).to eq(app)
-  end
-
-  it "creates gui object" do
-    expect(background.gui).not_to be_nil
-  end
-
-  it_behaves_like "object with style" do
-    subject(:background) { Shoes::Background.new(app, parent, Shoes::COLORS[:black]) }
-    let(:subject_without_style) { Shoes::Background.new(app, parent, blue) }
-    let(:subject_with_style) { Shoes::Background.new(app, parent, blue, arg_styles) }
-  end
-
-  it_behaves_like "object with dimensions"
-
-  describe "relative dimensions from parent" do
-    subject { Shoes::Background.new(app, parent, blue, relative_opts) }
-    it_behaves_like "object with relative dimensions"
-  end
-
-  context "negative dimensions" do
-    subject { Shoes::Background.new(app, parent, blue, negative_opts) }
-    it_behaves_like "object with negative dimensions"
-  end
-
-  it { is_expected.not_to be_takes_up_space }
-end

data/spec/shoes/border_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-shared_examples_for "basic border" do
-  it "retains app" do
-    expect(subject.app).to eq(app)
-  end
-
-  it "creates gui object" do
-    expect(subject.gui).not_to be_nil
-  end
-end
-
-describe Shoes::Border do
-  include_context "dsl app"
-  let(:parent) { Shoes::FakeElement.new nil, left, top, width, height }
-  let(:opts) { {left: left, top: top, width: width, height: height} }
-
-  let(:left) { 10 }
-  let(:top) { 20 }
-  let(:width) { 100 }
-  let(:height) { 200 }
-
-  let(:blue) { Shoes::COLORS[:blue] }
-
-  subject { Shoes::Border.new(app, parent, blue, opts) }
-
-  it_behaves_like "basic border"
-  it_behaves_like "object with style" do
-    subject { Shoes::Border.new(app, parent, Shoes::COLORS[:black]) }
-    let(:subject_without_style) { Shoes::Border.new(app, parent, blue) }
-    let(:subject_with_style) { Shoes::Border.new(app, parent, blue, arg_styles) }
-  end
-  it_behaves_like "object with dimensions"
-
-  describe "relative dimensions from parent" do
-    subject { Shoes::Border.new(app, parent, blue, relative_opts) }
-    it_behaves_like "object with relative dimensions"
-  end
-
-  describe "negative dimensions" do
-    subject { Shoes::Border.new(app, parent, blue, negative_opts) }
-    it_behaves_like "object with negative dimensions"
-  end
-
-  it { is_expected.not_to be_takes_up_space }
-end

data/spec/shoes/builtin_methods_spec.rb

@@ -1,122 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::BuiltinMethods do
-  let(:input_blk) { proc {} }
-  let(:app) { Shoes::App.new({}, &input_blk) }
-  let(:logger) { double("logger") }
-  let(:dialog) { double('dialog') }
-
-  before :each do
-    Shoes::LOG.clear
-    allow(Shoes).to receive(:logger) { logger }
-  end
-
-  describe 'Shoes.p' do
-    it 'adds a debug to the log with an inspected object' do
-      Shoes.p 'message'
-      expect(Shoes::LOG).to include ['debug', 'message'.inspect]
-    end
-
-    it 'also handles object the way they should be handled' do
-      Shoes.p []
-      expect(Shoes::LOG).to include ['debug', '[]']
-    end
-  end
-
-  %w(info debug warn error).each do |level|
-    describe "##{level}" do
-      before :each do
-        allow(logger).to receive(level)
-        app.public_send(level, "test")
-      end
-
-      it 'sets Shoes::LOG' do
-        expect(Shoes::LOG).to eq([[level, 'test']])
-      end
-
-      it 'sends message to logger' do
-        expect(logger).to have_received(level)
-      end
-    end
-  end
-
-  %w(open_file save_file open_folder save_folder).each do |chooser_action|
-    describe "#ask_#{chooser_action}" do
-      before do
-        allow(Shoes::Dialog).to receive(:new).and_return(dialog)
-        expect(dialog).to receive(:dialog_chooser).and_return(dialog)
-      end
-
-      it 'creates a new chooser dialog' do
-        expect(app.public_send("ask_#{chooser_action}")).to eq(dialog)
-      end
-    end
-  end
-
-  # just testing responds to things since the implementation is tested
-  # elsewhere
-  describe 'are builtin methods are also available from Shoes' do
-    builtin_methods = [:alert, :ask, :ask_color, :ask_open_file, :ask_save_file,
-                       :ask_open_folder, :ask_save_folder, :confirm, :color,
-                       :debug, :error, :font, :gradient, :gray, :rgb, :info,
-                       :pattern, :warn]
-
-    builtin_methods.each do |method|
-      it "responds to #{method}" do
-        expect(Shoes).to respond_to method
-      end
-    end
-
-    describe 'does not get to the nitty gritty helper_methods' do
-      helper_methods = [:image_file?, :image_pattern]
-
-      helper_methods.each do |method|
-        it "does not respond to #{method}" do
-          expect(Shoes).not_to respond_to method
-        end
-      end
-    end
-  end
-
-  %w(alert confirm).each do |type|
-    describe '##{alert}' do
-      let(:message) { double('message') }
-
-      before do
-        allow(Shoes::Dialog).to receive(:new).and_return(dialog)
-        expect(dialog).to receive(type).with(message).and_return(dialog)
-      end
-
-      it 'creates a new dialog' do
-        expect(app.public_send(type, message)).to eq(dialog)
-      end
-    end
-  end
-
-  describe '#ask' do
-    let(:message) { double('message') }
-    let(:args) { double('args') }
-
-    before do
-      allow(Shoes::Dialog).to receive(:new).and_return(dialog)
-      expect(dialog).to receive(:ask).with(message, args).and_return(dialog)
-    end
-
-    it 'creates a new dialog' do
-      expect(app.ask(message, args)).to eq(dialog)
-    end
-  end
-
-  describe '#ask_color' do
-    let(:title) { double('title') }
-
-    before do
-      allow(Shoes::Dialog).to receive(:new).and_return(dialog)
-      expect(dialog).to receive(:ask_color).with(title).and_return(dialog)
-    end
-
-    it 'creates a new dialog' do
-      expect(app.ask_color(title)).to eq(dialog)
-    end
-  end
-end

data/spec/shoes/button_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Button do
-  include_context "dsl app"
-
-  let(:input_opts) do
-    { left: left, top: top, width: width, height: height, margin: margin, state: "disabled" }
-  end
-
-  let(:left)   { 13 }
-  let(:top)    { 44 }
-  let(:width)  { 131 }
-  let(:height) { 137 }
-  let(:margin) { 14 }
-
-  subject(:button) { Shoes::Button.new(app, parent, "text", input_opts, input_block) }
-
-  it_behaves_like "movable object"
-  it_behaves_like "object with state"
-  it_behaves_like "object with style" do
-    let(:subject_without_style) { Shoes::Button.new(app, parent, "text") }
-    let(:subject_with_style) { Shoes::Button.new(app, parent, "text", arg_styles) }
-  end
-  it_behaves_like "object with dimensions"
-
-  it { is_expected.to respond_to :click }
-  it { is_expected.to respond_to :focus }
-  it { is_expected.to respond_to :text= }
-
-  describe "initialize" do
-    its(:parent) { should eq(parent) }
-    its(:text) { should eq("text") }
-    its(:width) { should eq(131) }
-    its(:height) { should eq(137) }
-    its(:state) { should eq("disabled") }
-  end
-
-  describe ".text=" do
-    it "changes the text" do
-      expect(subject.gui).to receive(:text=).with("something else")
-      subject.text = "something else"
-      expect(subject.text).to eq "something else"
-    end
-  end
-
-  describe "relative dimensions" do
-    subject { Shoes::Button.new(app, parent, "text", relative_opts, input_block) }
-    it_behaves_like "object with relative dimensions"
-  end
-
-  describe "negative dimensions" do
-    subject { Shoes::Button.new(app, parent, "text", negative_opts, input_block) }
-    it_behaves_like "object with negative dimensions"
-  end
-end

data/spec/shoes/check_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Check do
-  include_context "dsl app"
-
-  let(:input_opts) { { width: 22, height: 22 } }
-  subject { Shoes::Check.new(app, parent, input_opts, input_block) }
-
-  it_behaves_like "checkable"
-  it_behaves_like "object with state"
-  it_behaves_like "object with style" do
-    let(:subject_without_style) { Shoes::Check.new(app, parent) }
-    let(:subject_with_style) { Shoes::Check.new(app, parent, arg_styles) }
-  end
-
-  describe "dimensions" do
-    let(:left) { 10 }
-    let(:top) { 20 }
-    let(:width) { 100 }
-    let(:height) { 200 }
-    let(:input_opts) { {left: left, top: top, width: width, height: height} }
-    subject { Shoes::Check.new(app, parent, input_opts) }
-
-    it_behaves_like "object with dimensions"
-
-    describe "takes relative dimensions from parent" do
-      subject { Shoes::Check.new(app, parent, relative_opts) }
-      it_behaves_like "object with relative dimensions"
-    end
-
-    describe "negative dimensions" do
-      subject { Shoes::Check.new(app, parent, negative_opts) }
-      it_behaves_like "object with negative dimensions"
-    end
-  end
-end

data/spec/shoes/color_spec.rb

@@ -1,429 +0,0 @@
-require 'spec_helper'
-
-describe Shoes::Color do
-  describe ".create" do
-    let(:color) { Shoes::Color.new(40, 50, 60) }
-
-    it "accepts color" do
-      expect(Shoes::Color.create(color)).to eq(color)
-    end
-
-    it "accepts string" do
-      expect(Shoes::Color.create("28323c")).to eq(color)
-    end
-  end
-
-  shared_examples_for "black" do
-    its(:class) { should eq(Shoes::Color) }
-    its(:red) { should eq(0) }
-    its(:green) { should eq(0) }
-    its(:blue) { should eq(0) }
-    its(:hex) { should eq("#000000") }
-    it { is_expected.to be_black }
-    it { is_expected.not_to be_white }
-  end
-
-  shared_examples "color with bad arguments" do
-    it "raises ArgumentError" do
-      expect(subject).to raise_error(ArgumentError)
-    end
-  end
-
-  context "with wrong number of arguments" do
-    subject { -> { Shoes::Color.new(10, 10) } }
-    it_behaves_like "color with bad arguments"
-  end
-
-  context "with too many hex chars" do
-    subject { -> { Shoes::Color.new("a1b2c3d") } }
-    it_behaves_like "color with bad arguments"
-  end
-
-  context "with too few hex chars" do
-    subject { -> { Shoes::Color.new("a1") } }
-    it_behaves_like "color with bad arguments"
-  end
-
-  context "with invalid hex chars" do
-    subject { -> { Shoes::Color.new("#g01234") } }
-    it_behaves_like "color with bad arguments"
-  end
-
-  context "hex" do
-    let(:rgb) { Shoes::Color.new(0, 0, 0, 255) }
-
-    context "with '#000000'" do
-      subject { Shoes::Color.new("#000000") }
-      it { is_expected.to eq(rgb) }
-    end
-
-    context "with '000000'" do
-      subject { Shoes::Color.new("000000") }
-      it { is_expected.to eq(rgb) }
-    end
-
-    context "with '000'" do
-      subject { Shoes::Color.new("000") }
-      it { is_expected.to eq(rgb) }
-    end
-
-    context "with '#000'" do
-      subject { Shoes::Color.new("#000") }
-      it { is_expected.to eq(rgb) }
-    end
-
-    context "with '#FFF'" do
-      let(:rgb) { Shoes::Color.new(255, 255, 255) }
-      subject { Shoes::Color.new("#FFF") }
-      it { is_expected.to eq(rgb) }
-    end
-
-    context "with '#fff'" do
-      let(:rgb) { Shoes::Color.new(255, 255, 255) }
-      subject { Shoes::Color.new("#fff") }
-      it { is_expected.to eq(rgb) }
-    end
-  end
-
-  context "rgb" do
-    context "black" do
-      context "with optional alpha" do
-        subject { Shoes::Color.new(0, 0, 0, 0) }
-        it_behaves_like "black"
-        its(:alpha) { should eq(0) }
-      end
-
-      context "without optional alpha" do
-        subject { Shoes::Color.new(0, 0, 0) }
-        it_behaves_like "black"
-        its(:alpha) { should eq(255) }
-      end
-
-      context "using floats" do
-        context "with optional alpha" do
-          subject { Shoes::Color.new(0.0, 0.0, 0.0, 0.0) }
-          it_behaves_like "black"
-          its(:alpha) { should eq(0) }
-        end
-
-        context "without optional alpha" do
-          subject { Shoes::Color.new(0.0, 0.0, 0.0) }
-          it_behaves_like "black"
-          its(:alpha) { should eq(255) }
-        end
-      end
-    end
-
-    describe "inspect" do
-      include InspectHelpers
-
-      # Using patterns here so we can handle the variable hex string identifier
-      let(:rgb_pattern) { 'rgb[(]10, 20, 30[)]' }
-      let(:inspect_pattern) { "[(]Shoes::Color:#{shoes_object_id_pattern} #{rgb_pattern} alpha:40[)]$" }
-      subject(:color) { Shoes::Color.new(10, 20, 30, 40) }
-
-      its(:to_s) { should match(rgb_pattern) }
-      its(:inspect) { should match(inspect_pattern) }
-    end
-
-    context "white" do
-      subject { Shoes::Color.new(255, 255, 255) }
-      it { is_expected.to be_white }
-      it { is_expected.not_to be_black }
-    end
-
-    context "peru" do
-      shared_examples_for "peru" do
-        its(:class) { should eq(Shoes::Color) }
-        its(:red) { should eq(205) }
-        its(:green) { should eq(133) }
-        its(:blue) { should eq(63) }
-        it { is_expected.not_to be_black }
-        it { is_expected.not_to be_white }
-      end
-
-      context "with optional alpha" do
-        subject { Shoes::Color.new(205, 133, 63, 100) }
-        it_behaves_like("peru")
-        its(:alpha) { should eq(100) }
-      end
-
-      context "without optional alpha" do
-        subject { Shoes::Color.new(205, 133, 63) }
-        it_behaves_like("peru")
-        its(:alpha) { should eq(255) }
-      end
-
-      context "using floats" do
-        let(:red) { 0.805 }
-        let(:green) { 0.52 }
-        let(:blue) { 0.248 }
-        let(:alpha) { 0.392 }
-
-        context "with optional alpha" do
-          subject { Shoes::Color.new(red, green, blue, alpha) }
-          it_behaves_like "peru"
-          its(:alpha) { should eq(100) }
-        end
-
-        context "without optional alpha" do
-          subject { Shoes::Color.new(red, green, blue) }
-          it_behaves_like "peru"
-          its(:alpha) { should eq(255) }
-        end
-      end
-    end
-
-    describe "light and dark" do
-      let(:lightgreen) { Shoes::Color.new(144, 238, 144) }
-      let(:darkgreen) { Shoes::Color.new(0, 100, 0) }
-      let(:mediumseagreen) { Shoes::Color.new(60, 179, 113) }
-
-      specify "light color is light" do
-        expect(lightgreen).to be_light
-        expect(mediumseagreen).not_to be_light
-        expect(darkgreen).not_to be_light
-      end
-
-      specify "dark color is dark" do
-        expect(lightgreen).not_to be_dark
-        expect(mediumseagreen).not_to be_dark
-        expect(darkgreen).to be_dark
-      end
-    end
-
-    describe "transparency" do
-      let(:transparent) { Shoes::Color.new(25, 25, 112, 0) }
-      let(:semi) { Shoes::Color.new(25, 25, 112, 100) }
-      let(:opaque) { Shoes::Color.new(25, 25, 25) }
-
-      specify "only transparent colors are transparent" do
-        expect(transparent).to be_transparent
-        expect(semi).not_to be_transparent
-        expect(opaque).not_to be_transparent
-      end
-
-      specify "only opaque colors should be opaque" do
-        expect(transparent).not_to be_opaque
-        expect(semi).not_to be_opaque
-        expect(opaque).to be_opaque
-      end
-    end
-
-    describe "comparable" do
-      let(:color1) { Shoes::Color.new(255, 69, 0) }
-      let(:red) { Shoes::Color.new 255, 0, 0 }
-      let(:green) { Shoes::Color.new 0, 255, 0 }
-
-      it "is equal when values are equal" do
-        color2 = Shoes::Color.new(255, 69, 0)
-        expect(color1).to eq(color2)
-      end
-
-      it "is less than when darker" do
-        color2 = Shoes::Color.new(255, 70, 0)
-        expect(color1).to be < color2
-      end
-
-      it "is greater than when lighter" do
-        color2 = Shoes::Color.new(255, 68, 0)
-        expect(color1).to be > color2
-      end
-
-      it 'does not claim for full red and full green to be equal' do
-        expect(red).not_to eq green
-      end
-
-      it 'claims that a color is the same as itself' do
-        expect(green).to eq green
-      end
-
-      # shoes 3 compatibility behavior
-      describe 'different colors' do
-        it 'takes the total of rgb values to compare, less is less' do
-          expect(create_rgb(100, 200, 0)).to be < create_rgb(50, 100, 151)
-        end
-
-        it 'takes the total of rgb values to compare, more is more' do
-          expect(create_rgb(0, 200, 200)).to be > create_rgb(150, 150, 99)
-        end
-      end
-
-      context "same rgb values" do
-        let(:color2) { Shoes::Color.new(255, 69, 0, 254) }
-        it "is less than when less opaque" do
-          expect(color2).to be < color1
-        end
-
-        it "is greater than when more opaque" do
-          expect(color1).to be > color2
-        end
-      end
-    end
-  end
-
-  def create_rgb(r, g, b)
-    Shoes::Color.new r, g, b
-  end
-end
-
-describe "Shoes built-in colors" do
-  class MockApp
-    include Shoes::DSL
-  end
-
-  subject { MockApp.new }
-
-  its(:papayawhip) { should eq(Shoes::Color.new(255, 239, 213)) }
-  its(:aquamarine) { should eq(Shoes::Color.new(127, 255, 212)) }
-  its(:tomato) { should eq(Shoes::Color.new(255, 99, 71)) }
-
-  # define colors spec here since this has the other custom colors?
-  it 'can use define_shoes_color to create built-in colors' do
-    Shoes::DSL.define_shoes_color(:test_color, 0, 1, 2)
-    expect(subject.test_color).to eq Shoes::Color.new(0, 1, 2)
-  end
-end
-
-describe "Shoes built in gray" do
-  let(:app) { Shoes::App.new }
-
-  it "creates a dsl method for gray" do
-    expect(app).to respond_to(:gray)
-  end
-
-  specify "gray with no parameters is [128, 128, 128, OPAQUE]" do
-    expect(app.gray).to eq(Shoes::Color.new(128, 128, 128))
-  end
-
-  specify "single parameter specifies the gray level" do
-    expect(app.gray(64)).to eq(Shoes::Color.new(64, 64, 64))
-  end
-
-  specify "two parameters specifies the gray level and opacity" do
-    expect(app.gray(13, 57)).to eq(Shoes::Color.new(13, 13, 13, 57))
-  end
-
-  specify "float parameters should be normalised" do
-    expect(app.gray(1.0, 0.5)).to eq(Shoes::Color.new(255, 255, 255, 128))
-  end
-
-  it 'hangles 0.93 right as well' do
-    result93 = (0.93 * 255).to_i
-    expect(app.gray(0.93)).to eq(Shoes::Color.new(result93, result93, result93))
-  end
-
-  it 'also has a grey alias for our BE friends' do
-    expect(app).to respond_to :grey
-  end
-end
-
-# Differences between this implementation and Red Shoes
-describe "differences from Red Shoes" do
-  let(:white) { Shoes::Color.new(255, 255, 255) }
-  let(:transparent_black) { Shoes::Color.new(0, 0, 0, 0) }
-
-  context "integers" do
-    specify "too-large values become 255" do
-      expect(Shoes::Color.new(256, 256, 256, 256)).to eq(white)
-    end
-
-    specify "too-small values become 0" do
-      expect(Shoes::Color.new(-1, -1, -1, -1)).to eq(transparent_black)
-    end
-  end
-
-  context "floats" do
-    specify "too-large values become 255" do
-      expect(Shoes::Color.new(1.1, 1.1, 1.1, 1.1)).to eq(white)
-    end
-
-    specify "too-small values become 0" do
-      expect(Shoes::Color.new(-0.1, -0.1, -0.1, -0.1)).to eq(transparent_black)
-    end
-  end
-
-  # These specifications describe how this implementation differs from Red Shoes.
-  # These are examples of what Red Shoes _does_ do, and what this implementation
-  # _does not_ do.
-  describe "unusual input" do
-    let(:baseline) { Shoes::Color.new(50, 0, 200) }
-
-    describe "too-large values" do
-      specify "red does not get modulo-256'd into bounds" do
-        expect(Shoes::Color.new(306, 0, 200)).not_to eq(baseline)
-        expect(Shoes::Color.new(1.197, 0, 200)).not_to eq(baseline)
-      end
-
-      specify "green does not get modulo-256'd into bounds" do
-        expect(Shoes::Color.new(50, 256, 200)).not_to eq(baseline)
-        expect(Shoes::Color.new(50, 2.005, 200)).not_to eq(baseline)
-      end
-
-      specify "blue does not get modulo-256'd into bounds" do
-        expect(Shoes::Color.new(50, 0, 456)).not_to eq(baseline)
-        expect(Shoes::Color.new(50, 0, 2.7913137254902)).not_to eq(baseline)
-      end
-    end
-
-    describe "negative values" do
-      specify "-1 does not become 255" do
-        expect(Shoes::Color.new(-1, -1, -1, -1)).not_to eq(Shoes::Color.new(255, 255, 255))
-      end
-
-      specify "256 and neighbors" do
-        expect(Shoes::Color.new(-256, -255, -257)).not_to eq(Shoes::Color.new(0, 1, 255))
-      end
-
-      specify "float behaviour" do
-        expect(Shoes::Color.new(-1.0, -0.5, -0.0)).not_to eq(Shoes::Color.new(0, 128, 1))
-      end
-    end
-
-    describe "edge cases" do
-      specify "0.0 does not become 1" do
-        expect(Shoes::Color.new(0.0, 0.0, 0.0)).not_to eq(Shoes::Color.new(1, 1, 1))
-      end
-
-      specify "1.0 does not become 0" do
-        expect(Shoes::Color.new(1.0, 1.0, 1.0)).not_to eq(Shoes::Color.new(0, 0, 0))
-      end
-    end
-  end
-end
-
-describe Shoes::Color::DSLHelpers do
-  class ColorDSLHelperTest
-    include Shoes::Color::DSLHelpers
-  end
-
-  subject { ColorDSLHelperTest.new }
-
-  describe '#pattern' do
-    it 'creates an image pattern when fed a string for which a file exists' do
-      allow(File).to receive_messages(exist?: true)
-      my_path = '/some/path/to/image.png'
-      image_pattern = subject.pattern(my_path)
-      expect(image_pattern.path).to eq my_path
-    end
-
-    it 'raises an argument error for bad input like a single number' do
-      expect { subject.pattern(1) }.to raise_error(ArgumentError)
-    end
-
-    it 'creates a gradient given 2 arguments' do
-      expect(subject).to receive(:gradient)
-      subject.pattern([10, 10, 10], [30, 30, 30])
-    end
-  end
-
-  describe '#gradient' do
-    it 'raises an argument error for no arguments supplied' do
-      expect { subject.gradient }.to raise_error ArgumentError
-    end
-
-    it 'raises an argument error for too many (> 2) args supplied' do
-      expect { subject.gradient 1, 2, 3 }.to raise_error ArgumentError
-    end
-  end
-end