prawn-icon 1.0.0 → 2.0.0

data/spec/integration/icon_spec.rb

@@ -7,12 +7,13 @@
 require 'spec_helper'
 
 describe Prawn::Icon::Interface do
+  let(:pdf) { create_pdf }
+
   describe '::icon' do
     context 'valid icon key' do
       context 'with options' do
         it 'should handle text options (size)' do
-          pdf = create_pdf
-          pdf.icon 'fa-arrows', size: 60
+          pdf.icon 'far-address-book', size: 60
           text = PDF::Inspector::Text.analyze(pdf.render)
 
           expect(text.font_settings.first[:size]).to eq(60)
@@ -21,50 +22,69 @@ describe Prawn::Icon::Interface do
 
       context 'inline_format: true' do
         it 'should handle text options (size)' do
-          pdf = create_pdf
-          pdf.icon '<icon size="60">fa-arrows</icon>', inline_format: true
+          pdf.icon '<icon size="60">far-address-book</icon>', inline_format: true
           text = PDF::Inspector::Text.analyze(pdf.render)
 
-          expect(text.strings.first).to eq("\uf047")
+          expect(text.strings.first).to eq('')
           expect(text.font_settings.first[:size]).to eq(60.0)
         end
 
         it 'should be able to render on multiple documents' do
           pdf1 = create_pdf
           pdf2 = create_pdf
-          pdf1.icon '<icon>fa-arrows</icon>', inline_format: true
-          pdf2.icon '<icon>fa-arrows</icon>', inline_format: true
+          pdf1.icon '<icon>far-address-book</icon>', inline_format: true
+          pdf2.icon '<icon>far-address-book</icon>', inline_format: true
           text1 = PDF::Inspector::Text.analyze(pdf1.render)
           text2 = PDF::Inspector::Text.analyze(pdf2.render)
 
-          expect(text1.strings.first).to eq("\uf047")
-          expect(text2.strings.first).to eq("\uf047")
+          expect(text1.strings.first).to eq('')
+          expect(text2.strings.first).to eq('')
+        end
+
+        it 'renders the icon at the proper cursor position (#24)' do
+          icon_text = '<icon>fas-info-circle</icon> icon here!'
+          pdf.text 'Start'
+          pdf.move_down 10
+          pdf.text 'More'
+          pdf.move_down 20
+          icon = pdf.icon icon_text, inline_format: true
+          pdf.move_down 30
+          pdf.text 'End'
+
+          expect(icon.at.first).to eq(0)
+          expect(icon.at.last.round).to eq(734)
+        end
+
+        context 'with final_gap: false' do
+          it 'renders the icon without a final gap' do
+            icon = pdf.icon '<icon size="60">far-address-book</icon>',
+              inline_format: true,
+              final_gap: false
+            expect(icon.at.last.round).to eq(792)
+          end
         end
       end
 
       context 'without options' do
         it 'should render an icon to document' do
-          pdf = create_pdf
-          pdf.icon 'fa-arrows'
+          pdf.icon 'far-address-book'
           text = PDF::Inspector::Text.analyze(pdf.render)
 
-          expect(text.strings.first).to eq("\uf047")
+          expect(text.strings.first).to eq('')
         end
       end
     end
 
     context 'invalid icon key' do
       it 'should raise IconNotFound' do
-        pdf = create_pdf
-        proc = Proc.new { pdf.icon 'fa-__INVALID' }
+        proc = Proc.new { pdf.icon 'far-__INVALID' }
 
-        expect(proc).to raise_error(Prawn::Errors::IconNotFound)
+        expect(proc).to raise_error(Prawn::Icon::Errors::IconNotFound)
       end
     end
 
     context 'invalid specifier' do
       it 'should raise UnknownFont' do
-        pdf = create_pdf
         proc = Proc.new { pdf.icon '__INVALID__' }
 
         expect(proc).to raise_error(Prawn::Errors::UnknownFont)
@@ -75,74 +95,67 @@ describe Prawn::Icon::Interface do
   describe '::make_icon' do
     context ':inline_format => false (default)' do
       it 'should return a Prawn::Icon instance' do
