squib 0.6.0 → 0.7.0

data/spec/api/api_image_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-require 'squib'
-
-describe Squib::Deck, 'images' do
-
-  context '#png' do
-     it 'calls Card#png, Dir, and progress bar' do
-      card = instance_double(Squib::Card)
-      progress = double(Squib::Progress)
-      expect(card).to receive(:png).with('foo', 0, 1, :native, :native, 0.5, :overlay, 0.75, nil).once
-      expect(Dir).to receive(:chdir).with('.').and_yield.once
-      expect(progress).to receive(:start).and_yield(progress).once
-      expect(progress).to receive(:increment).once
-      Squib::Deck.new do
-        @progress_bar = progress
-        @cards = [card]
-        png file: 'foo', x: 0, y: 1, alpha: 0.5, blend: :overlay, angle: 0.75
-      end
-    end
-  end
-
-  context '#svg' do
-     it 'calls Card#svg, Dir, and progress bar' do
-      card = instance_double(Squib::Card)
-      progress = double(Squib::Progress)
-      expect(card).to receive(:svg).with('foo', nil, '#bar', 0, 1, 20, 30, 0.5, :overlay, 0.75, nil).once
-      expect(Dir).to receive(:chdir).with('.').and_yield.once
-      expect(progress).to receive(:start).and_yield(progress).once
-      expect(progress).to receive(:increment).once
-      Squib::Deck.new do
-        @progress_bar = progress
-        @cards = [card]
-        svg file: 'foo', id: 'bar', x: 0, y: 1, width: 20, height: 30, alpha: 0.5, blend: :overlay, angle: 0.75
-      end
-    end
-  end
-
-end

data/spec/api/api_text_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-require 'squib'
-
-describe Squib::Deck, '#text' do
-
-  context 'fonts' do
-     it "should use the default font when #text and #set_font don't specify" do
-      card = instance_double(Squib::Card)
-      expect(card).to receive(:text).with(anything, 'a', 'Arial 36', *([anything] * 17)).once
-      Squib::Deck.new do
-        @cards = [card]
-        text str: 'a'
-      end
-    end
-
-    it "should use the #set_font when #text doesn't specify" do
-      card = instance_double(Squib::Card)
-      expect(card).to receive(:text).with(anything, 'a', 'Times New Roman 16', *([anything] * 17)).once
-      Squib::Deck.new do
-        @cards = [card]
-        set font: 'Times New Roman 16'
-        text str: 'a'
-      end
-    end
-
-    it 'should use the specified font no matter what' do
-      card = instance_double(Squib::Card)
-      expect(card).to receive(:text).with(anything, 'a', 'Arial 18', *([anything] * 17)).once
-      Squib::Deck.new do
-        @cards = [card]
-        set font: 'Times New Roman 16'
-        text str: 'a', font: 'Arial 18'
-      end
-    end
-  end
-
-end

data/spec/graphics/graphics_shapes_spec.rb

