shoes-swt 4.0.0.pre2 → 4.0.0.pre3

data/spec/shoes/arc_spec.rb

@@ -1,51 +0,0 @@
-require 'shoes/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_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/background_spec.rb

@@ -1,53 +0,0 @@
-require 'shoes/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) }
-
-  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
-
-  describe '#needs_to_be_positioned?' do
-    context 'without absolute dimensions' do
-      let(:input_opts) {{}}
-      it {is_expected.not_to be_needs_to_be_positioned}
-    end
-
-    context 'with absolute dimensions' do
-      it {is_expected.to be_needs_to_be_positioned}
-    end
-  end
-
-  it {is_expected.not_to be_takes_up_space}
-end

data/spec/shoes/border_spec.rb

@@ -1,47 +0,0 @@
-require 'shoes/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}
-  it {is_expected.not_to be_needs_to_be_positioned}
-end

data/spec/shoes/builtin_methods_spec.rb

@@ -1,110 +0,0 @@
-require 'shoes/spec_helper'
-
-describe Shoes::BuiltinMethods do
-  let(:input_blk) { Proc.new {} }
-  let(:app) { Shoes::App.new({}, &input_blk) }
-  let(:logger) { double("logger") }
-
-  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
-
-  describe "info" do
-    before :each do
-      allow(logger).to receive(:info)
-      app.info("test")
-    end
-
-    it "sets Shoes::LOG" do
-      expect(Shoes::LOG).to eq([["info", "test"]])
-    end
-
-    it "sends message to logger" do
-      expect(logger).to have_received(:info)
-    end
-  end
-
-  describe "debug" do
-    before :each do
-      allow(logger).to receive(:debug)
-      app.debug("test")
-    end
-
-    it "sets Shoes::LOG" do
-      expect(Shoes::LOG).to eq([["debug", "test"]])
-    end
-
-    it "sends message to logger" do
-      expect(logger).to have_received(:debug)
-    end
-  end
-
-  describe "warn" do
-    before :each do
-      allow(logger).to receive(:warn)
-      app.warn("test")
-    end
-
-    it "sets Shoes::LOG" do
-      expect(Shoes::LOG).to eq([["warn", "test"]])
-    end
-
-    it "sends message to logger" do
-      expect(logger).to have_received(:warn)
-    end
-  end
-
-  describe "error" do
-    before :each do
-      allow(logger).to receive(:error)
-      app.error("test")
-    end
-
-    it "sets Shoes::LOG" do
-      expect(Shoes::LOG).to eq([["error", "test"]])
-    end
-
-    it "sends message to logger" do
-      expect(logger).to have_received(:error)
-    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
-end

data/spec/shoes/button_spec.rb

@@ -1,44 +0,0 @@
-require "shoes/spec_helper"
-
-describe Shoes::Button do
-  include_context "dsl app"
-  let(:input_opts) { {:left => left, :top => top, :width => width,
-                      :height => height, :margin => margin, :state => "disabled"} }
-
-  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 }
-
-  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 "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,35 +0,0 @@
-require 'shoes/spec_helper'
-
-describe Shoes::Check do
-  include_context "dsl app"
-
-  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,408 +0,0 @@
-require 'shoes/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 { lambda { Shoes::Color.new(10, 10) } }
-    it_behaves_like "color with bad arguments"
-  end
-
-  context "with too many hex chars" do
-    subject { lambda { Shoes::Color.new("a1b2c3d") } }
-    it_behaves_like "color with bad arguments"
-  end
-
-  context "with too few hex chars" do
-    subject { lambda { Shoes::Color.new("a1") } }
-    it_behaves_like "color with bad arguments"
-  end
-
-  context "with invalid hex chars" do
-    subject { lambda { 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(:color_1) { 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
-        color_2 = Shoes::Color.new(255, 69, 0)
-        expect(color_1).to eq(color_2)
-      end
-
-      it "is less than when darker" do
-        color_2 = Shoes::Color.new(255, 70, 0)
-        expect(color_1).to be < color_2
-      end
-
-      it "is greater than when lighter" do
-        color_2 = Shoes::Color.new(255, 68, 0)
-        expect(color_1).to be > color_2
-      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
-
-      context "same rgb values" do
-        let(:color_2) { Shoes::Color.new(255, 69, 0, 254) }
-        it "is less than when less opaque" do
-          expect(color_2).to be < color_1
-        end
-
-        it "is greater than when more opaque" do
-          expect(color_1).to be > color_2
-        end
-      end
-    end
-  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)) }
-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
-    result_93 = (0.93 * 255).to_i
-    expect(app.gray(0.93)).to eq(Shoes::Color.new(result_93, result_93, result_93))
-  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