squib 0.3.0 → 0.4.0

data/spec/data/samples/units.rb.txt

@@ -1,3 +1,4 @@
+cairo: antialias=(["subpixel"])
 cairo: save([])
 cairo: set_source_color(["#ddd"])
 cairo: paint([])

data/spec/deck_spec.rb

@@ -1,5 +1,5 @@
 require 'spec_helper'
-require 'squib/deck'
+require 'squib'
 
 describe Squib::Deck do
 

data/spec/graphics/graphics_images_spec.rb

@@ -12,10 +12,16 @@ describe Squib::Card do
       allow(Cairo::ImageSurface).to receive(:from_png).and_return(@png)
       allow(Cairo::ImageSurface).to receive(:new).and_return(@png)
       allow(RSVG::Handle).to receive(:new_from_file).and_return(@svg)
+      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')
+
   end
 
   context '#png' do
     it 'makes all the expected calls on a smoke test' do
+      expect(@context).to receive(:antialias=).with('subpixel')
       expect(@context).to receive(:save).once
       expect(@context).to receive(:translate).with(-37, -38).once
       expect(@context).to receive(:rotate).with(0.0).once
@@ -42,14 +48,12 @@ describe Squib::Card do
     it 'makes all the expected calls on a smoke test' do
       expect(@svg).to receive(:width).and_return(100).twice
       expect(@svg).to receive(:height).and_return(100).twice
+      expect(@context).to receive(:antialias=).with('subpixel').once
       expect(@context).to receive(:save).once
-      expect(@context).to receive(:translate).with(-37, -38).once
       expect(@context).to receive(:rotate).with(0.0).once
       expect(@context).to receive(:translate).with(37, 38).once
       expect(@context).to receive(:scale).with(1.0, 1.0).once
       expect(@context).to receive(:render_rsvg_handle).with(@svg, 'id').once
-      expect(@context).to receive(:set_source).with(@png, 37, 38).once
-      expect(@context).to receive(:paint).with(0.9).once
       expect(@context).to receive(:restore).once
 
       card = Squib::Card.new(@deck, 100, 150)

data/spec/graphics/graphics_save_doc_spec.rb

@@ -3,62 +3,59 @@ require 'squib'
 
 describe Squib::Deck, '#save_pdf' do
 
-  def expect_card_place(x, y)
-    expect(@context).to receive(:set_source)
-      .with(instance_of(Cairo::ImageSurface), -37, -37)
-      .once                                   # trim the card
-    expect(@context).to receive(:paint).once  # paint trimmed card
-    expect(@context).to receive(:set_source)  # place the card
-      .with(instance_of(Cairo::ImageSurface), x, y).once
-    expect(@context).to receive(:paint).once  # paint placed card
-  end
-
   context 'typical inputs' do
+    let(:cxt) { double(Cairo::Context) }
+
+    def expect_card_place(x, y)
+      expect(cxt).to receive(:translate).with(x, y).once
+      expect(cxt).to receive(:rectangle).once
+      expect(cxt).to receive(:clip).once
+      expect(cxt).to receive(:set_source)  # place the card
+                      .with(instance_of(Cairo::ImageSurface), 0, 0).once
+      expect(cxt).to receive(:paint).once  # paint placed card
+      expect(cxt).to receive(:translate).with(-x,-y).once
+      expect(cxt).to receive(:reset_clip).once
+    end
 
     before(:each) do
-      @context = double(Cairo::Context)
       allow(Cairo::PDFSurface).to receive(:new).and_return(nil) #don't create the file
+      allow(Cairo::Context).to    receive(:new).and_return(cxt)
+      allow(cxt).to receive(:antialias=)
     end
 
     it 'make all the expected calls on a smoke test' do
       num_cards = 9
