squib 0.12.0 → 0.13.0

data/spec/args/draw_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-require 'squib/args/draw'
-
-describe Squib::Args::Draw do
-  let(:custom_colors) { { 'foo' => 'abc' } }
-  subject(:draw)      {Squib::Args::Draw.new(custom_colors)}
-
-  context 'unit conversion' do
-
-    it 'converts units on stroke width' do
-      args = { stroke_width: '2in' }
-      draw.load!(args, expand_by: 2)
-      expect(draw).to have_attributes(stroke_width: [600, 600])
-    end
-
-  end
-
-  context 'dsl overrides' do
-    subject(:draw) {Squib::Args::Draw.new(custom_colors, { stroke_width: 0.0 })}
-
-    it 'works when specified' do
-      draw.load!({}) # go right to defaults
-      expect(draw.stroke_width).to eq([0.0]) # ordinarily a non-zero according
-    end
-
-  end
-
-  context 'validation' do
-
-    it 'converts to Cairo options' do
-      args = { join: 'bevel', cap: 'round' }
-      draw.load!(args)
-      expect(draw).to have_attributes(
-        join: [Cairo::LINE_JOIN_BEVEL],
-        cap: [Cairo::LINE_JOIN_ROUND]
-        )
-    end
-
-    it 'parses dash options' do
-      args = { dash: '3 4 5' }
-      draw.load!(args)
-      expect(draw).to have_attributes(dash: [[3, 4, 5]])
-    end
-
-    it 'parses more complex dash options' do
-      args = { dash: '30.5,  90,  5' }
-      draw.load!(args)
-      expect(draw).to have_attributes(dash: [[30.5, 90, 5]])
-    end
-
-    it 'does unit conversion on dash options' do
-      args = { dash: '3in  4in 5in' }
-      draw.load!(args)
-      expect(draw).to have_attributes(dash: [[900, 1200, 1500]])
-    end
-
-    it 'converts line caps to Cairo constants' do
-      args = { cap: :SQUARE }
-      draw.load! args
-      expect(draw).to have_attributes(cap: [Cairo::LINE_CAP_SQUARE])
-    end
-
-    it 'converts line join' do
-      args = { join: 'round' }
-      draw.load! args
-      expect(draw).to have_attributes(join: [Cairo::LINE_JOIN_ROUND])
-    end
-
-    it 'allows fill_first stroke_strategy' do
-      args = { stroke_strategy: :FILL_first }
-      draw.load! args
-      expect(draw).to have_attributes(stroke_strategy: [:fill_first])
-    end
-
-    it 'allows stroke_first stroke_strategy' do
-      args = { stroke_strategy: '  stroke_FIRST ' }
-      draw.load! args
-      expect(draw).to have_attributes(stroke_strategy: [:stroke_first])
-    end
-
-    it 'disallows anything not stroke_first and fill_first' do
-      args = { stroke_strategy: 'foo' }
-      expect { draw.load! args }.to raise_error("Only 'stroke_first' or 'fill_first' allowed")
-    end
-
-    context 'custom colors' do
-
-      it 'looks up custom colors in the config' do
-        draw.load!({ color: 'foo' })
-        expect(draw.color).to eq ['abc']
-      end
-
-      it 'passes on through for non-custom color' do
-        draw = Squib::Args::Draw.new(custom_colors)
-        draw.load!({ color: 'bar' })
-        expect(draw.color).to eq ['bar']
-      end
-
-    end
-  end
-end

data/spec/args/embed_key_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-require 'squib/args/embed_key'
-
-describe Squib::Args::EmbedKey do
-
-  context '#validate_key' do
-
-    it 'converts to string' do
-      expect(subject.validate_key(2.5)).to eq ('2.5')
-    end
-
-  end
-end

data/spec/args/input_file_spec.rb