@@ -1,85 +0,0 @@
-require 'spec_helper'
-require 'squib'
-
-describe Squib::Card do
-
-  let(:deck) { double(Squib::Deck) }
-  let(:cxt)  { double(Cairo::Context) }
-
-  def expect_stroke(cxt, fill_color, stroke_color, stroke_width)
-    expect(cxt).to receive(:set_source_color).with(stroke_color).once
-    expect(cxt).to receive(:set_line_width).with(stroke_width).once
-    expect(cxt).to receive(:stroke).once
-    expect(cxt).to receive(:set_source_color).with(fill_color).once
-    expect(cxt).to receive(:fill).once
-  end
-
-  before(:each) do
-    allow(Cairo::Context).to receive(:new).and_return(cxt)
-    allow(deck).to receive(:dir).and_return('_output')
-    allow(deck).to receive(:count_format).and_return('%02d')
-    allow(deck).to receive(:prefix).and_return('card_')
-    allow(deck).to receive(:antialias).and_return('subpixel')
-    allow(deck).to receive(:backend).and_return('memory')
-  end
-
-  context 'rect' do
-    it 'make all the expected calls on a smoke test' do
-      expect(cxt).to receive(:antialias=).with('subpixel')
-      expect(cxt).to receive(:save).once
-      expect(cxt).to receive(:rounded_rectangle).with(37, 38, 50, 100, 10, 15).twice
-      expect_stroke(cxt, '#fff', '#f00', 2.0)
-      expect(cxt).to receive(:restore).once
-
-      card = Squib::Card.new(deck, 100, 150)
-      # rect(x, y, width, height, x_radius, y_radius,
-      #      fill_color, stroke_color, stroke_width)
-      card.rect(37, 38, 50, 100, 10, 15, '#fff', '#f00', 2.0)
-    end
-  end
-
-  context 'circle' do
-    it 'make all the expected calls on a smoke test' do
-      expect(cxt).to receive(:antialias=).with('subpixel')
-      expect(cxt).to receive(:save).once
-      expect(cxt).to receive(:move_to).with(137, 38)
-      expect(cxt).to receive(:circle).with(37, 38, 100).twice
-      expect_stroke(cxt, '#fff', '#f00', 2.0)
-      expect(cxt).to receive(:restore).once
-
-      card = Squib::Card.new(deck, 100, 150)
-      # circle(x, y, radius,
-      #        fill_color, stroke_color, stroke_width)
-      card.circle(37, 38, 100, '#fff', '#f00', 2.0)
-    end
-  end
-
-  context 'triangle' do
-    it 'make all the expected calls on a smoke test' do
-      expect(cxt).to receive(:antialias=).with('subpixel')
-      expect(cxt).to receive(:save).once
-      expect(cxt).to receive(:triangle).with(1, 2, 3, 4, 5, 6).twice
-      expect_stroke(cxt, '#fff', '#f00', 2.0)
-      expect(cxt).to receive(:restore).once
-
-      card = Squib::Card.new(deck, 100, 150)
-      card.triangle(1, 2, 3, 4, 5, 6, '#fff', '#f00', 2.0)
-    end
-  end
-
-  context 'line' do
-    it 'make all the expected calls on a smoke test' do
-      expect(cxt).to receive(:antialias=).with('subpixel')
-      expect(cxt).to receive(:save).once
-      expect(cxt).to receive(:move_to).with(1, 2).once
-      expect(cxt).to receive(:line_to).with(3, 4).once
-      expect(cxt).to receive(:set_source_color).with('#fff').once
-      expect(cxt).to receive(:set_line_width).with(2.0).once
-      expect(cxt).to receive(:stroke).once
-      expect(cxt).to receive(:restore).once
-
-      card = Squib::Card.new(deck, 100, 150)
-      card.line(1, 2, 3, 4, '#fff', 2.0)
-    end
-  end
-end

data/spec/graphics/graphics_text_spec.rb