-      args = { file: 'foo.pdf', dir: '_out', margin: 75, gap: 5, trim: 37 }
-      deck = Squib::Deck.new(cards: num_cards, width: 825, height: 1125)
-      mock_squib_logger(@old_logger) do
-        expect(Squib.logger).to receive(:debug).at_least(:once)
-        expect(Cairo::Context).to receive(:new).and_return(@context).exactly(num_cards + 1).times
-        expect(deck).to receive(:dirify) { |arg| arg } #don't create the dir
-
-        expect_card_place(75, 75)
-        expect_card_place(831, 75)
-        expect_card_place(1587, 75)
-        expect_card_place(2343, 75)
-        expect_card_place(75, 1131)
-        expect_card_place(831, 1131)
-        expect_card_place(1587, 1131)
-        expect_card_place(2343, 1131)
-        expect(@context).to receive(:show_page).once
-        expect_card_place(75, 75)
+      deck = Squib::Deck.new(cards: 9, width: 825, height: 1125)
+      expect(deck).to receive(:dirify) { |arg| arg } #don't create the dir
+      expect(Squib.logger).to receive(:debug).at_least(:once)
+
+      expect_card_place(75, 75)
+      expect_card_place(831, 75)
+      expect_card_place(1587, 75)
+      expect_card_place(2343, 75)
+      expect_card_place(75, 1131)
+      expect_card_place(831, 1131)
+      expect_card_place(1587, 1131)
+      expect_card_place(2343, 1131)
+      expect(cxt).to receive(:show_page).once
+      expect_card_place(75, 75)
 
-        deck.save_pdf(args)
-      end
+      args = { file: 'foo.pdf', dir: '_out', margin: 75, gap: 5, trim: 37 }
+      deck.save_pdf(args)
     end
 
     it 'only does the three cards on a limited range' do
       num_cards = 9
       args = { range: 2..4, file: 'foo.pdf', dir: '_out', margin: 75, gap: 5, trim: 37 }
       deck = Squib::Deck.new(cards: num_cards, width: 825, height: 1125)
-      mock_squib_logger(@old_logger) do
-        expect(Squib.logger).to receive(:debug).at_least(:once)
-        expect(Cairo::Context).to receive(:new).and_return(@context).exactly(4).times
-        expect(deck).to receive(:dirify) { |arg| arg }  #don't create the dir
+      expect(Squib.logger).to receive(:debug).at_least(:once)
+      expect(deck).to receive(:dirify) { |arg| arg }  #don't create the dir
 
-        expect_card_place(75, 75)
-        expect_card_place(831, 75)
-        expect_card_place(1587, 75)
+      expect_card_place(75, 75)
+      expect_card_place(831, 75)
+      expect_card_place(1587, 75)
 
-        deck.save_pdf(args)
-      end
+      deck.save_pdf(args)
     end
 
   end

data/spec/graphics/graphics_shapes_spec.rb

@@ -15,10 +15,15 @@ describe Squib::Card do
     @deck    = double(Squib::Deck)
     @context = double(Cairo::Context)
     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')
   end
 
   context 'rect' do
     it 'make all the expected calls on a smoke test' do
+      expect(@context).to receive(:antialias=).with('subpixel')
       expect(@context).to receive(:save).once
       expect(@context).to receive(:rounded_rectangle).with(37, 38, 50, 100, 10, 15).twice
       expect_stroke('#fff', '#f00', 2.0)
@@ -33,7 +38,9 @@ describe Squib::Card do
 
   context 'circle' do
     it 'make all the expected calls on a smoke test' do
+      expect(@context).to receive(:antialias=).with('subpixel')
       expect(@context).to receive(:save).once
+      expect(@context).to receive(:move_to).with(137, 38)
       expect(@context).to receive(:circle).with(37, 38, 100).twice
       expect_stroke('#fff', '#f00', 2.0)
       expect(@context).to receive(:restore).once
@@ -47,6 +54,7 @@ describe Squib::Card do
 
   context 'triangle' do
     it 'make all the expected calls on a smoke test' do
+      expect(@context).to receive(:antialias=).with('subpixel')
       expect(@context).to receive(:save).once
       expect(@context).to receive(:triangle).with(1, 2, 3, 4, 5, 6).twice
       expect_stroke('#fff', '#f00', 2.0)
@@ -59,6 +67,7 @@ describe Squib::Card do
 
   context 'line' do
     it 'make all the expected calls on a smoke test' do
