squib 0.9.0 → 0.10.0

data/spec/args/paragraph_spec.rb

@@ -7,147 +7,147 @@ describe Squib::Args::Paragraph do
 
   context 'str validator' do
     it 'converts everything to string' do
-      para.load!( {str: 5} )
+      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!( {} )
+      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!( {} )
+      para.load!({})
       expect(para.font).to eq [Squib::DEFAULT_FONT]
     end
 
     it 'uses specified font when given' do
-      para.load!( {font: 'MyFont 8'})
+      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 } )
+      para.load!({ align: :left })
       expect(para.align).to eq [Pango::ALIGN_LEFT]
     end
 
     it 'converts to pango right' do
-      para.load!( { align: :RIGHT } )
+      para.load!({ align: :RIGHT })
       expect(para.align).to eq [Pango::ALIGN_RIGHT]
     end
 
     it 'converts to pango center' do
-      para.load!( { align: 'center' } )
+      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')
+      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'} )
+      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'} )
+      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} )
+      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} )
+      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')
+      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'} )
+      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} )
+      para.load!({ ellipsize: :StArt })
       expect(para.ellipsize).to eq [Pango::Layout::ELLIPSIZE_START]
     end
 
     it 'converts to pango middle' do
-      para.load!( { ellipsize: 'middle'} )
+      para.load!({ ellipsize: 'middle' })
       expect(para.ellipsize).to eq [Pango::Layout::ELLIPSIZE_MIDDLE]
     end
 
     it 'converts to pango end' do
-      para.load!( { ellipsize: 'END'} )
+      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')
+      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} )
+      para.load!({ justify: nil })
       expect(para.justify).to eq [nil]
     end
 
     it 'can be true' do
-      para.load!( { justify: true} )
+      para.load!({ justify: true })
       expect(para.justify).to eq [true]
     end
 
     it 'can be false' do
-      para.load!( { justify: false} )
+      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')
+      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} )
+      para.load!({ spacing: nil })
       expect(para.spacing).to eq [nil]
     end
     it 'is converted to Pango space' do
-      para.load!( { spacing: 519} )
+      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')
+      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} )
+      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')
+      expect { para.load!({ valign: 'foo' }) }.to raise_error(ArgumentError, 'valign must be one of: top, middle, bottom')
     end
   end
 
-end
+end

data/spec/args/range_spec.rb

@@ -38,4 +38,4 @@ describe Squib::Args::CardRange do
     expect(range.to_a).to eq([])
   end
 
-end
+end

data/spec/args/save_batch_spec.rb

@@ -6,12 +6,12 @@ describe Squib::Args::SaveBatch do
 
   context 'dir' do
     it 'is created if not exists (and warns)' do
-      opts = {dir: 'tocreate'}
+      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(save_batch).to have_attributes({ dir: ['tocreate'] })
         expect(Dir.exists? 'tocreate').to be true
       end
     end
@@ -21,29 +21,29 @@ describe Squib::Args::SaveBatch do
     it 'does nothing by default' do
       opts = {}
       save_batch.load! opts
-      expect(save_batch[0]).to have_attributes({rotate: false, angle: 0})
+      expect(save_batch[0]).to have_attributes({ rotate: false, angle: 0 })
     end
 
     it 'rotates by pi/2 with true' do
-      opts = {rotate: true}
+      opts = { rotate: true }
       save_batch.load! opts
-      expect(save_batch[0]).to have_attributes({rotate: true, angle: Math::PI / 2})
+      expect(save_batch[0]).to have_attributes({ rotate: true, angle: Math::PI / 2 })
     end
 
     it 'rotates by pi/2' do
-      opts = {rotate: :clockwise}
+      opts = { rotate: :clockwise }
       save_batch.load! opts
-      expect(save_batch[0]).to have_attributes({rotate: true, angle: Math::PI / 2})
+      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}
+      opts = { rotate: :counterclockwise }
       save_batch.load! opts
