shoes-core 4.0.0.pre3

data/spec/shoes/arc_spec.rb

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

@@ -0,0 +1,47 @@
+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) }
+
+  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

@@ -0,0 +1,46 @@
+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}
+end

data/spec/shoes/builtin_methods_spec.rb

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

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

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

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