+      expect(@context).to receive(:antialias=).with('subpixel')
       expect(@context).to receive(:save).once
       expect(@context).to receive(:move_to).with(1, 2).once
       expect(@context).to receive(:line_to).with(3, 4).once

data/spec/graphics/graphics_text_spec.rb

@@ -4,66 +4,77 @@ 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) }
+
     before(:each) do
-      @deck    = double(Squib::Deck)
-      @context = double(Cairo::Context)
-      @layout  = double(Pango::Layout)
-      allow(Cairo::Context).to receive(:new).and_return(@context)
+      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')
     end
 
     it 'make all the expected calls on a smoke test' do
-      mock_squib_logger(@old_logger) do
-        extent = Pango::Rectangle.new(50,60,100,200)
-        expect(Squib.logger).to receive(:debug).once
-        expect(@context).to receive(:save).once
-        expect(@context).to receive(:set_source_color).once
-        expect(@context).to receive(:move_to).with(10, 15).once
-        expect(@context).to receive(:translate).with(-10, -15).once
-        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(@layout).to receive(:font_description=).with(Pango::FontDescription.new('Sans 12')).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(@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)
-        ret = card.text('foo', 'Sans 12', nil, '#abc',
-                        10, 15, 20, 25,
-                        nil, false, false, false,
-                        1.0, :left, :top, nil, 0.0)
-        expect(ret).to eq({width: 0, height: 0})
-      end
+      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(10, 15).once
+      expect(context).to receive(:translate).with(-10, -15).once
+      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(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)
+      ret = card.text('foo', 'Sans 12', nil, '#abc',
+                      10, 15, 20, 25,
+                      nil, false, false, false,
+                      1.0, :left, :top, nil, 0.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
-      @deck    = double(Squib::Deck)
-      @context = double(Cairo::Context).as_null_object
-      @layout  = double(Pango::Layout).as_null_object
-      @extents = double("extents")
-      allow(Cairo::Context).to receive(:new).and_return(@context)
-      expect(@context).to receive(:create_pango_layout).once.and_return(@layout)
+      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('best')
     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 = Squib::Card.new(deck, 100, 150)
+      expect(layout).to receive(:alignment=).with(Pango::Layout::ALIGN_RIGHT).once
       card.text('foo', 'Sans 12', nil, '#abc',
                 10, 15, 20, 50,
                 nil, false, false, false,
@@ -71,8 +82,8 @@ describe Squib::Card, '#text' do
     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 = Squib::Card.new(deck, 100, 150)
+      expect(layout).to receive(:alignment=).with(Pango::Layout::ALIGN_CENTER).once
       card.text('foo', 'Sans 12', nil, '#abc',
                 10, 15, 20, 50,
                 nil, false, false, false,
@@ -80,8 +91,8 @@ describe Squib::Card, '#text' do
     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 = Squib::Card.new(deck, 100, 150)
+      expect(layout).to receive(:wrap=).with(Pango::Layout::WRAP_CHAR).once
       card.text('foo', 'Sans 12', nil, '#abc',
                 10, 15, 20, 50,
                 nil, false, 'char', false,
@@ -89,8 +100,8 @@ describe Squib::Card, '#text' do
     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 = Squib::Card.new(deck, 100, 150)
+      expect(layout).to receive(:wrap=).with(Pango::Layout::WRAP_WORD).once
       card.text('foo', 'Sans 12', nil, '#abc',
                 10, 15, 20, 50,
                 nil, false, 'word', false,
@@ -98,8 +109,8 @@ describe Squib::Card, '#text' do
     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 = Squib::Card.new(deck, 100, 150)
+      expect(layout).to receive(:wrap=).with(Pango::Layout::WRAP_WORD_CHAR).once
       card.text('foo', 'Sans 12', nil, '#abc',
                 10, 15, 20, 50,
                 nil, false, :word_char, false,
@@ -107,8 +118,8 @@ describe Squib::Card, '#text' do
     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 = Squib::Card.new(deck, 100, 150)
+      expect(layout).to receive(:wrap=).with(Pango::Layout::WRAP_WORD_CHAR).once
       card.text('foo', 'Sans 12', nil, '#abc',
                 10, 15, 20, 50,
                 nil, false, true, false,
@@ -116,8 +127,8 @@ describe Squib::Card, '#text' do
     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 = Squib::Card.new(deck, 100, 150)
+      expect(layout).to receive(:ellipsize=).with(Pango::Layout::ELLIPSIZE_START).once
       card.text('foo', 'Sans 12', nil, '#abc',
                 10, 15, 20, 50,
                 nil, false, true, :start,
@@ -125,8 +136,8 @@ describe Squib::Card, '#text' do
     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 = Squib::Card.new(deck, 100, 150)
+      expect(layout).to receive(:ellipsize=).with(Pango::Layout::ELLIPSIZE_MIDDLE).once
       card.text('foo', 'Sans 12', nil, '#abc',
                 10, 15, 20, 50,
                 nil, false, true, 'middle',

data/spec/input_helpers_spec.rb

@@ -25,11 +25,9 @@ describe Squib::InputHelpers do
 
   context '#layoutify' do
     it 'warns on the logger when the layout does not exist' do
-      mock_squib_logger(@old_logger) 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
+      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
@@ -88,11 +86,9 @@ describe Squib::InputHelpers do
       opts = {dir: 'tocreate'}
       Dir.chdir(output_dir) do
         FileUtils.rm_rf('tocreate', secure: true)
-        mock_squib_logger(@old_logger) do
-          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
+        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
 
@@ -218,4 +214,25 @@ describe Squib::InputHelpers do
     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

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 require 'simplecov'
 require 'coveralls'
+require 'byebug'
 
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
   SimpleCov::Formatter::HTMLFormatter,
@@ -57,6 +58,7 @@ def mock_cairo(strio)
   cxt     = double(Cairo::Context)
   surface = double(Cairo::ImageSurface)
   pango   = double(Pango::Layout)
+  font    = double(Pango::FontDescription)
   allow(Squib.logger).to receive(:warn) {}
   allow(ProgressBar).to receive(:create).and_return(Squib::DoNothing.new)
   allow(Cairo::ImageSurface).to receive(:new).and_return(surface)
@@ -68,11 +70,14 @@ def mock_cairo(strio)
   allow(pango).to receive(:height).and_return(25)
   allow(pango).to receive(:width).and_return(25)
   allow(pango).to receive(:extents).and_return([Pango::Rectangle.new(0,0,0,0)]*2)
+  allow(Pango::FontDescription).to receive(:new).and_return(font)
+  allow(Cairo::PDFSurface).to receive(:new).and_return(nil)
 
   %w(save set_source_color paint restore translate rotate move_to
     update_pango_layout width height show_pango_layout rounded_rectangle
     set_line_width stroke fill set_source scale render_rsvg_handle circle
-    triangle line_to operator= show_page clip transform mask).each do |m|
+    triangle line_to operator= show_page clip transform mask rectangle
+    reset_clip antialias=).each do |m|
     allow(cxt).to receive(m) { |*args| strio << scrub_hex("cairo: #{m}(#{args})\n") }
   end
 
@@ -81,9 +86,14 @@ def mock_cairo(strio)
     allow(pango).to receive(m) {|*args| strio << scrub_hex("pango: #{m}(#{args})\n") }
   end
 
+  %w(size=).each do |m|
+    allow(font).to receive(m) { |*args| strio << scrub_hex("pango font: #{m}(#{args})\n") }
+  end
+
   %w(write_to_png).each do |m|
     allow(surface).to receive(m) { |*args| strio << scrub_hex("surface: #{m}(#{args})\n") }
   end
+
 end
 
 # Refine Squib to allow setting the logger and progress bar
@@ -91,20 +101,13 @@ module Squib
   def logger=(l)
     @logger = l
   end
-  module_function 'logger='
+  module_function :logger=
 
   class Deck
     attr_accessor :progress_bar
   end
 end
 
-def mock_squib_logger(old_logger)
-  old_logger = Squib.logger
-  Squib.logger = instance_double(Logger)
-  yield
-  Squib.logger = old_logger
-end
-
 def output_dir
   File.expand_path('../samples/_output', File.dirname(__FILE__))
 end