-      expect(save_batch[0]).to have_attributes({rotate: true, angle: 3 * Math::PI / 2})
+      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}
+      opts = { rotate: 5.0 }
       expect { save_batch.load!(opts) }.to raise_error('invalid option to rotate: only [true, false, :clockwise, :counterclockwise]')
     end
   end

data/spec/args/scale_box_spec.rb

@@ -6,7 +6,7 @@ describe Squib::Args::ScaleBox do
 
   context 'unit conversion' do
     it 'converts units on all args' do
-      args = {x: ['1in', '2in'], y: 300, width: '1in', height: '1in'}
+      args = { x: ['1in', '2in'], y: 300, width: '1in', height: '1in' }
       box.load!(args, expand_by: 2)
       expect(box).to have_attributes(
         x: [300, 600],
@@ -19,7 +19,7 @@ describe Squib::Args::ScaleBox do
 
   context 'validation' do
     it 'replaces with deck width and height' do
-      args = {width: :deck, height: :deck}
+      args = { width: :deck, height: :deck }
       deck = OpenStruct.new(width: 123, height: 456)
       box = Squib::Args::Box.new(deck)
       box.load!(args, expand_by: 1)
@@ -27,41 +27,41 @@ describe Squib::Args::ScaleBox do
     end
 
     it 'allows :native' do
-      args = {width: :native, height: :native}
+      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'}
+      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}
+      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}
+      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}
+      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}
+      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}
+      args = { height: :foo }
       expect { box.load!(args, expand_by: 1) }.to raise_error('height must be a number, :scale, :native, or :deck')
     end
 

data/spec/args/sheet_spec.rb

@@ -4,11 +4,11 @@ require 'squib/args/sheet'
 describe Squib::Args::Sheet do
 
   context 'dsl overrides' do
-    subject(:sheet) { Squib::Args::Sheet.new({}, {file: 'foo'}) }
+    subject(:sheet) { Squib::Args::Sheet.new({}, { file: 'foo' }) }
 
     it 'works when specified' do
       sheet.load!({}) # go right to defaults
-      expect(sheet.file).to eq( 'foo' ) # dsl method default override
+      expect(sheet.file).to eq('foo') # dsl method default override
     end
 
   end
@@ -29,25 +29,25 @@ describe Squib::Args::Sheet do
     end
 
     it 'computes properly on non-integer' do
-      opts = {columns: 1, rows: :infinite}
+      opts = { columns: 1, rows: :infinite }
       sheet.load! opts
-      expect(sheet).to have_attributes( columns: 1, rows: 4 )
+      expect(sheet).to have_attributes(columns: 1, rows: 4)
     end
 
     it 'computes properly on unspecified rows' do
-      opts = {columns: 1}
+      opts = { columns: 1 }
       sheet.load! opts
-      expect(sheet).to have_attributes( columns: 1, rows: 4 )
+      expect(sheet).to have_attributes(columns: 1, rows: 4)
     end
 
     it 'computes properly on unspecified, too-big column' do
       opts = {}
       sheet.load! opts
-      expect(sheet).to have_attributes( columns: 5, rows: 1 )
+      expect(sheet).to have_attributes(columns: 5, rows: 1)
     end
 
     it 'fails on a non-integer column' do
-      opts = {columns: :infinite}
+      opts = { columns: :infinite }
       expect { sheet.load!(opts) }.to raise_error('columns must be an integer')
     end
 

data/spec/args/showcase_special_spec.rb

@@ -1,15 +1,15 @@
-require 'spec_helper'
-require 'squib/args/showcase_special'
-
-describe Squib::Args::ShowcaseSpecial do
-  subject(:showcase_special) { Squib::Args::ShowcaseSpecial.new }
-
-  context '#face_right?' do
-    it 'compares face to right' do
-      opts = { face: 'LEFT ' }
-      showcase_special.load! opts
-      expect(showcase_special.face_right?).to be false
-    end
-  end
-
-end
+require 'spec_helper'
+require 'squib/args/showcase_special'
+
+describe Squib::Args::ShowcaseSpecial do
+  subject(:showcase_special) { Squib::Args::ShowcaseSpecial.new }
+
+  context '#face_right?' do
+    it 'compares face to right' do
+      opts = { face: 'LEFT ' }
+      showcase_special.load! opts
+      expect(showcase_special.face_right?).to be false
+    end
+  end
+
+end