@@ -1,21 +0,0 @@
-require 'spec_helper'
-require 'squib/args/input_file'
-
-describe Squib::Args::InputFile do
-  subject(:ifile) {Squib::Args::InputFile.new}
-
-  context 'validate_file' do
-
-    it 'allows a file if it exists' do
-      args = { file: __FILE__ } # I code therefore I am.
-      ifile.load!(args, expand_by: 1)
-      expect(ifile).to have_attributes(file: [File.expand_path(__FILE__)])
-    end
-
-    it 'raises on non-existent file' do
-      args = { file: 'foo.rb' }
-      expect { ifile.load!(args, expand_by: 1) }.to raise_error("File #{File.expand_path('foo.rb')} does not exist!")
-    end
-
-  end
-end

data/spec/args/paint_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-require 'squib/args/paint'
-
-describe Squib::Args::Draw do
-  let(:custom_colors) { { 'foo' => 'abc' } }
-  subject(:paint) {Squib::Args::Paint.new(custom_colors)}
-
-  context 'alpha' do
-
-    it 'can be a float' do
-      args = { alpha: 0.6 }
-      paint.load!(args)
-      expect(paint.alpha).to eq [0.6]
-    end
-
-    it 'raises exception when not a float' do
-      args = { alpha: /6/ }
-      expect { paint.load!(args) }.to raise_error('alpha must respond to to_f')
-    end
-
-  end
-end

data/spec/args/paragraph_spec.rb

@@ -1,153 +0,0 @@
-require 'spec_helper'
-require 'squib/args/paragraph'
-require 'squib/constants'
-
-describe Squib::Args::Paragraph do
-  subject(:para) { Squib::Args::Paragraph.new('FooFont 32') }
-
-  context 'str validator' do
-    it 'converts everything to string' do
-      para.load!({ str: 5 })
-      expect(para.str).to eq ['5']
-    end
-  end
-
-  context 'font validator' do
-    it 'uses deck font by default' do
-      para.load!({})
-      expect(para.font).to eq ['FooFont 32']
-    end
-
-    it 'uses system default font when deck font is :default' do
-      para = Squib::Args::Paragraph.new(:default)
-      para.load!({})
-      expect(para.font).to eq [Squib::DEFAULT_FONT]
-    end
-
-    it 'uses specified font when given' do
-      para.load!({ font: 'MyFont 8' })
-      expect(para.font).to eq ['MyFont 8']
-    end
-  end
-
-  context 'align validator' do
-    it 'converts to pango left' do
-      para.load!({ align: :left })
-      expect(para.align).to eq [Pango::ALIGN_LEFT]
-    end
-
-    it 'converts to pango right' do
-      para.load!({ align: :RIGHT })
-      expect(para.align).to eq [Pango::ALIGN_RIGHT]
-    end
-
-    it 'converts to pango center' do
-      para.load!({ align: 'center' })
-      expect(para.align).to eq [Pango::ALIGN_CENTER]
-    end
-
-    it 'raises an exception on anything else' do
-      expect { para.load!({ align: 'foo' }) }.to raise_error(ArgumentError, 'align must be one of: center, left, right')
-    end
-  end
-
-  context 'wrap validator' do
-    it 'converts to pango wrap word' do
-      para.load!({ wrap: 'word' })
-      expect(para.wrap).to eq [Pango::WRAP_WORD]
-    end
-
-    it 'converts to pango wrap char' do
-      para.load!({ wrap: 'WORD_ChAr' })
-      expect(para.wrap).to eq [Pango::WRAP_WORD_CHAR]
-    end
-
-    it 'converts to pango wrap char on true' do
-      para.load!({ wrap: true })
-      expect(para.wrap).to eq [Pango::WRAP_WORD_CHAR]
-    end
-
-    it 'converts to pango wrap char with false' do
-      para.load!({ wrap: false })
-      expect(para.wrap).to eq [Pango::WRAP_CHAR]
-    end
-
-    it 'raises an exception on anything else' do
-      expect { para.load!({ wrap: 'foo' }) }.to raise_error(ArgumentError, 'wrap must be one of: word, char, word_char, true, or false')
-    end
-  end
-
-  context 'ellipsize validator' do
-    it 'converts to pango on none and false' do
-      para.load!({ ellipsize: 'none' })
-      expect(para.ellipsize).to eq [Pango::Layout::ELLIPSIZE_NONE]
-    end
-
-    it 'converts to pango with start' do
-      para.load!({ ellipsize: :StArt })
-      expect(para.ellipsize).to eq [Pango::Layout::ELLIPSIZE_START]
-    end
-
-    it 'converts to pango middle' do
-      para.load!({ ellipsize: 'middle' })
-      expect(para.ellipsize).to eq [Pango::Layout::ELLIPSIZE_MIDDLE]
-    end
-
-    it 'converts to pango end' do
-      para.load!({ ellipsize: 'END' })
-      expect(para.ellipsize).to eq [Pango::Layout::ELLIPSIZE_END]
-    end
-
-    it 'raises an exception on anything else' do
-      expect { para.load!({ ellipsize: 'foo' }) }.to raise_error(ArgumentError, 'ellipsize must be one of: none, start, middle, end, true, or false')
-    end
-  end
-
-  context 'justify validator' do
-    it 'allows nil' do
-      para.load!({ justify: nil })
-      expect(para.justify).to eq [nil]
-    end
-
-    it 'can be true' do
-      para.load!({ justify: true })
-      expect(para.justify).to eq [true]
-    end
-
-    it 'can be false' do
-      para.load!({ justify: false })
-      expect(para.justify).to eq [false]
-    end
-
-    it 'raises an exception on anything else' do
-      expect { para.load!({ justify: 'false' }) }.to raise_error(ArgumentError, 'justify must be one of: nil, true, or false')
-    end
-  end
-
-  context 'spacing validator' do
-    it 'allows nil' do
-      para.load!({ spacing: nil })
-      expect(para.spacing).to eq [nil]
-    end
-    it 'is converted to Pango space' do
-      para.load!({ spacing: 519 })
-      expect(para.spacing).to eq [Pango::SCALE * 519.0]
-    end
-
-    it 'raises an exception if not a float' do
-      expect { para.load!({ spacing: /foo/ }) }.to raise_error(ArgumentError, 'spacing must be a number or nil')
-    end
-  end
-
-  context 'valign validator' do
-    it 'converts top' do
-      para.load!({ valign: :top })
-      expect(para.valign).to eq ['top']
-    end
-
-    it 'raises an exception if not one of the three' do
-      expect { para.load!({ valign: 'foo' }) }.to raise_error(ArgumentError, 'valign must be one of: top, middle, bottom')
-    end
-  end
-
-end