-        pdf = create_pdf
-        icon = pdf.make_icon 'fa-arrows'
+        icon = pdf.make_icon 'far-address-book'
 
-        expect(icon.class).to eq(Prawn::Icon)
+        expect(icon).to be_a(Prawn::Icon)
       end
     end
 
     context ':inline_format => true' do
       it 'should return a Prawn::::Text::Formatted::Box instance' do
-        pdf = create_pdf
-        icon = pdf.make_icon '<icon>fa-arrows</icon>', inline_format: true
+        icon = pdf.make_icon '<icon>far-address-book</icon>', inline_format: true
 
-        expect(icon.class).to eq(Prawn::Text::Formatted::Box)
+        expect(icon).to be_a(Prawn::Text::Formatted::Box)
       end
     end
   end
 
   describe '::inline_icon' do
     it 'should return a Prawn::Text::Formatted::Box instance' do
-      pdf = create_pdf
-      icon = pdf.inline_icon '<icon>fa-arrows</icon>'
+      icon = pdf.inline_icon '<icon>far-address-book</icon>'
 
-      expect(icon.class).to eq(Prawn::Text::Formatted::Box)
+      expect(icon).to be_a(Prawn::Text::Formatted::Box)
     end
   end
 
   describe '::table_icon' do
     context 'inline_format: false (default)' do
       it 'should return a hash with font and content keys' do
-        pdf = create_pdf
-        icon = pdf.table_icon 'fa-arrows'
+        icon = pdf.table_icon 'far-address-book'
 
-        expect(icon.class).to eq(Hash)
-        expect(icon[:font]).to eq('fa')
-        expect(icon[:content]).to eq("\uf047")
+        expect(icon).to be_a(Hash)
+        expect(icon[:font]).to eq('far')
+        expect(icon[:content]).to eq('')
       end
     end
 
     context 'inline_format: true' do
       it 'should convert <icon> to <font> tags' do
-        pdf = create_pdf
-        icon = pdf.table_icon '<icon>fa-user</icon>', inline_format: true
+        icon = pdf.table_icon '<icon>fas-user</icon>', inline_format: true
 
-        expect(icon.class).to eq(Hash)
-        expect(icon[:content]).to eq('<font name="fa"></font>')
-        expect(icon[:inline_format]).to be_true
+        expect(icon).to be_a(Hash)
+        expect(icon[:content]).to eq('<font name="fas"></font>')
+        expect(icon[:inline_format]).to be true
       end
 
       it 'should ignore all other tags' do
-        pdf = create_pdf
         a = ['<b>BOLD</b> <color rgb="0099FF">BLUE</color>', inline_format: true]
         icon = pdf.table_icon(*a)
 
-        expect(icon.class).to eq(Hash)
+        expect(icon).to be_a(Hash)
         expect(icon[:content]).to eq(a[0])
-        expect(icon[:inline_format]).to be_true
+        expect(icon[:inline_format]).to be true
       end
 
       context 'multiple icons' do
         it 'should ignore any text not in an icon tag' do
-          pdf = create_pdf
-          a = ['<icon>fa-user</icon> Some Text <icon>fi-laptop</icon>', inline_format: true]
-          out = '<font name="fa"></font> Some Text <font name="fi"></font>'
+          a = ['<icon>fas-user</icon> Some Text <icon>fi-laptop</icon>', inline_format: true]
+          out = '<font name="fas"></font> Some Text <font name="fi"></font>'
           icon = pdf.table_icon(*a)
 
-          expect(icon.class).to eq(Hash)
+          expect(icon).to be_a(Hash)
           expect(icon[:content]).to eq(out)
-          expect(icon[:inline_format]).to be_true
+          expect(icon[:inline_format]).to be true
         end
       end
     end
@@ -150,43 +163,50 @@ describe Prawn::Icon::Interface do
 end
 
 describe Prawn::Icon do
