shoes-core 4.0.0.pre7 → 4.0.0.pre8

data/spec/shoes/shared_examples/dsl/line.rb

@@ -1,9 +0,0 @@
-shared_examples_for "line DSL method" do
-  it "creates a Shoes::Line" do
-    expect(dsl.line(10, 15, 20, 30)).to be_an_instance_of(Shoes::Line)
-  end
-
-  it "raises an ArgumentError" do
-    expect { dsl.line(30) }.to raise_error(ArgumentError)
-  end
-end

data/spec/shoes/shared_examples/dsl/nofill.rb

@@ -1,6 +0,0 @@
-shared_examples_for "nofill DSL method" do
-  it "sets nil" do
-    dsl.nofill
-    expect(dsl.style[:fill]).to eq(nil)
-  end
-end

data/spec/shoes/shared_examples/dsl/nostroke.rb

@@ -1,6 +0,0 @@
-shared_examples_for "nostroke DSL method" do
-  it "sets nil" do
-    dsl.nostroke
-    expect(dsl.style[:stroke]).to eq(nil)
-  end
-end

data/spec/shoes/shared_examples/dsl/oval.rb

@@ -1,88 +0,0 @@
-shared_examples_for "an oval/circle element" do
-  it "makes a Shoes::Oval" do
-    expect(oval).to be_instance_of(Shoes::Oval)
-  end
-
-  it "sets the proper dimensions" do
-    expect(oval.top).to eq(top)
-    expect(oval.left).to eq(left)
-    expect(oval.width).to eq(width)
-    expect(oval.height).to eq(height)
-  end
-
-  it "sets stroke" do
-    expect(oval.style[:stroke]).to eq(stroke)
-  end
-
-  it "sets fill" do
-    expect(oval.style[:fill]).to eq(fill)
-  end
-end
-
-shared_examples_for "oval DSL method" do
-  let(:left)   { 20 }
-  let(:top)    { 30 }
-  let(:width)  { 100 }
-  let(:height) { 200 }
-  let(:stroke) { Shoes::COLORS[:black] }
-  let(:fill) { Shoes::COLORS[:black] }
-
-  describe "creating an oval" do
-    describe "with explicit arguments" do
-      let(:oval) { dsl.oval(left, top, width, height) }
-      it_behaves_like "an oval/circle element"
-    end
-
-    describe "with stroke and fill styles" do
-      let(:stroke) { Shoes::COLORS.fetch :orchid }
-      let(:fill) { Shoes::COLORS.fetch :lemonchiffon }
-
-      describe "as colors" do
-        let(:oval) { dsl.oval(left, top, width, height, stroke: stroke, fill: fill) }
-        it_behaves_like "an oval/circle element"
-      end
-
-      describe "as hex strings" do
-        let(:oval) { dsl.oval(left, top, width, height, stroke: stroke.hex, fill: fill.hex) }
-        it_behaves_like "an oval/circle element"
-      end
-    end
-
-    describe "with too few arguments" do
-      it "raises an ArgumentError" do
-        expect { dsl.oval(10) }.to raise_error(ArgumentError)
-      end
-    end
-  end
-
-  describe "creating a circle" do
-    let(:width) { height }
-
-    describe "with explicit arguments" do
-      let(:oval) { dsl.oval(left, top, width, height) }
-      it_behaves_like "an oval/circle element"
-    end
-
-    describe "with top, left, diameter" do
-      let(:oval) { dsl.oval(left, top, width) }
-      it_behaves_like "an oval/circle element"
-    end
-
-    describe "with a style hash" do
-      describe "containing left, top, height, width" do
-        let(:oval) { dsl.oval(left: left, top: top, width: width, height: height) }
-        it_behaves_like "an oval/circle element"
-      end
-
-      describe "containing left, top, height, width, center: false" do
-        let(:oval) { dsl.oval(left: left, top: top, width: width, height: height, center: false) }
-        it_behaves_like "an oval/circle element"
-      end
-
-      describe "containing left, top, diameter" do
-        let(:oval) { dsl.oval(left: left, top: top, diameter: width) }
-        it_behaves_like "an oval/circle element"
-      end
-    end
-  end
-end

data/spec/shoes/shared_examples/dsl/pattern.rb

@@ -1,34 +0,0 @@
-shared_examples_for "pattern DSL method" do
-  let(:honeydew) { Shoes::COLORS[:honeydew] }
-  let(:salmon) { Shoes::COLORS[:salmon] }
-
-  context "with single color" do
-    let(:pattern) { dsl.pattern honeydew }
-    it "returns the color" do
-      expect(pattern).to eq(honeydew)
-    end
-  end
-
-  context "with color range" do
-    let(:pattern) { dsl.pattern honeydew..salmon }
-
-    it "returns a gradient" do
-      expect(pattern).to eq(dsl.gradient(honeydew..salmon))
-    end
-  end
-
-  context "with single string" do
-    let(:pattern) { dsl.pattern honeydew.hex }
-    it "returns the color" do
-      expect(pattern).to eq(honeydew)
-    end
-  end
-
-  context "with string range" do
-    let(:pattern) { dsl.pattern honeydew.hex..salmon.hex }
-
-    it "returns a gradient" do
-      expect(pattern).to eq(dsl.gradient(honeydew..salmon))
-    end
-  end
-end