data/spec/args/range_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-require 'squib/args/card_range'
-
-describe Squib::Args::CardRange do
-
-  it 'must be within the card size range' do
-    expect {Squib::Args::CardRange.new(2..3, deck_size: 2)}
-      .to raise_error(ArgumentError, '2..3 is outside of deck range of 0..1')
-  end
-
-  it 'defaults to range of all cards if :all' do
-    range = Squib::Args::CardRange.new(:all, deck_size: 5)
-    expect(range.to_a).to eq([0, 1, 2, 3, 4])
-  end
-
-  it 'creates a range of cards for singleton' do
-    range = Squib::Args::CardRange.new(3, deck_size: 5)
-    expect(range.to_a).to eq([3])
-  end
-
-  it 'lets arrays pass through unchanged' do
-    range = Squib::Args::CardRange.new([0, 2], deck_size: 5)
-    expect(range.to_a).to eq([0, 2])
-  end
-
-  it 'raises an error on everything else' do
-    expect { Squib::Args::CardRange.new(:foo, deck_size: 5) }
-      .to raise_error(ArgumentError, 'foo must be Enumerable (i.e. respond_to :each).')
-  end
-
-  it 'allows anything with :to_i' do
-    range = Squib::Args::CardRange.new(0.9, deck_size: 5)
-    expect(range.to_a).to eq([0])
-  end
-
-  it 'allows [] as an empty range' do
-    range = Squib::Args::CardRange.new([], deck_size: 5)
-    expect(range.to_a).to eq([])
-  end
-
-end