@@ -1,164 +0,0 @@
-require 'spec_helper'
-require 'squib'
-
-describe Squib::Card, '#text' do
-
-  context 'typical inputs' do
-    let(:deck)      { double(Squib::Deck) }
-    let(:context)   { double(Cairo::Context) }
-    let(:layout)    { double(Pango::Layout) }
-    let(:font_desc) { double(Pango::FontDescription) }
-    let(:pango_cxt) { double(Pango::Context) }
-
-    before(:each) do
-      allow(Cairo::Context).to receive(:new).and_return(context)
-      allow(deck).to receive(:dir).and_return('_output')
-      allow(deck).to receive(:count_format).and_return('%02d')
-      allow(deck).to receive(:prefix).and_return('card_')
-      allow(deck).to receive(:antialias).and_return('best')
-      allow(deck).to receive(:antialias).and_return('subpixel')
-      allow(deck).to receive(:backend).and_return('memory')
-      allow(layout).to receive(:context).and_return(pango_cxt)
-    end
-
-    it 'make all the expected calls on a smoke test' do
-      extent = Pango::Rectangle.new(50,60,100,200)
-      expect(Squib.logger).to receive(:debug).once
-      expect(context).to receive(:antialias=).with('subpixel').once
-      expect(context).to receive(:save).once
-      expect(context).to receive(:set_source_color).once
-      expect(context).to receive(:move_to).with(0, 0).twice
-      expect(context).to receive(:rotate).with(0.0).once
-      expect(context).to receive(:translate).with(10, 15).once
-      expect(context).to receive(:create_pango_layout).once.and_return(layout)
-      expect(Pango::FontDescription).to receive(:new).with('Sans 12').and_return(font_desc)
-      expect(layout ).to receive(:font_description=).with(font_desc).once
-      expect(layout ).to receive(:text=).with('foo').once
-      expect(layout ).to receive(:width=).with(20 * Pango::SCALE).once
-      expect(layout ).to receive(:height=).with(25 * Pango::SCALE).once
-      expect(layout ).to receive(:ellipsize=).with(Pango::Layout::ELLIPSIZE_NONE).once
-      expect(layout ).to receive(:alignment=).with(Pango::Layout::ALIGN_LEFT).once
-      expect(pango_cxt).to receive(:font_options=).once
-      expect(layout ).to receive(:justify=).with(false).once
-      expect(layout ).to receive(:spacing=).with(1.0 * Pango::SCALE).once
-      expect(context).to receive(:update_pango_layout).once
-      expect(layout ).to receive(:height).once.and_return(25)
-      expect(layout ).to receive(:extents).thrice.and_return([nil,extent])
-      expect(context).to receive(:update_pango_layout).once
-      expect(context).to receive(:show_pango_layout).once
-      expect(context).to receive(:restore).once
-
-      card = Squib::Card.new(deck, 100, 150)
-      # text(str, font, font_size, color,
-      #      x, y, width, height,
-      #      markup, justify, wrap, ellipsize,
-      #      spacing, align, valign, hint, angle,
-      #      stroke_width, stroke_color)
-      ret = card.text(Squib::TextEmbed.new,'foo', 'Sans 12', nil, '#abc',
-                      10, 15, 20, 25,
-                      nil, false, false, false,
-                      1.0, :left, :top, nil, 0.0, '#fff', 0)
-      expect(ret).to eq({width: 0, height: 0})
-    end
-  end
-
-  context 'convenience lookups' do
-    let(:deck)      { double(Squib::Deck) }
-    let(:context)   { double(Cairo::Context).as_null_object }
-    let(:layout)    { double(Pango::Layout).as_null_object }
-    let(:extents)   { double("extents") }
-
-    before(:each) do
-      allow(Cairo::Context).to receive(:new).and_return(context)
-      expect(context).to receive(:create_pango_layout).once.and_return(layout)
-      allow(deck).to receive(:dir).and_return('_output')
-      allow(deck).to receive(:count_format).and_return('%02d')
-      allow(deck).to receive(:prefix).and_return('card_')
-      allow(deck).to receive(:antialias).and_return('subpixel')
-      allow(deck).to receive(:backend).and_return('memory')
-    end
-
-    it 'aligns right with strings' do
-      card = Squib::Card.new(deck, 100, 150)
-      expect(layout).to receive(:alignment=).with(Pango::Layout::ALIGN_RIGHT).once
-      card.text(Squib::TextEmbed.new, 'foo', 'Sans 12', nil, '#abc',
-                10, 15, 20, 50,
-                nil, false, false, false,
-                1.0, 'right', :top, nil, 0.0, '#fff', 0)
-    end
-
-    it 'aligns center with strings' do
-      card = Squib::Card.new(deck, 100, 150)
-      expect(layout).to receive(:alignment=).with(Pango::Layout::ALIGN_CENTER).once
-      card.text(Squib::TextEmbed.new, 'foo', 'Sans 12', nil, '#abc',
-                10, 15, 20, 50,
-                nil, false, false, false,
-                1.0, 'center', :top, nil, 0.0, '#fff', 0)
-    end
-
-    it 'sets wrap to char with string char' do
-      card = Squib::Card.new(deck, 100, 150)
-      expect(layout).to receive(:wrap=).with(Pango::Layout::WRAP_CHAR).once
-      card.text(Squib::TextEmbed.new, 'foo', 'Sans 12', nil, '#abc',
-                10, 15, 20, 50,
-                nil, false, 'char', false,
-                1.0, :left, :top, nil, 0.0, '#fff', 0)
-    end
-
-    it 'sets wrap to word with word string' do
-      card = Squib::Card.new(deck, 100, 150)
-      expect(layout).to receive(:wrap=).with(Pango::Layout::WRAP_WORD).once
-      card.text(Squib::TextEmbed.new, 'foo', 'Sans 12', nil, '#abc',
-                10, 15, 20, 50,
-                nil, false, 'word', false,
-                1.0, :left, :top, nil, 0.0, '#fff', 0)
-    end
-
-    it 'sets wrap to word_char with symbol word_char' do
-      card = Squib::Card.new(deck, 100, 150)
-      expect(layout).to receive(:wrap=).with(Pango::Layout::WRAP_WORD_CHAR).once
-      card.text(Squib::TextEmbed.new, 'foo', 'Sans 12', nil, '#abc',
-                10, 15, 20, 50,
-                nil, false, :word_char, false,
-                1.0, :left, :top, nil, 0.0, '#fff', 0)
-    end
-
-    it 'sets wrap to word_char with true' do
-      card = Squib::Card.new(deck, 100, 150)
-      expect(layout).to receive(:wrap=).with(Pango::Layout::WRAP_WORD_CHAR).once
-      card.text(Squib::TextEmbed.new, 'foo', 'Sans 12', nil, '#abc',
-                10, 15, 20, 50,
-                nil, false, true, false,
-                1.0, :left, :top, nil, 0.0, '#fff', 0)
-    end
-
-    it 'sets ellipsize to start properly' do
-      card = Squib::Card.new(deck, 100, 150)
-      expect(layout).to receive(:ellipsize=).with(Pango::Layout::ELLIPSIZE_START).once
-      card.text(Squib::TextEmbed.new, 'foo', 'Sans 12', nil, '#abc',
-                10, 15, 20, 50,
-                nil, false, true, :start,
-                1.0, :left, :top, nil, 0.0, '#fff', 0)
-    end
-
-    it 'sets ellipsize to middle properly' do
-      card = Squib::Card.new(deck, 100, 150)
-      expect(layout).to receive(:ellipsize=).with(Pango::Layout::ELLIPSIZE_MIDDLE).once
-      card.text(Squib::TextEmbed.new, 'foo', 'Sans 12', nil, '#abc',
-                10, 15, 20, 50,
-                nil, false, true, 'middle',
-                1.0, :left, :top, nil, 0.0, '#fff', 0)
-    end
-
-    it 'implements stroke and fill when asked to' do
-      card = Squib::Card.new(deck, 100, 150)
-      expect(context).to receive(:set_line_width).with(3.0).once
-      expect(context).to receive(:pango_layout_path).once
-      card.text(Squib::TextEmbed.new, 'foo', 'Sans 12', nil, '#abc',
-                10, 15, 20, 50,
-                nil, false, true, 'middle',
-                1.0, :left, :top, nil, 0.0, '#f00', 3.0)
-    end
-
-  end
-end