data/spec/shoes/shared_examples/dsl/progress.rb

@@ -1,7 +0,0 @@
-shared_examples_for "progress DSL method" do
-  let(:progress) { dsl.progress }
-
-  it 'should be a progress bar' do
-    expect(progress).to be_instance_of Shoes::Progress
-  end
-end

data/spec/shoes/shared_examples/dsl/rect.rb

@@ -1,92 +0,0 @@
-shared_examples_for "rectangle dimensions" do
-  it "makes a Shoes::Rect" do
-    expect(rect).to be_an_instance_of(Shoes::Rect)
-  end
-
-  it "sets proper dimensions" do
-    expect(rect.left).to eq(left)
-    expect(rect.top).to eq(top)
-    expect(rect.width).to eq(width)
-    expect(rect.height).to eq(height)
-  end
-end
-
-shared_examples_for "rect DSL method" do
-  let(:left)   { 40 }
-  let(:top)    { 30 }
-  let(:curve)  { 12 }
-
-  it "raises an ArgumentError" do
-    expect { dsl.rect(30) }.to raise_exception(ArgumentError)
-  end
-
-  context 'unequal sides' do
-    let(:width)  { 200 }
-    let(:height) { 100 }
-
-    context "from explicit arguments" do
-      let(:rect) { dsl.rect left, top, width, height }
-
-      include_examples "rectangle dimensions"
-
-      it "defaults to corner radius of 0" do
-        expect(rect.curve).to eq(0)
-      end
-    end
-
-    context "round corners, from explicit arguments" do
-      let(:rect) { dsl.rect left, top, width, height, curve }
-
-      include_examples "rectangle dimensions"
-
-      it "sets corner radius" do
-        expect(rect.curve).to eq(curve)
-      end
-    end
-
-    context "from style hash" do
-      let(:rect) { dsl.rect left: left, top: top, width: width, height: height }
-
-      include_examples "rectangle dimensions"
-
-      it "defaults to corner radius of 0" do
-        expect(rect.curve).to eq(0)
-      end
-    end
-
-    context "rounded corners, from style hash" do
-      let(:rect) { dsl.rect left: left, top: top, width: width, height: height, curve: curve }
-
-      include_examples "rectangle dimensions"
-
-      it "sets corner radius" do
-        expect(rect.curve).to eq(curve)
-      end
-    end
-  end
-
-  context "square" do
-    let(:width)  { 200 }
-    let(:height) { 200 }
-
-    context "from explicit arguments" do
-      let(:rect) { dsl.rect left, top, width }
-
-      include_examples "rectangle dimensions"
-
-      it "defaults to corner radius of 0" do
-        expect(rect.curve).to eq(0)
-      end
-    end
-
-    context "square, from style hash" do
-      let(:rect) { dsl.rect left: left, top: top, width: width }
-
-      include_examples "rectangle dimensions"
-
-      it "defaults to corner radius of 0" do
-        expect(rect.curve).to eq(0)
-      end
-    end
-  end
-end

data/spec/shoes/shared_examples/dsl/rgb.rb

@@ -1,28 +0,0 @@
-shared_examples_for "rgb DSL method" do
-  let(:red) { 100 }
-  let(:green) { 149 }
-  let(:blue) { 237 }
-  let(:alpha) { 133 } # cornflowerblue
-
-  it "sends args to Shoes::Color" do
-    allow(Shoes::Color).to receive(:new)
-    dsl.rgb(red, green, blue, alpha)
-    expect(Shoes::Color).to have_received(:new).with(red, green, blue, alpha)
-  end
-
-  it "defaults to opaque" do
-    allow(Shoes::Color).to receive(:new)
-    dsl.rgb(red, green, blue)
-    expect(Shoes::Color).to have_received(:new).with(red, green, blue, Shoes::Color::OPAQUE)
-  end
-
-  describe "named color method" do
-    it "produces correct color" do
-      expect(dsl.cornflowerblue).to eq(Shoes::Color.new(red, green, blue))
-    end
-
-    it "accepts alpha arg" do
-      expect(dsl.cornflowerblue(alpha)).to eq(Shoes::Color.new(red, green, blue, alpha))
-    end
-  end
-end

data/spec/shoes/shared_examples/dsl/shape.rb