-  context 'FontAwesome' do
-    it 'should render FontAwesome glyphs' do
-      pdf = create_pdf
-      pdf.icon 'fa-user'
+  let(:pdf) { create_pdf }
+
+  context 'FontAwesome | Regular' do
+    it 'should render regular glyphs' do
+      pdf.icon 'far-user'
       text = PDF::Inspector::Text.analyze(pdf.render)
 
-      expect(text.strings.first).to eq("")
+      expect(text.strings.first).to eq('')
     end
   end
 
-  context 'Foundation Icons' do
-    it 'should render Foundation glyphs' do
-      pdf = create_pdf
-      pdf.icon 'fi-laptop'
+  context 'FontAwesome | Solid' do
+    it 'should render solid glyphs' do
+      pdf.icon 'fas-user'
       text = PDF::Inspector::Text.analyze(pdf.render)
 
-      expect(text.strings.first).to eq("")
+      expect(text.strings.first).to eq('')
     end
   end
 
-  context 'GitHub Octicons' do
-    it 'should render GitHub Octicon glyphs' do
-      pdf = create_pdf
-      pdf.icon 'octicon-logo-github'
+  context 'FontAwesome | Brands' do
+    it 'should render FontAwesome glyphs' do
+      pdf.icon 'fab-amazon'
+      text = PDF::Inspector::Text.analyze(pdf.render)
+
+      expect(text.strings.first).to eq('')
+    end
+  end
+
+  context 'Foundation Icons' do
+    it 'should render Foundation glyphs' do
+      pdf.icon 'fi-laptop'
       text = PDF::Inspector::Text.analyze(pdf.render)
 
-      expect(text.strings.first).to eq("")
+      expect(text.strings.first).to eq('')
     end
   end
 
   context 'PaymentFont' do
     it 'should render PaymentFont glyphs' do
-      pdf = create_pdf
       pdf.icon 'pf-amazon'
       text = PDF::Inspector::Text.analyze(pdf.render)
 
-      expect(text.strings.first).to eq("")
+      expect(text.strings.first).to eq('')
     end
   end
 end

data/spec/spec_helper.rb

@@ -3,6 +3,10 @@
 # Copyright October 2014, Jesse Doyle. All rights reserved.
 #
 # This is free software. Please see the LICENSE and COPYING files for details.
+#
+#
+require 'simplecov'
+SimpleCov.start
 
 require "bundler"
 Bundler.setup

data/spec/support/parser_helper.rb

@@ -14,4 +14,4 @@ module ParserHelper
     regex = Prawn::Icon::Parser::CONTENT_REGEX
     string.scan(regex).flatten
   end
-end
+end

data/spec/support/pdf_helper.rb

@@ -12,4 +12,4 @@ module PDFHelper
   def valid_unicode?(string)
     string.force_encoding('UTF-8').valid_encoding?
   end
-end
+end

data/spec/unit/base_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+#
+# Copyright September 2016, Jesse Doyle. All rights reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+describe Prawn::Icon::Base do
+  describe 'FONTDIR' do
+    it 'returns the data/fonts directory' do
+      path = File.expand_path '../../..', __FILE__
+      path = File.join path, 'data/fonts'
+      expect(Prawn::Icon::Base::FONTDIR).to eq(path)
+    end
+  end
+end

data/spec/unit/errors/icon_key_empty_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+#
+# Copyright September 2016, Jesse Doyle. All rights reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+describe Prawn::Icon::Errors::IconKeyEmpty do
+  let(:pdf) { create_pdf }
+
+  it 'is a StandardError' do
+    expect(subject).to be_a(StandardError)
+  end
+
+  it 'is thrown on a missing icon key' do
+    proc = Proc.new { pdf.icon '' }
+
+    expect(proc).to raise_error(described_class)
+  end
+end

data/spec/unit/errors/icon_not_found_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+#
+# Copyright September 2016, Jesse Doyle. All rights reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+describe Prawn::Icon::Errors::IconNotFound do
+  let(:pdf) { create_pdf }
+
+  it 'is a StandardError' do
+    expect(subject).to be_a(StandardError)
+  end
+
+  it 'is thrown on an invalid icon key' do
+    proc = Proc.new { pdf.icon 'far-an invalid key' }
+
+    expect(proc).to raise_error(described_class)
+  end
+end