data/spec/input_helpers_spec.rb

@@ -1,238 +0,0 @@
-require 'spec_helper'
-require 'squib'
-require 'squib/input_helpers'
-
-class DummyDeck
-  include  Squib::InputHelpers
-  attr_accessor :layout, :cards, :custom_colors, :width, :height, :dpi
-end
-
-describe Squib::InputHelpers do
-
-  before(:each) do
-    @deck = DummyDeck.new
-    @deck.layout = {
-      'blah' => {x: 25},
-      'apples' => {x: 35},
-      'oranges' => {y: 45},
-    }
-    @deck.cards = %w(a b)
-    @deck.custom_colors = {}
-    @deck.width = 100
-    @deck.height = 200
-    @deck.dpi = 300
-  end
-
-  context '#layoutify' do
-    it 'warns on the logger when the layout does not exist' do
-      expect(Squib.logger).to receive(:warn).with("Layout entry 'foo' does not exist.").twice
-      expect(Squib.logger).to receive(:debug)
-      expect(@deck.send(:layoutify, {layout: :foo})).to eq({layout: [:foo,:foo]})
-    end
-
-    it 'applies the layout in a normal situation' do
-      expect(@deck.send(:layoutify, {layout: :blah})).to \
-        eq({layout: [:blah, :blah], x: [25, 25]})
-    end
-
-    it 'applies two different layouts for two different situations' do
-      expect(@deck.send(:layoutify, {layout: ['blah', 'apples']})).to \
-        eq({layout: ['blah','apples'], x: [25, 35]})
-    end
-
-    it 'still has nils when not applied two different layouts differ in structure' do
-      expect(@deck.send(:layoutify, {layout: ['apples', 'oranges']})).to \
-        eq({layout: ['apples','oranges'], x: [35], y: [nil, 45]})
-      #...this might behavior that is hard to debug for users. Trying to come up with a warning or something...
-    end
-
-    it 'also looks up based on strings' do
-      expect(@deck.send(:layoutify, {layout: 'blah'})).to \
-        eq({layout: ['blah','blah'], x: [25, 25]})
-    end
-
-  end
-
-  context '#rangeify' do
-    it 'must be within the card size range' do
-      expect{@deck.send(:rangeify, {range: 2..3})}.to \
-        raise_error(ArgumentError, '2..3 is outside of deck range of 0..1')
-    end
-
-    it 'cannot be nil' do
-      expect{@deck.send(:rangeify, {range: nil})}.to \
-        raise_error(RuntimeError, 'Range cannot be nil')
-    end
-
-    it 'defaults to a range of all cards if :all' do
-      expect(@deck.send(:rangeify, {range: :all})).to eq({range: 0..1})
-    end
-  end
-
-  context '#fileify' do
-    it 'should throw an error if the file does not exist' do
-      expect{@deck.send(:fileify, {file: 'nonexist.txt'}, true)}.to \
-        raise_error(RuntimeError,"File #{File.expand_path('nonexist.txt')} does not exist!")
-    end
-  end
-
-  context '#dirify' do
-    it 'should raise an error if the directory does not exist' do
-      expect{@deck.send(:dirify, {dir: 'nonexist'}, :dir, false)}.to \
-        raise_error(RuntimeError,"'nonexist' does not exist!")
-    end
-
-    it 'should warn and make a directory creation is allowed' 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
-        expect(@deck.send(:dirify, opts, :dir, true)).to eq(opts)
-        expect(Dir.exists? 'tocreate').to be true
-      end
-    end
-
-  end
-
-  context '#colorify' do
-    it 'should pass through if nillable' do
-      color = @deck.send(:colorify, {color: ['#fff']}, true)[:color]
-      expect(color).to eq(['#fff'])
-    end
-
-    it 'pulls from custom colors in the config' do
-      @deck.custom_colors['foo'] = '#abc'
-      expect(@deck.send(:colorify, {color: [:foo]}, false)[:color][0].to_s).to \
-        eq('#abc')
-    end
-
-    it 'pulls custom colors even when a string' do
-      @deck.custom_colors['foo'] = '#abc'
-      expect(@deck.send(:colorify, {color: ['foo']}, false)[:color][0].to_s).to \
-        eq('#abc')
-    end
-  end
-
-  context '#rotateify' do
-    it 'computes a clockwise rotate properly' do
-      opts = @deck.send(:rotateify, {rotate: :clockwise})
-      expect(opts).to eq({ :angle => 0.5 * Math::PI,
-                           :rotate => :clockwise
-                         })
-    end
-
-    it 'computes a counter-clockwise rotate properly' do
-      opts = @deck.send(:rotateify, {rotate: :counterclockwise})
-      expect(opts).to eq({ :angle => 1.5 * Math::PI,
-                           :rotate => :counterclockwise
-                         })
-    end
-  end
-
-  context '#convert_units' do
-    it 'does not touch arrays integers' do
-      args = {x: [156]}
-      needed_params = [:x]
-      opts = @deck.send(:convert_units, args, needed_params)
-      expect(opts).to eq({ :x => [156] })
-    end
-
-    it 'does not touch arrays floats' do
-      args = {x: [156.2]}
-      needed_params = [:x]
-      opts = @deck.send(:convert_units, args, needed_params)
-      expect(opts).to eq({ :x => [156.2] })
-    end
-
-    it 'converts array of all inches' do
-      args = {x: ['1in', '2in']}
-      needed_params = [:x]
-      opts = @deck.send(:convert_units, args, needed_params)
-      expect(opts).to eq({:x => [300.0, 600.0] }) #assume 300dpi default
-    end
-
-    it 'converts array of some inches' do
-      args = {x: [156, '2in']}
-      needed_params = [:x]
-      opts = @deck.send(:convert_units, args, needed_params)
-      expect(opts).to eq({:x => [156.0, 600.0]}) #assume 300dpi default
-    end
-
-    it 'handles whitespace' do
-      args = {x: ['1in   ']}
-      needed_params = [:x]
-      opts = @deck.send(:convert_units, args, needed_params)
-      expect(opts).to eq({:x => [300.0] }) #assume 300dpi default
-    end
-
-     it 'converts centimeters' do
-      args = {x: ['2cm']}
-      needed_params = [:x]
-      opts = @deck.send(:convert_units, args, needed_params)
-      expect(opts).to eq({:x => [236.2204722] }) #assume 300dpi default
-    end
-
-    it 'handles non-expading singletons' do
-      args = {margin: '1in', trim: '1in', gap: '1in'}
-      needed_params = [:margin, :trim, :gap]
-      opts = @deck.send(:convert_units, args, needed_params)
-      expect(opts).to eq({margin: 300, trim: 300, gap: 300}) #assume 300dpi default
-    end
-
-  end
-
-  context '#rowify' do
-    it 'does nothing on an integer' do
-      opts = @deck.send(:rowify, {columns: 2, rows: 2})
-      expect(opts).to eq({ columns: 2,
-                           rows: 2
-                        })
-    end
-
-    it 'computes properly on non-integer' do
-      opts = @deck.send(:rowify, {columns: 1, rows: :infinite})
-      expect(opts).to eq({ columns: 1,
-                           rows: 2
-                        })
-    end
-  end
-
-  context '#faceify' do
-    it 'is false on left' do
-      opts = @deck.send(:faceify, {face: :left})
-      expect(opts).to eq({ face: false })
-    end
-
-    it 'is true on right' do
-      opts = @deck.send(:faceify, {face: 'Right'})
-      expect(opts).to eq({ face: true })
-    end
-
-    it 'is false on anything else' do
-      opts = @deck.send(:faceify, {face: 'flugelhorn'})
-      expect(opts).to eq({ face: false })
-    end
-  end
-
-  context '#formatify' do
-    it 'sets format to nil when format is not set' do
-      opts = @deck.send(:formatify, {foo: true})
-      expect(opts).to eq({
-        foo: true,
-        format: [nil]
-        })
-    end
-
-    it 'updates the format to array' do
-      opts = @deck.send(:formatify, {format: :png})
-      expect(opts).to eq({format: [:png]})
-    end
-
-    it 'updates the format to flattened array' do
-      opts = @deck.send(:formatify, {format: [[:png]]})
-      expect(opts).to eq({format: [:png]})
-    end
-
-  end
-
-end