@@ -1,61 +0,0 @@
-shared_examples_for "shape DSL method" do
-  let(:shape) do
-    dsl.shape do
-      move_to 400, 300
-      line_to 400, 200
-      line_to 100, 100
-      line_to 400, 300
-      curve_to 100, 100, 20, 200, 120, 240
-    end
-  end
-
-  it "creates a Shoes::Shape" do
-    expect(shape).to be_an_instance_of(Shoes::Shape)
-  end
-
-  it "receives style from app" do
-    green = Shoes::COLORS.fetch :green
-    dsl.style[:stroke] = green
-    expect(shape.stroke).to eq(green)
-  end
-
-  describe "constructing" do
-    it "doesn't need any arguments" do
-      shape = dsl.shape
-      expect(shape.left).to eq(nil)
-      expect(shape.top).to eq(nil)
-    end
-
-    it "can accept some styles" do
-      white = Shoes::COLORS.fetch :white
-      shape = dsl.shape stroke: white
-      expect(shape.stroke).to eq(white)
-    end
-
-    it "can accept a left and top" do
-      left = 10
-      top = 20
-      shape = dsl.shape left, top
-      expect(shape.left).to eq(left)
-      expect(shape.top).to eq(top)
-    end
-
-    it "accepts left and top in styles" do
-      left = 10
-      top = 20
-      shape = dsl.shape left: left, top: top
-      expect(shape.left).to eq(left)
-      expect(shape.top).to eq(top)
-    end
-
-    it "can accept a left, top, and some styles" do
-      left = 10
-      top = 20
-      white = Shoes::COLORS.fetch(:white)
-      shape = dsl.shape left, top, stroke: white
-      expect(shape.left).to eq(left)
-      expect(shape.top).to eq(top)
-      expect(shape.stroke).to eq(white)
-    end
-  end
-end

data/spec/shoes/shared_examples/dsl/star.rb

@@ -1,110 +0,0 @@
-shared_examples_for "star DSL method" do
-  it "creates a Shoes::Star" do
-    expect(dsl.star(30, 20)).to be_an_instance_of(Shoes::Star)
-  end
-
-  it "raises an ArgumentError with just one argument" do
-    expect { dsl.star(30) }.to raise_error(ArgumentError)
-  end
-
-  describe 'instantiation' do
-    let(:left) { 10 }
-    let(:top) { 20 }
-    let(:points) { 15 }
-    let(:outer) { 27 }
-    let(:inner) { 33 }
-    let(:clickable) { proc {} }
-
-    DEFAULT_POINTS = 10
-    DEFAULT_OUTER = 100.0
-    DEFAULT_INNER = 50.0
-
-    describe '2 arguments' do
-      subject { dsl.star left, top }
-      its(:left) { should eq left }
-      its(:top) { should eq top }
-      its(:points) { should eq DEFAULT_POINTS }
-      its(:outer) { should eq DEFAULT_OUTER }
-      its(:inner) { should eq DEFAULT_INNER }
-    end
-
-    describe '2 arguments with hash' do
-      subject { dsl.star left, top, click: clickable }
-      its(:left)   { should eq left }
-      its(:top)    { should eq top }
-      its(:points) { should eq DEFAULT_POINTS }
-      its(:outer)  { should eq DEFAULT_OUTER }
-      its(:inner)  { should eq DEFAULT_INNER }
-
-      it "gets the click" do
-        expect(subject.style[:click]).to eq(clickable)
-      end
-    end
-
-    describe '3 arguments with hash' do
-      subject { dsl.star left, top, points, click: clickable }
-      its(:left)   { should eq left }
-      its(:top)    { should eq top }
-      its(:points) { should eq points }
-      its(:outer)  { should eq DEFAULT_OUTER }
-      its(:inner)  { should eq DEFAULT_INNER }
-
-      it "gets the click" do
-        expect(subject.style[:click]).to eq(clickable)
-      end
-    end
-
-    describe '4 arguments' do
-      subject { dsl.star left, top, points, outer }
-      its(:left) { should eq left }
-      its(:top) { should eq top }
-      its(:points) { should eq points }
-      its(:outer) { should eq outer }
-      its(:inner) { should eq DEFAULT_INNER }
-    end
-
-    describe '4 arguments with hash' do
-      subject { dsl.star left, top, points, outer, click: clickable }
-      its(:left)   { should eq left }
-      its(:top)    { should eq top }
-      its(:points) { should eq points }
-      its(:outer)  { should eq outer }
-      its(:inner)  { should eq DEFAULT_INNER }
-
-      it "gets the click" do
-        expect(subject.style[:click]).to eq(clickable)
-      end
-    end
-
-    describe '5 arguments' do
-      subject { dsl.star left, top, points, outer, inner }
-      its(:left) { should eq left }
-      its(:top) { should eq top }
-      its(:points) { should eq points }
-      its(:outer) { should eq outer }
-      its(:inner) { should eq inner }
-    end
-
-    describe '5 arguments with hash' do
-      subject { dsl.star left, top, points, outer, inner, click: clickable }
-      its(:left)   { should eq left }
-      its(:top)    { should eq top }
-      its(:points) { should eq points }
-      its(:outer)  { should eq outer }
-      its(:inner)  { should eq inner }
-
-      it "gets the click" do
-        expect(subject.style[:click]).to eq(clickable)
-      end
-    end
-
-    describe 'too many arguments' do
-      oops = 1000
-      subject { dsl.star left, top, points, outer, inner, oops }
-
-      it "raises on construction" do
-        expect { subject }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end