data/spec/args/transform_spec.rb

@@ -3,11 +3,11 @@ require 'squib/args/transform'
 
 describe Squib::Args::Box do
   subject(:trans) { Squib::Args::Transform.new }
-  let(:expected_defaults) { {x: [0], y: [0], crop_width: [:native], crop_height: [:native] } }
+  let(:expected_defaults) { { x: [0], y: [0], crop_width: [:native], crop_height: [:native] } }
 
   context 'validation' do
     it 'replaces with deck width and height' do
-      args  = {crop_width: :deck, crop_height: :deck}
+      args  = { crop_width: :deck, crop_height: :deck }
       deck  = OpenStruct.new(width: 123, height: 456)
       trans = Squib::Args::Transform.new(deck)
       trans.load!(args, expand_by: 1)
@@ -15,11 +15,11 @@ describe Squib::Args::Box do
     end
 
     it 'has radius override x_radius and y_radius' do
-      args = {crop_corner_x_radius: 1, crop_corner_y_radius: 2, crop_corner_radius: 3}
+      args = { crop_corner_x_radius: 1, crop_corner_y_radius: 2, crop_corner_radius: 3 }
       trans.load!(args, expand_by: 2)
       expect(trans).to have_attributes(crop_corner_x_radius: [3, 3], crop_corner_y_radius: [3, 3])
     end
 
   end
 
-end
+end

data/spec/args/typographer_spec.rb

@@ -24,48 +24,48 @@ describe Squib::Args::Typographer do
     expect(t.process(%{"foo"})).to eq(%{\u201Cfoo\u201D})
   end
 
-  it "quotes in the middle of the string" do
+  it 'quotes in the middle of the string' do
     expect(t.process(%{hello "foo" world})).to eq(%{hello \u201Cfoo\u201D world})
   end
 
-  it "single left quotes at the beginning" do
+  it 'single left quotes at the beginning' do
     expect(t.process(%{'foo})).to eq(%{\u2018foo})
   end
 
-  it "single right quotes at the end" do
+  it 'single right quotes at the end' do
     expect(t.process(%{foo'})).to eq(%{foo\u2019})
   end
 
-  it "single quotes in the middle" do
+  it 'single quotes in the middle' do
     expect(t.process(%{a 'foo' bar})).to eq(%{a \u2018foo\u2019 bar})
   end
 
-  it "handles apostraphes" do
+  it 'handles apostraphes' do
     expect(t.process(%{can't})).to eq(%{can\u2019t})
   end
 
-it "single quotes inside double quotes" do
+it 'single quotes inside double quotes' do
     expect(t.process(%{"'I can't do that', he said"})).to eq(%{\u201C\u2018I can\u2019t do that\u2019, he said\u201D})
   end
 
-  it "replaces the straightforward ones" do
+  it 'replaces the straightforward ones' do
     expect(t.process(%{``hi...'' -- ---})).to eq(%{\u201Chi\u2026\u201D \u2013 \u2014})
   end
 
-  it "does nothing on lone quotes" do
+  it 'does nothing on lone quotes' do
     expect(t.process(%{"})).to eq(%{"})
     expect(t.process(%{'})).to eq(%{'})
   end
 
-  it "ignores stuff in <tags>" do
+  it 'ignores stuff in <tags>' do
     expect(t.process(%{<span weight="bold">"can't"</span>})).to eq(%{<span weight="bold">\u201Ccan\u2019t\u201D</span>})
   end
 
 
   context 'configured' do
-    #TODO
+    # TODO
   end
 
 
 
-end
+end