data/spec/args/save_batch_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'squib/args/save_batch'
-
-describe Squib::Args::SaveBatch do
-  subject(:save_batch) {Squib::Args::SaveBatch.new}
-
-  context 'dir' do
-    it 'is created if not exists (and warns)' do
-      opts = { dir: 'tocreate' }
-      Dir.chdir(output_dir) do
-        FileUtils.rm_rf('tocreate', secure: true)
-        expect(Squib.logger).to receive(:warn).with("Dir 'tocreate' does not exist, creating it.").once
-        save_batch.load! opts
-        expect(save_batch).to have_attributes({ dir: ['tocreate'] })
-        expect(Dir.exists? 'tocreate').to be true
-      end
-    end
-  end
-
-  context 'rotate' do
-    it 'does nothing by default' do
-      opts = {}
-      save_batch.load! opts
-      expect(save_batch[0]).to have_attributes({ rotate: false, angle: 0 })
-    end
-
-    it 'rotates by pi/2 with true' do
-      opts = { rotate: true }
-      save_batch.load! opts
-      expect(save_batch[0]).to have_attributes({ rotate: true, angle: Math::PI / 2 })
-    end
-
-    it 'rotates by pi/2' do
-      opts = { rotate: :clockwise }
-      save_batch.load! opts
-      expect(save_batch[0]).to have_attributes({ rotate: true, angle: Math::PI / 2 })
-    end
-
-    it 'rotates by pi/2 with counterclockwise' do
-      opts = { rotate: :counterclockwise }
-      save_batch.load! opts
-      expect(save_batch[0]).to have_attributes({ rotate: true, angle: 3 * Math::PI / 2 })
-    end
-
-    it 'raises error on a number' do
-      opts = { rotate: 5.0 }
-      expect { save_batch.load!(opts) }.to raise_error('invalid option to rotate: only [true, false, :clockwise, :counterclockwise]')
-    end
-  end
-
-end

data/spec/args/scale_box_spec.rb

@@ -1,71 +0,0 @@
-require 'spec_helper'
-require 'squib/args/scale_box'
-
-describe Squib::Args::ScaleBox do
-  subject(:box) { Squib::Args::ScaleBox.new({}) }
-
-  context 'unit conversion' do
-    it 'converts units on all args' do
-      args = { x: ['1in', '2in'], y: 300, width: '1in', height: '1in' }
-      box.load!(args, expand_by: 2)
-      expect(box).to have_attributes(
-        x: [300, 600],
-        y: [300, 300],
-        width: [300, 300],
-        height: [300, 300],
-      )
-    end
-  end
-
-  context 'validation' do
-    it 'replaces with deck width and height' do
-      args = { width: :deck, height: :deck }
-      deck = OpenStruct.new(width: 123, height: 456)
-      box = Squib::Args::Box.new(deck)
-      box.load!(args, expand_by: 1)
-      expect(box).to have_attributes(width: [123], height: [456])
-    end
-
-    it 'allows :native' do
-      args = { width: :native, height: :native }
-      box.load!(args, expand_by: 1)
-      expect(box).to have_attributes(width: [:native], height: [:native])
-    end
-
-    it 'allows native to be a string' do
-      args = { width: 'native' }
-      box.load!(args, expand_by: 1)
-      expect(box).to have_attributes(width: [:native], height: [:native])
-    end
-
-    it 'allows :scale on width if height has to_f' do
-      args = { width: :scale, height: 75 }
-      box.load!(args, expand_by: 1)
-      expect(box).to have_attributes(width: [:scale], height: [75])
-    end
-
-    it 'allows :scale on width if height has to_f' do
-      args = { width: 75, height: :scale }
-      box.load!(args, expand_by: 1)
-      expect(box).to have_attributes(width: [75], height: [:scale])
-    end
-
-    it 'disallows both :scale' do
-      args = { width: :scale, height: :scale }
-      expect { box.load!(args, expand_by: 1) }.to raise_error('if width is :scale, height must be a number')
-    end
-
-    it 'disallows non-to_f on width' do
-      args = { width: :foo }
-      expect { box.load!(args, expand_by: 1) }.to raise_error('width must be a number, :scale, :native, or :deck')
-    end
-
-    it 'disallows non-to_f on height' do
-      args = { height: :foo }
-      expect { box.load!(args, expand_by: 1) }.to raise_error('height must be a number, :scale, :native, or :deck')
-    end
-
-  end
-
-
-end