squib 0.0.4 → 0.0.5

data/spec/graphics/graphics_save_doc_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+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
+
+    before(:each) do
+      @context = double(Cairo::Context)
+      allow(Cairo::PDFSurface).to receive(:new).and_return(nil) #don't create the file
+    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).thrice
+        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.save_pdf(args)
+      end
+    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).thrice
+        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_card_place(75, 75)
+        expect_card_place(831, 75)
+        expect_card_place(1587, 75)
+
+        deck.save_pdf(args)
+      end
+    end
+
+  end
+
+end

data/spec/graphics/graphics_shapes_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'squib'
+
+describe Squib::Card do
+
+  def expect_stroke(fill_color, stroke_color, stroke_width)
+    expect(@context).to receive(:set_source_color).with(stroke_color).once
+    expect(@context).to receive(:set_line_width).with(stroke_width).once
+    expect(@context).to receive(:stroke).once
+    expect(@context).to receive(:set_source_color).with(fill_color).once
+    expect(@context).to receive(:fill).once
+  end
+
+  before(:each) do
+    @deck    = double(Squib::Deck)
+    @context = double(Cairo::Context)
+    allow(Cairo::Context).to receive(:new).and_return(@context)
+  end
+
+  context 'rect' do
+    it 'make all the expected calls on a smoke test' do
+      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)
+      expect(@context).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(@context).to receive(:save).once
+      expect(@context).to receive(:circle).with(37, 38, 100).twice
+      expect_stroke('#fff', '#f00', 2.0)
+      expect(@context).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(@context).to receive(:save).once
+      expect(@context).to receive(:triangle).with(1, 2, 3, 4, 5, 6).twice
+      expect_stroke('#fff', '#f00', 2.0)
+      expect(@context).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(@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
+      expect(@context).to receive(:set_source_color).with('#fff').once
+      expect(@context).to receive(:set_line_width).with(2.0).once
+      expect(@context).to receive(:stroke).once
+      expect(@context).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

@@ -0,0 +1,135 @@
+require 'spec_helper'
+require 'squib'
+
+describe Squib::Card, '#text' do
+
+  context 'typical inputs' do
+    before(:each) do
+      @deck    = double(Squib::Deck)
+      @context = double(Cairo::Context)
+      @layout  = double(Pango::Layout)
+      allow(Cairo::Context).to receive(:new).and_return(@context)
+    end
+
+    it 'make all the expected calls on a smoke test' do
+      mock_squib_logger(@old_logger) do
+        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).once.and_return([0,0])
+        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)
+        card.text('foo', 'Sans 12', nil, '#abc',
+                  10, 15, 20, 25,
+                  nil, false, false, false,
+                  1.0, :left, :top, nil, 0.0)
+      end
+    end
+  end
+
+  context 'convenience lookups' do
+    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)
+    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('foo', 'Sans 12', nil, '#abc',
+                10, 15, 20, 50,
+                nil, false, false, false,
+                1.0, 'right', :top, nil, 0.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('foo', 'Sans 12', nil, '#abc',
+                10, 15, 20, 50,
+                nil, false, false, false,
+                1.0, 'center', :top, nil, 0.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('foo', 'Sans 12', nil, '#abc',
+                10, 15, 20, 50,
+                nil, false, 'char', false,
+                1.0, :left, :top, nil, 0.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('foo', 'Sans 12', nil, '#abc',
+                10, 15, 20, 50,
+                nil, false, 'word', false,
+                1.0, :left, :top, nil, 0.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('foo', 'Sans 12', nil, '#abc',
+                10, 15, 20, 50,
+                nil, false, :word_char, false,
+                1.0, :left, :top, nil, 0.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('foo', 'Sans 12', nil, '#abc',
+                10, 15, 20, 50,
+                nil, false, true, false,
+                1.0, :left, :top, nil, 0.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('foo', 'Sans 12', nil, '#abc',
+                10, 15, 20, 50,
+                nil, false, true, :start,
+                1.0, :left, :top, nil, 0.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('foo', 'Sans 12', nil, '#abc',
+                10, 15, 20, 50,
+                nil, false, true, 'middle',
+                1.0, :left, :top, nil, 0.0)
+    end
+
+  end
+end

data/spec/input_helpers_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'squib'
 require 'squib/input_helpers'
 
 class DummyDeck
@@ -6,20 +7,12 @@ class DummyDeck
   attr_accessor :layout, :cards, :custom_colors
 end
 
-module Squib
-  def logger=(l)
-    @logger = l
-  end
-  module_function 'logger='
-end
-
 describe Squib::InputHelpers do
 
-
   before(:each) do
     @deck = DummyDeck.new
     @deck.layout = {
-      'blah' => {x: 25}, 
+      'blah' => {x: 25},
       'apples' => {x: 35},
       'oranges' => {y: 45},
     }
@@ -28,90 +21,118 @@ describe Squib::InputHelpers do
   end
 
   context '#layoutify' do
-    it "warns on the logger when the layout doesn't exist" do
-      @old_logger = Squib.logger
-      Squib.logger = instance_double(Logger)
-      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]}) 
-      Squib.logger = @old_logger
+    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
     end
 
-    it "applies the layout in a normal situation" do
+    it 'applies the layout in a normal situation' do
       expect(@deck.send(:layoutify, {layout: :blah})).to \
-        eq({layout: [:blah, :blah], x: [25, 25]}) 
+        eq({layout: [:blah, :blah], x: [25, 25]})
     end
 
-    it "applies two different layouts for two different situations" do
+    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]}) 
+        eq({layout: ['blah','apples'], x: [25, 35]})
     end
 
-    it "still has nils when not applied two different layouts differ in structure" do
+    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]}) 
+        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
+    it 'also looks up based on strings' do
       expect(@deck.send(:layoutify, {layout: 'blah'})).to \
-        eq({layout: ['blah','blah'], x: [25, 25]}) 
+        eq({layout: ['blah','blah'], x: [25, 25]})
     end
 
   end
 
   context '#rangeify' do
-    it "must be within the card size range" 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
+    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
+    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 doesn't exist" do
+  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 "#dir" do
-    it "should raise an error if the directory does not exist" do
+  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)
+        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
+      end
+    end
+
   end
 
-  context "#colorify" do
-    it "should parse if nillable" do
+  context '#colorify' do
+    it 'should parse if nillable' do
       color = @deck.send(:colorify, {color: ['#fff']}, true)[:color]
       expect(color.to_a[0].to_a).to eq([1.0, 1.0, 1.0, 1.0])
     end
 
-    it "raises and error if the color doesn't exist" do
+    it 'raises and error if the color does not exist' do
       expect{ @deck.send(:colorify, {color: [:nonexist]}, false) }.to \
-        raise_error(ArgumentError, "unknown color name: nonexist")
+        raise_error(ArgumentError, 'unknown color name: nonexist')
     end
 
-    it "pulls from config's custom colors" do
-      @deck.custom_colors['foo'] = "#abc"
+    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('#AABBCCFF')
     end
 
-    it "pulls from config's custom colors even when a string" do
-      @deck.custom_colors['foo'] = "#abc"
+    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('#AABBCCFF')
     end
   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
+
+end