prawn-icon 0.5.0

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+#
+# Copyright October 2014, Jesse Doyle. All rights reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require "bundler"
+Bundler.setup
+
+require "prawn"
+require "prawn/icon"
+require 'pdf/inspector'
+require "rspec"
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/extensions/ and its subdirectories.
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.include PDFHelper
+  config.include ParserHelper
+end

data/spec/support/parser_helper.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+#
+# Copyright October 2014, Jesse Doyle. All rights reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module ParserHelper
+  def tokenize_string(string)
+    regex = Prawn::Icon::Parser::PARSER_REGEX
+    string.scan(regex)
+  end
+
+  def contentize_string(string)
+    regex = Prawn::Icon::Parser::CONTENT_REGEX
+    string.scan(regex).flatten
+  end
+end

data/spec/support/pdf_helper.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+#
+# Copyright October 2014, Jesse Doyle. All rights reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+module PDFHelper
+  def create_pdf
+    Prawn::Document.new(margin: 0)
+  end
+
+  def valid_unicode?(string)
+    string.force_encoding('UTF-8').valid_encoding?
+  end
+end

data/spec/unit/font_data_spec.rb

@@ -0,0 +1,190 @@
+# encoding: utf-8
+#
+# Copyright October 2014, Jesse Doyle. All rights reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'spec_helper'
+
+describe Prawn::Icon::FontData do
+  describe '#initialize' do
+    it 'should update font_families on initialization' do
+      pdf = create_pdf
+      data = Prawn::Icon::FontData.new(pdf, set: :fa)
+
+      expect(pdf.font_families['fa']).not_to be_nil
+    end
+  end
+
+  describe '::load' do
+    it 'should cache font data on a document basis' 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__
+
+      expect(obj_id_1).to eq(obj_id_2)
+    end
+
+    it 'should accept a string as a specifier' do
+      pdf = create_pdf
+      data = Prawn::Icon::FontData.load(pdf, 'fa')
+
+      expect(data).not_to be_nil
+    end
+
+    it 'should accept a symbol as a specifer' do
+      pdf = create_pdf
+      data = Prawn::Icon::FontData.load(pdf, :fa)
+
+      expect(data).not_to be_nil
+    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, :fi)
+      Prawn::Icon::FontData.load(pdf, :octicon)
+      data = Prawn::Icon::FontData.release_data
+
+      expect(data).to be_empty
+    end
+  end
+
+  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')
+      valid = unicode.force_encoding('UTF-8').valid_encoding?
+
+      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)
+    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)
+    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)
+    end
+
+    it 'should handle strings without any dashes properly' do
+      specifier = Prawn::Icon::FontData.specifier_from_key 'foo'
+
+      expect(specifier).to eq(:foo)
+    end
+  end
+
+  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
+
+      expect(version.is_a? String).to be_true
+    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
+      extname = File.extname(path)
+
+      expect(extname).to eq('.yml')
+    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
+      extname = File.extname(path)
+
+      expect(extname).to eq('.ttf')
+    end
+  end
+
+  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
+
+      expect(specifier).to eq('fa')
+    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')
+      valid = unicode.force_encoding('UTF-8').valid_encoding?
+
+      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') }
+
+      expect(proc).to raise_error(Prawn::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
+
+      expect(keys).not_to be_empty
+      expect(keys.first.is_a? String).to be_true
+    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
+
+      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
+      key = yaml.keys.first
+      mapping = yaml['fa']
+      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
+    end
+  end
+end

data/spec/unit/icon_spec.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+#
+# Copyright October 2014, Jesse Doyle. All rights reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'spec_helper'
+
+describe Prawn::Icon do
+  describe '#initialize' do
+    context 'valid icon family specifier' do
+      it 'should be capable of creating icon instances' do
+        pdf = create_pdf
+        icon = Prawn::Icon.new 'fa-arrows', pdf
+
+        expect(icon.unicode).to eq("\uf047")
+      end
+
+      it 'should raise an error if icon key is not found' do
+        pdf = create_pdf
+        proc = Proc.new { Prawn::Icon.new 'fa-__INVALID__', pdf }
+
+        expect(proc).to raise_error(Prawn::Errors::IconNotFound)
+      end
+    end
+
+    context 'invalid icon specifier' do
+      it 'should raise an error' do
+        pdf = create_pdf
+        proc = Proc.new { pdf.icon '__INVALID__  some text' }
+
+        expect(proc).to raise_error(Prawn::Errors::UnknownFont)
+      end
+    end
+
+    context 'without a pdf object' do
+      it 'should raise an ArgumentError' do
+        proc = Proc.new { Prawn::Icon.new('fa-arrows') }
+
+        expect(proc).to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe '#render' do
+    it 'should render an icon to the page' do
+      pdf = create_pdf
+      pdf.icon('fa-arrows').render
+      text = PDF::Inspector::Text.analyze(pdf.render)
+
+      expect(text.font_settings.first[:name]).to match(/FontAwesome/)
+    end
+  end
+
+  describe '#set' do
+    context 'with dashes in key' do
+      it 'should return the set as a symbol from key' do
+        pdf = create_pdf
+        set = Prawn::Icon.new('fa-arrows', pdf).set
+
+        expect(set).to eq(:fa)
+      end
+    end
+
+    context 'without dashes in key' do
+      it 'raise an error about invalid keys' do
+        pdf = create_pdf
+        proc = Proc.new { Prawn::Icon.new 'some invalid key', pdf }
+
+        expect(proc).to raise_error(Prawn::Errors::UnknownFont)
+      end
+    end
+  end
+
+  describe '#unicode' do
+    context 'valid icon key' do
+      it 'should return a unicode character' do
+        pdf = create_pdf
+        icon = Prawn::Icon.new 'fa-arrows', pdf
+
+        expect(valid_unicode?(icon.unicode)).to be_true
+      end
+    end
+
+    context 'invalid icon key' do
+      it 'should raise IconNotFound' do
+        pdf = create_pdf
+        proc = Proc.new { Prawn::Icon.new 'fa-__INVALID__', pdf }
+
+        expect(proc).to raise_error(Prawn::Errors::IconNotFound)
+      end
+    end
+  end
+end

data/spec/unit/parser_spec.rb

@@ -0,0 +1,190 @@
+# encoding: utf-8
+#
+# Copyright October 2014, Jesse Doyle. All rights reserved.
+#
+# This is free software. Please see the LICENSE and COPYING files for details.
+
+require 'spec_helper'
+
+describe Prawn::Icon::Parser do
+  describe '::format' do
+    it 'should return a raw prawn-formatted string on valid input' do
+      string = '<icon>fa-arrows</icon>'
+      pdf = create_pdf
+      formatted = Prawn::Icon::Parser.format(pdf, string)
+      match = "<font name=\"fa\"></font>"
+
+      expect(formatted).to eq(match)
+    end
+
+    it 'should return unchanged if no icon tags are found' do
+      string = <<-EOS
+      <link href="#">test</link>
+      Here's some sample text.
+      <i>more text</i>
+      EOS
+      pdf = create_pdf
+      formatted = Prawn::Icon::Parser.format(pdf, string)
+
+      expect(formatted).to eq(string)
+    end
+
+    it 'should return the empty string if given the empty string' do
+      string = ''
+      pdf = create_pdf
+      formatted = Prawn::Icon::Parser.format(pdf, string)
+
+      expect(formatted).to be_empty
+    end
+
+    it 'should raise an error when an icon key is invalid' do
+      string = '<icon>an invalid key</icon>'
+      pdf = create_pdf
+      proc = Proc.new { Prawn::Icon::Parser.format(pdf, string) }
+
+      expect(proc).to raise_error(Prawn::Errors::UnknownFont)
+    end
+
+    it 'should raise an error when an icon is not found for valid set' do
+      string = '<icon>fa-__INVALID__</icon>'
+      pdf = create_pdf
+      proc = Proc.new { Prawn::Icon::Parser.format(pdf, string) }
+
+      expect(proc).to raise_error(Prawn::Errors::IconNotFound)
+    end
+  end
+
+  describe '::config_from_tokens' do
+    it 'should return an array containing only an empty hash' do
+      string = '<icon>fa-arrows</icon>'
+      tokens = tokenize_string(string)
+      config = Prawn::Icon::Parser.config_from_tokens(tokens)
+      inner = config.first
+
+      expect(config.size).to eq(1)
+      expect(inner).to be_empty
+    end
+
+    it 'should return an array containing a signle hash of attrs' do
+      string = '<icon size="12" color="CCCCCC">fa-arrows</icon>'
+      tokens = tokenize_string(string)
+      config = Prawn::Icon::Parser.config_from_tokens(tokens)
+      inner = config.first
+
+      expect(config.size).to eq(1)
+      expect(inner[:size]).to eq(12.0)
+      expect(inner[:color]).to eq('CCCCCC')
+    end
+
+    it 'should return an array containing as many hashes as icons' do
+      string = <<-EOS
+      <icon>fa-arrows</icon>
+      <icon>fa-arrows</icon>
+      <icon>fa-arrows</icon>
+      EOS
+      tokens = tokenize_string(string)
+      config = Prawn::Icon::Parser.config_from_tokens(tokens)
+
+      expect(config.size).to eq(3)
+    end
+  end
+
+  describe '::keys_to_unicode' do
+    it 'should return an empty array for empty input' do
+      string = ''
+      config = []
+      content = contentize_string(string)
+      pdf = create_pdf
+      icons = Prawn::Icon::Parser.keys_to_unicode(pdf, content, config)
+
+      expect(icons).to be_empty
+    end
+
+    it 'should return an array with unicode content' do
+      string = '<icon>fa-arrows</icon>'
+      tokens = tokenize_string(string)
+      content = contentize_string(string)
+      config = Prawn::Icon::Parser.config_from_tokens(tokens)
+      pdf = create_pdf
+      icons = Prawn::Icon::Parser.keys_to_unicode(pdf, content, config)
+      icon = icons.first[:content]
+
+      expect(valid_unicode?(icon)).to be_true
+    end
+
+    it 'should return a single array containing attr hash of defaults' do
+      # Hash must contain :set and :content by default
+      string = '<icon>fa-arrows</icon>'
+      tokens = tokenize_string(string)
+      content = contentize_string(string)
+      config = Prawn::Icon::Parser.config_from_tokens(tokens)
+      pdf = create_pdf
+      icons = Prawn::Icon::Parser.keys_to_unicode(pdf, content, config)
+      icon = icons.first
+
+      expect(icon[:set]).to eq(:fa)
+      expect(icon[:content]).not_to be_empty
+    end
+
+    it 'should handle strings with multiple icons/attrs combinations' do
+      string = <<-EOS
+      <icon size="20">fa-arrows</icon>
+      some filler text
+      <icon>fa-arrows</icon>
+      <icon size="8" color="0099FF">fa-arrows</icon>
+      EOS
+      tokens = tokenize_string(string)
+      content = contentize_string(string)
+      config = Prawn::Icon::Parser.config_from_tokens(tokens)
+      pdf = create_pdf
+      icons = Prawn::Icon::Parser.keys_to_unicode(pdf, content, config)
+      first = icons.first
+      second = icons[1]
+      third = icons[2]
+
+      expect(icons.size).to eq(3)
+      expect(first[:size]).to eq(20.0)
+      expect(second[:size]).to be_nil
+      expect(third[:size]).to eq(8.0)
+      expect(third[:color]).to eq('0099FF')
+    end
+  end
+
+  describe '::icon_tags' do
+    it 'should return valid input as prawn formatted text tags wrapping color tags' do
+      icons = [
+        { set: :fa, color: 'CCCCCC', content: "\uf001" }
+      ]
+      tags = Prawn::Icon::Parser.icon_tags(icons)
+      match = "<font name=\"fa\"><color rgb=\"CCCCCC\">\uf001</color></font>"
+
+      expect(tags.size).to eq(1)
+      expect(tags.first).to eq(match)
+    end
+
+    it 'should return valid input as prawn formatted text tags without color' do
+      icons = [
+        { set: :fa, content: "\uf001" }
+      ]
+      tags = Prawn::Icon::Parser.icon_tags(icons)
+      match = "<font name=\"fa\">\uf001</font>"
+
+      expect(tags.size).to eq(1)
+      expect(tags.first).to eq(match)
+    end
+
+    it 'should be capable of handling multiple icon fonts' do
+      icons = [
+        { set: :fa, content: "\uf001" },
+        { set: :fi, content: "\uf001" }
+      ]
+      tags = Prawn::Icon::Parser.icon_tags(icons)
+      match1 = "<font name=\"fa\">\uf001</font>"
+      match2 = "<font name=\"fi\">\uf001</font>"
+
+      expect(tags.size).to eq(2)
+      expect(tags[0]).to eq(match1)
+      expect(tags[1]).to eq(match2)
+    end
+  end
+end