data/spec/unit/font_data_spec.rb

@@ -7,47 +7,49 @@
 require 'spec_helper'
 
 describe Prawn::Icon::FontData do
+  let(:pdf) { create_pdf }
+  let(:fontawesome) { Prawn::Icon::FontData.new(pdf, set: :far) }
+
+  before { Prawn::Icon::FontData.release_data }
+
   describe '#initialize' do
-    it 'should update font_families on initialization' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf, set: :fa)
+    before { Prawn::Icon::FontData.new(pdf, set: :far) }
 
-      expect(pdf.font_families['fa']).not_to be_nil
+    it 'should update font_families on initialization' do
+      expect(pdf.font_families['far']).not_to be_nil
     end
   end
 
   describe '::load' do
-    it 'should only load a single object for multiple documents' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.load(pdf, 'fa')
-      obj_id_1 = data.__id__
-      data = Prawn::Icon::FontData.load(pdf, 'fa')
-      obj_id_2 = data.__id__
+    context 'specifier is a string' do
+      let(:data) { Prawn::Icon::FontData.load(pdf, 'far') }
 
-      expect(obj_id_1).to eq(obj_id_2)
-    end
+      it 'should load the font' do
+        expect(data).not_to be_nil
+      end
 
-    it 'should accept a string as a specifier' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.load(pdf, 'fa')
+      it 'should only load a single object for multiple documents' do
+        obj_id_1 = data.object_id
+        second = Prawn::Icon::FontData.load(pdf, 'far')
+        obj_id_2 = second.object_id
 
-      expect(data).not_to be_nil
+        expect(obj_id_1).to eq(obj_id_2)
+      end
     end
 
-    it 'should accept a symbol as a specifer' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.load(pdf, :fa)
+    context 'specifier is a symbol' do
+      let(:data) { Prawn::Icon::FontData.load(pdf, :far) }
 
-      expect(data).not_to be_nil
+      it 'should load the font' do
+        expect(data).not_to be_nil
+      end
     end
   end
 
   describe '::release_data' do
     it 'should remove all data references if requested' do
-      pdf = create_pdf
-      Prawn::Icon::FontData.load(pdf, :fa)
+      Prawn::Icon::FontData.load(pdf, :far)
       Prawn::Icon::FontData.load(pdf, :fi)
-      Prawn::Icon::FontData.load(pdf, :octicon)
       data = Prawn::Icon::FontData.release_data
 
       expect(data).to be_empty
@@ -56,30 +58,29 @@ describe Prawn::Icon::FontData do
 
   describe '::unicode_from_key' do
     it 'should provide a UTF-8 string for a valid key' do
-      pdf = create_pdf
-      unicode = Prawn::Icon::FontData.unicode_from_key(pdf, 'fa-arrows')
+      unicode = Prawn::Icon::FontData.unicode_from_key(pdf, 'far-address-book')
       valid = unicode.force_encoding('UTF-8').valid_encoding?
 
-      expect(valid).to be_true
+      expect(valid).to be true
     end
   end
 
   describe '::specifier_from_key' do
     it 'should provide the font specifier from a valid key' do
-      specifier = Prawn::Icon::FontData.specifier_from_key('fa-arrows')
-      expect(specifier).to eq(:fa)
+      specifier = Prawn::Icon::FontData.specifier_from_key('far-address-book')
+      expect(specifier).to eq(:far)
     end
 
     it 'should error when key is nil' do
       proc = Proc.new { Prawn::Icon::FontData.specifier_from_key nil }
 
-      expect(proc).to raise_error(Prawn::Errors::IconKeyEmpty)
+      expect(proc).to raise_error(Prawn::Icon::Errors::IconKeyEmpty)
     end
 
     it 'should error when key is an empty string' do
       proc = Proc.new { Prawn::Icon::FontData.specifier_from_key '' }
 
-      expect(proc).to raise_error(Prawn::Errors::IconKeyEmpty)
+      expect(proc).to raise_error(Prawn::Icon::Errors::IconKeyEmpty)
     end
 
     it 'should handle strings without any dashes properly' do
@@ -91,19 +92,15 @@ describe Prawn::Icon::FontData do
 
   describe '#font_version' do
     it 'should have a font version as a string' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf)
-      version = data.font_version
+      version = fontawesome.font_version
 
-      expect(version.is_a? String).to be_true
+      expect(version).to be_a(String)
     end
   end
 
   describe '#legend_path' do
     it 'should have a valid path to a yml file for legend' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf)
-      path = data.legend_path
+      path = fontawesome.legend_path
       extname = File.extname(path)
 
       expect(extname).to eq('.yml')
@@ -112,19 +109,15 @@ describe Prawn::Icon::FontData do
 
   describe '#load_fonts' do
     it 'should return a FontData object' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf)
-      ret_val = data.load_fonts(pdf)
+      ret_val = fontawesome.load_fonts(pdf)
 
-      expect(ret_val.is_a? Prawn::Icon::FontData).to be_true
+      expect(ret_val).to be_a(Prawn::Icon::FontData)
     end
   end
 
   describe '#path' do
     it 'should have a valid path to a TTF file' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf)
-      path = data.path
+      path = fontawesome.path
       extname = File.extname(path)
 
       expect(extname).to eq('.ttf')
@@ -133,68 +126,56 @@ describe Prawn::Icon::FontData do
 
   describe '#specifier' do
     it 'should retrieve the string specifier from the yaml legend file' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf, set: :fa)
-      specifier = data.specifier
+      specifier = fontawesome.specifier
 
-      expect(specifier).to eq('fa')
+      expect(specifier).to eq('far')
     end
   end
 
   describe '#unicode' do
     it 'should provide a valid UTF-8 encoded string for a valid key' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf, set: :fa)
-      unicode = data.unicode('arrows')
+      unicode = fontawesome.unicode('address-book')
       valid = unicode.force_encoding('UTF-8').valid_encoding?
 
-      expect(valid).to be_true
+      expect(valid).to be true
     end
 
     it 'should raise an error if unable to match a key' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf, set: :fa)
-      proc = Proc.new { data.unicode('an invalid sequence') }
+      proc = Proc.new { fontawesome.unicode('an invalid sequence') }
 
-      expect(proc).to raise_error(Prawn::Errors::IconNotFound)
+      expect(proc).to raise_error(Prawn::Icon::Errors::IconNotFound)
     end
   end
 
   describe '#keys' do
     it 'should return a non-empty array of strings' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf, set: :fa)
-      keys = data.keys
+      keys = fontawesome.keys
 
       expect(keys).not_to be_empty
-      expect(keys.first.is_a? String).to be_true
+      expect(keys.first).to be_a(String)
     end
 
     it 'should not contain the version as a key' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf, set: :fa)
-      keys = data.keys
+      keys = fontawesome.keys
 
-      expect(keys.include?('__font_version__')).to be_false
+      expect(keys.include?('__font_version__')).to be false
     end
   end
 
   describe '#yaml' do
     it 'should return a hash with the specifier as the first key' do
-      pdf = create_pdf
-      data = Prawn::Icon::FontData.new(pdf, set: :fa)
-      yaml = data.yaml
+      yaml = fontawesome.yaml
       key = yaml.keys.first
-      mapping = yaml['fa']
+      mapping = yaml['far']
       inner_key = mapping.keys.last
       inner_value = mapping.values.last
       proc = Proc.new { inner_value.force_encoding('UTF-8').valid_encoding? }
 
-      expect(yaml.is_a? Hash).to be_true
-      expect(key).to eq('fa')
-      expect(inner_key.is_a? String).to be_true
-      expect(inner_value.is_a? String).to be_true
-      expect(proc).to be_true
+      expect(yaml).to be_a(Hash)
+      expect(key).to eq('far')
+      expect(inner_key).to be_a(String)
+      expect(inner_value).to be_a(String)
+      expect(proc.call).to be true
     end
   end
 end