thinreports 0.10.2 → 0.12.1

data/test/unit/generator/pdf/document/graphics/test_image.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'base64'
-
-class Thinreports::Generator::PDF::Graphics::TestImage < Minitest::Test
-  include Thinreports::TestHelper
-
-  def setup
-    format = Thinreports::Layout::Format.build(self.layout_file.path)
-    @document = Thinreports::Generator::PDF::Document.new.tap { |doc|
-      doc.start_new_page(format)
-    }
-  end
-
-  def test_image
-    each_image do |image_filename|
-      @document.image(data_file(image_filename), 0, 0, 100, 100)
-      @document.image(StringIO.new(read_data_file(image_filename)), 0, 100, 100, 100)
-    end
-    assert_equal 6, analyze_pdf_images(@document.render).count
-  end
-
-  def test_base64image
-    each_image do |image_filename|
-      @document.base64image(Base64.encode64(read_data_file(image_filename)), 0, 0, 100, 100)
-    end
-    assert_equal 3, analyze_pdf_images(@document.render).count
-  end
-
-  def test_image_box
-    each_image do |image_filename|
-      @document.image_box(data_file(image_filename), 0, 0, 100, 100)
-      @document.image(StringIO.new(read_data_file(image_filename)), 0, 100, 100, 100)
-    end
-    assert_equal 6, analyze_pdf_images(@document.render).count
-  end
-
-  def each_image(&block)
-    %w(
-      image_normal.png
-      image_normal.jpg
-      image_pallete_based.png
-    ).each { |image_filename| block.call(image_filename) }
-  end
-end

data/test/unit/generator/pdf/document/graphics/test_text.rb

@@ -1,171 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Generator::PDF::Graphics::TestText < Minitest::Test
-  include Thinreports::TestHelper
-
-  def setup
-    @pdf = Thinreports::Generator::PDF::Document.new
-    @pdf.internal.start_new_page
-  end
-
-  def exec_with_font_styles(attrs = nil, font = nil, &block)
-    attrs ||= {styles: [:bold]}
-    font  ||= {name: 'IPAMincho', size: 18, color: 'ff0000'}
-
-    @pdf.send(:with_font_styles, attrs, font, &block)
-  end
-
-  def exec_with_text_styles(attrs = {}, &block)
-    default_attrs = {font: 'Helvetica',
-                     color: 'ff0000',
-                     size: 18}
-    @pdf.send(:with_text_styles, default_attrs.merge(attrs), &block)
-  end
-
-  def test_with_text_styles_should_not_operate_when_color_is_none
-    exec_with_text_styles(color: 'none') do |_attrs, _styles|
-      flunk
-    end
-  end
-
-  def test_with_text_styles_should_set_leading_via_line_height_attribute
-    exec_with_text_styles(line_height: 30) do |attrs, _styles|
-      expected = @pdf.send(:text_line_leading,
-                           @pdf.send(:s2f, 30),
-                           name: 'Helvetica', size: 18)
-      assert_equal attrs[:leading], expected
-    end
-  end
-
-  def test_with_text_styles_should_not_set_leading_when_line_height_is_not_specified
-    exec_with_text_styles do |attrs, _styles|
-      refute_includes attrs.keys, :leading
-    end
-  end
-
-  def test_with_text_styles_should_set_character_spacing_via_letter_spacing_attribute
-    exec_with_text_styles(letter_spacing: 5) do |attrs, _styles|
-      assert_equal attrs[:character_spacing], @pdf.send(:s2f, 5)
-    end
-  end
-
-  def test_with_text_styles_should_not_set_character_spacing_when_letter_spacing_is_not_specified
-    exec_with_text_styles do |attrs, _styles|
-      refute_includes attrs.keys, :character_spacing
-    end
-  end
-
-  def test_with_text_styles_should_parse_color
-    exec_with_text_styles(color: '#ff0000') do |_attrs, _styles|
-      assert_equal @pdf.internal.fill_color, 'ff0000'
-    end
-  end
-
-  def test_with_font_styles_should_set_fill_color_using_color_of_font
-    exec_with_font_styles do |_attrs, _styles|
-      assert_equal @pdf.internal.fill_color, 'ff0000'
-    end
-  end
-
-  def test_with_font_styles_should_perform_manual_style_when_bold_style_cannot_be_applied
-    exec_with_font_styles do |_attrs, styles|
-      assert_empty styles
-    end
-  end
-
-  def test_with_font_styles_should_perform_manual_style_when_italic_style_cannot_be_applied
-    exec_with_font_styles do |_attrs, styles|
-      assert_empty styles
-    end
-  end
-
-  def test_with_font_styles_should_set_stroke_color_using_color_of_font_when_bold_style_cannot_be_applied
-    exec_with_font_styles do |_attrs, _styles|
-      assert_equal @pdf.internal.stroke_color, 'ff0000'
-    end
-  end
-
-  def test_with_font_styles_should_set_line_width_calculated_from_font_size_when_bold_style_cannot_be_applied
-    exec_with_font_styles do |_attrs, _styles|
-      assert_equal @pdf.internal.line_width, 18 * 0.025
-    end
-  end
-
-  def test_with_font_styles_should_set_mode_to_fill_stroke_when_bold_style_cannot_be_applied
-    exec_with_font_styles do |attrs, _styles|
-      assert_equal attrs[:mode], :fill_stroke
-    end
-  end
-
-  def test_with_font_styles_should_not_perform_a_manual_style_when_bold_style_can_be_applied
-    exec_with_font_styles(nil, name: 'Helvetica', size: 12, color: '0000ff') do |_attrs, styles|
-      assert_includes styles, :bold
-    end
-  end
-
-  def test_with_font_styles_should_not_perform_a_manual_style_when_italic_style_can_be_applied
-    exec_with_font_styles({styles: [:italic]}, name: 'Helvetica', size: 12, color: 'ff0000') do |_attrs, styles|
-      assert_includes styles, :italic
-    end
-  end
-
-  def test_text_line_leading_should_return_a_specified_leading_value_minus_the_font_height
-    font = {name: 'IPAMincho', size: 36}
-    font_height = @pdf.internal.font(font[:name], size: font[:size]).height
-
-    assert_equal @pdf.send(:text_line_leading, 100, font), 100 - font_height
-  end
-
-  def test_text_without_line_wrap_should_replace_the_spaces_NBSP
-    assert_equal @pdf.send(:text_without_line_wrap, ' ' * 2), Prawn::Text::NBSP * 2
-  end
-
-  def test_text_box_should_not_raise_PrawnCannotFitError
-    @pdf.text_box('foo', 0, 0, 1, 1, font: 'IPAMincho',
-                                     size: 100,
-                                     color: '000000')
-  rescue Prawn::Errors::CannotFit
-    flunk('Raise Prawn::Errors::CannotFit.')
-  end
-
-  def test_text_box_attrs_should_return_a_Hash_containing_a_at_and_width_options
-    attrs = @pdf.send(:text_box_attrs, 0, 0, 50, 100)
-
-    assert_equal attrs.values_at(:at, :width),
-                 [@pdf.send(:pos, 0, 0), @pdf.send(:s2f, 50)]
-  end
-
-  def test_text_box_attrs_should_return_a_Hash_which_doesnt_contain_the_single_line_option_when_single_is_true_but_overflow_is_expand
-    attrs = @pdf.send(:text_box_attrs, 0, 0, 100, 100, single: true, overflow: :expand)
-    refute attrs.key?(:single_line)
-  end
-
-  def test_text_box_attrs_should_return_a_Hash_containing_a_single_line_option_when_single_is_true_and_overflow_isnot_expand
-    attrs = @pdf.send(:text_box_attrs, 0, 0, 100, 100, single: true, overflow: :truncate)
-    assert_equal attrs[:single_line], true
-  end
-
-  def test_text_box_attrs_should_return_a_Hash_which_does_not_contain_a_height_option_when_single_is_true
-    attrs = @pdf.send(:text_box_attrs, 0, 0, 100, 100, single: true)
-    refute attrs.key?(:height)
-  end
-
-  def test_text_box_attrs_should_return_a_Hash_which_does_not_contain_a_single_line_option_when_single_is_not_specified
-    attrs = @pdf.send(:text_box_attrs, 0, 0, 100, 100)
-    refute attrs.key?(:single_line)
-  end
-
-  def test_text_box_attrs_should_return_a_Hash_containing_a_height_optin_when_single_is_not_specified
-    attrs = @pdf.send(:text_box_attrs, 0, 0, 100, 200)
-    assert_equal attrs[:height], 200
-  end
-
-  def test_text
-    @pdf.expects(:text_box).
-      with('contents', 100, 200, 150, 250, { overflow: :shirink_to_fit }).once
-
-    @pdf.text('contents', 100, 200, 150, 250)
-  end
-end

data/test/unit/generator/pdf/document/test_font.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Generator::PDF::TestFont < Minitest::Test
-  include Thinreports::TestHelper
-
-  Font = Thinreports::Generator::PDF::Font
-
-  def teardown
-    # Reset font settings
-    Thinreports.configure do |c|
-      c.fallback_fonts = []
-    end
-  end
-
-  def test_setup_fonts
-    pdf = document.pdf
-
-    Font::BUILTIN_FONTS.each do |name, path|
-      expected_font = {
-        normal: path,
-        bold: path,
-        italic: path,
-        bold_italic: path
-      }
-      assert_equal expected_font, pdf.font_families[name]
-    end
-
-    Font::PRAWN_BUINTIN_FONT_ALIASES.each do |alias_font, original_font|
-      assert_equal pdf.font_families[alias_font],
-                   pdf.font_families[original_font]
-    end
-
-    assert_equal Font::DEFAULT_FALLBACK_FONTS, %w[IPAMincho]
-  end
-
-  def test_setup_fonts_with_custom_fallback_fonts
-    Thinreports.configure do |c|
-      c.fallback_fonts = []
-    end
-    assert_equal Font::DEFAULT_FALLBACK_FONTS,
-                 document.pdf.fallback_fonts
-
-    Thinreports.configure do |c|
-      c.fallback_fonts = 'IPAGothic'
-    end
-    assert_equal ['IPAGothic'] + Font::DEFAULT_FALLBACK_FONTS,
-                 document.pdf.fallback_fonts
-
-    Thinreports.configure do |c|
-      c.fallback_fonts = ['IPAMincho']
-    end
-    assert_equal ['IPAMincho'] + Font::DEFAULT_FALLBACK_FONTS,
-                 document.pdf.fallback_fonts
-
-    Thinreports.configure do |c|
-      c.fallback_fonts = ['IPAMincho', data_file('font.ttf')]
-    end
-    assert_equal ['IPAMincho', 'Custom-fallback-font1'] + Font::DEFAULT_FALLBACK_FONTS,
-                 document.pdf.fallback_fonts
-  end
-
-  def test_setup_fonts_with_unknown_custom_fallback_fonts
-    Thinreports.configure do |c|
-      c.fallback_fonts = ['/path/to/unknown.ttf']
-    end
-
-    assert_raises Thinreports::Errors::FontFileNotFound do
-      create_document
-    end
-  end
-
-  def test_default_family
-    assert_equal 'Helvetica', document.default_family
-  end
-
-  def test_default_family_if_mmissing
-    assert_equal 'Helvetica', document.default_family_if_missing('unknown')
-    assert_equal 'IPAMincho', document.default_family_if_missing('IPAMincho')
-  end
-
-  def test_font_has_style?
-    doc = create_document
-
-    assert_equal false, doc.font_has_style?('unknown', :bold)
-
-    doc.pdf.font_families['font_foo'] = {
-      normal: '/path/to/foo.ttf'
-    }
-    assert_equal false, doc.font_has_style?('font_foo', :italic)
-
-    doc.pdf.font_families['font_foo'] = {
-      normal: '/path/to/foo.ttf',
-      bold: '/path/to/foo.ttf'
-    }
-    assert_equal false, doc.font_has_style?('font_foo', :bold)
-
-    doc.pdf.font_families['font_foo'] = {
-      normal: '/path/to/foo.ttf',
-      bold: '/path/to/foo_bold.ttf'
-    }
-    assert_equal true, doc.font_has_style?('font_foo', :bold)
-  end
-
-  def document
-    Thinreports::Generator::PDF::Document.new
-  end
-  alias_method :create_document, :document
-end

data/test/unit/generator/pdf/document/test_graphics.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Generator::PDF::TestGraphics < Minitest::Test
-  include Thinreports::TestHelper
-
-  class TestGraphics
-    attr_accessor :pdf
-    include Thinreports::Generator::PDF::Graphics
-  end
-
-  def setup
-    @g = TestGraphics.new
-    @g.pdf = mock('pdf')
-  end
-
-  def test_setup_custom_graphic_states
-    @g.pdf.expects(:line_width).
-      with(TestGraphics::BASE_LINE_WIDTH).once
-
-    @g.send(:setup_custom_graphic_states)
-  end
-
-  def test_line_width
-    @g.pdf.
-      expects(:line_width).
-      with(10 * TestGraphics::BASE_LINE_WIDTH).once
-
-    @g.send(:line_width, 10)
-  end
-
-  def test_save_graphics_state
-    @g.pdf.expects(:save_graphics_state).once
-    @g.send(:save_graphics_state)
-  end
-
-  def test_restore_graphics_state
-    @g.pdf.expects(:restore_graphics_state).once
-    @g.send(:restore_graphics_state)
-  end
-end

data/test/unit/generator/pdf/document/test_page.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Generator::PDF::Document::TestPage < Minitest::Test
-  include Thinreports::TestHelper
-
-  def create_pdf
-    @pdf = Thinreports::Generator::PDF::Document.new
-  end
-
-  def test_JIS_page_size
-    sizes = Thinreports::Generator::PDF::Document::JIS_SIZES
-    assert_equal sizes['B4'], [728.5, 1031.8]
-    assert_equal sizes['B5'], [515.9, 728.5]
-  end
-
-  def test_B4_paper_size_should_returns_size_as_B4_JIS
-    create_pdf
-
-    format = Thinreports::Layout::Format.build(layout_file.path)
-    format.stubs(page_paper_type: 'B4')
-
-    @pdf.start_new_page(format)
-    assert_equal @pdf.internal.page.size, [728.5, 1031.8]
-  end
-
-  def test_B4_ISO_paper_size_should_be_converted_to_B4
-    create_pdf
-
-    format = Thinreports::Layout::Format.build(layout_file.path)
-    format.stubs(page_paper_type: 'B4_ISO')
-
-    @pdf.start_new_page(format)
-    assert_equal @pdf.internal.page.size, 'B4'
-  end
-
-  def test_change_page_format_should_return_true_at_first_time
-    create_pdf
-    format = Thinreports::Layout::Format.build(layout_file.path)
-
-    assert_equal @pdf.send(:change_page_format?, format), true
-  end
-
-  def test_change_page_format_should_return_false_when_given_the_same_format
-    create_pdf
-    format = Thinreports::Layout::Format.build(layout_file.path)
-
-    @pdf.instance_variable_set(:@current_page_format, format)
-    assert_equal @pdf.send(:change_page_format?, format), false
-  end
-
-  def test_change_page_format_should_return_true_when_given_the_other_format
-    create_pdf
-    format1 = Thinreports::Layout::Format.build(layout_file.path)
-    format2 = Thinreports::Layout::Format.build(layout_file.path)
-
-    @pdf.instance_variable_set(:@current_page_format, format1)
-    assert_equal @pdf.send(:change_page_format?, format2), true
-  end
-
-  def test_new_basic_page_options
-    format = Thinreports::Layout::Format.build(layout_file.path)
-    options = create_pdf.send(:new_basic_page_options, format)
-
-    assert_equal options[:layout], format.page_orientation.to_sym
-    assert_equal options[:size], format.page_paper_type
-  end
-
-  def test_new_basic_page_options_when_the_layout_has_customize_size
-    format = stub user_paper_type?: true,
-                  page_width: 100,
-                  page_height: 100,
-                  page_orientation: 'portrait'
-
-    options = create_pdf.send(:new_basic_page_options, format)
-    assert_equal options[:size], [100, 100]
-  end
-
-  def test_start_new_page_should_create_stamp
-    create_pdf
-    format = Thinreports::Layout::Format.build(layout_file.path)
-    @pdf.start_new_page(format)
-
-    assert_includes @pdf.send(:format_stamp_registry), format.identifier
-  end
-
-  def test_start_new_page_should_not_create_stamp
-    create_pdf
-    format = Thinreports::Layout::Format.build(layout_file.path)
-    @pdf.start_new_page(format)
-    @pdf.start_new_page(format)
-
-    assert_equal @pdf.send(:format_stamp_registry).size, 1
-  end
-
-  def test_start_new_page_should_stamp_constantly
-    create_pdf
-    format = Thinreports::Layout::Format.build(layout_file.path)
-    @pdf.expects(:stamp).with(format.identifier.to_s).times(2)
-
-    @pdf.start_new_page(format)
-    @pdf.start_new_page(format)
-  end
-
-  def test_add_blank_page_should_create_an_A4_size_page_in_first_page
-    create_pdf
-    @pdf.internal.expects(:start_new_page).with(size: 'A4').once
-
-    @pdf.add_blank_page
-  end
-
-  def test_add_blank_page_should_call_with_no_arguments_since_second_page
-    create_pdf
-    format = Thinreports::Layout::Format.build(layout_file.path)
-
-    @pdf.start_new_page(format)
-    @pdf.internal.expects(:start_new_page).with({}).once
-
-    @pdf.add_blank_page
-  end
-end

data/test/unit/generator/pdf/document/test_parse_color.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Generator::PDF::TestParseColor < Minitest::Test
-  include Thinreports::TestHelper
-
-  class TestColorParser
-    include Thinreports::Generator::PDF::ParseColor
-  end
-
-  def setup
-    @parser = TestColorParser.new
-  end
-
-  def test_parse_color_with_hexcolor
-    assert_equal @parser.parse_color('#ff0000'), 'ff0000'
-    assert_equal @parser.parse_color('000000'), '000000'
-  end
-
-  def test_parse_color_with_colorname
-    assert_equal @parser.parse_color('red'), 'ff0000'
-  end
-
-  def test_parse_color_with_colorname_raise_when_unknown_name_given
-    assert_raises Thinreports::Errors::UnsupportedColorName do
-      @parser.parse_color('whitesmoke')
-    end
-  end
-end

data/test/unit/generator/pdf/prawn_ext/test_calc_image_dimensions.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Generator::PrawnExt::TestCalcImageDimensions < Minitest::Test
-  class Klass
-    prepend Thinreports::Generator::PrawnExt::CalcImageDimensions
-
-    def calc_image_dimensions(options)
-      options
-    end
-  end
-
-  def setup
-    @klass = Klass.new
-  end
-
-  def test_calc_image_dimensions
-    res_options = @klass.calc_image_dimensions(
-      auto_fit: [100, 200],
-      width: 101,
-      height: 199
-    )
-    assert_equal [100, 200], res_options[:fit]
-    refute_includes res_options.keys, :auto_fit
-
-    res_options = @klass.calc_image_dimensions(
-      auto_fit: [100, 200],
-      width: 99,
-      height: 201
-    )
-    assert_equal [100, 200], res_options[:fit]
-
-    res_options = @klass.calc_image_dimensions(
-      auto_fit: [100, 200],
-      width: 99,
-      height: 199
-    )
-    refute_includes res_options.keys, :fit
-  end
-end

data/test/unit/generator/pdf/prawn_ext/test_width_of.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Generator::PrawnExt::TestWidthOf < Minitest::Test
-  def setup
-    @pdf = Prawn::Document.new
-  end
-
-  def test_width_of
-    text_width = @pdf.width_of('abcd')
-
-    @pdf.character_spacing(1) do
-      expected_character_space_width = 1 * 3
-      assert_equal text_width + expected_character_space_width, @pdf.width_of('abcd')
-    end
-
-    @pdf.character_spacing(1) do
-      assert_equal 0, @pdf.width_of('')
-    end
-  end
-end

data/test/unit/generator/pdf/test_document.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Generator::PDF::TestDocument < Minitest::Test
-  include Thinreports::TestHelper
-
-  # Alias
-  Document = Thinreports::Generator::PDF::Document
-
-  def test_new
-    pdf = Document.new
-    assert_equal pdf.internal.page_count, 0
-    assert_equal pdf.internal.page.margins.values, [0, 0, 0, 0]
-
-    pdf = Document.new(security: { owner_password: 'abc' })
-    assert_equal true, pdf.internal.state.encrypt
-
-    pdf = Document.new(title: 'Title')
-    assert_equal 'Title', pdf.internal.state.store.info.data[:Title]
-  end
-end

data/test/unit/generator/test_pdf.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Generator::TestPDF < Minitest::Test
-  include Thinreports::TestHelper
-
-  PDF = Thinreports::Generator::PDF
-
-  def test_default_layout
-    layout_filename = layout_file.path
-    report = Thinreports::Report.new layout: layout_filename
-
-    generator = PDF.new report
-    assert_equal layout_filename, generator.default_layout.filename
-  end
-
-  def test_initialize
-    report = Thinreports::Report.new layout: layout_file.path
-    report.start_new_page
-
-    PDF.new(report)
-
-    assert_equal true, report.finalized?
-  end
-end

data/test/unit/layout/test_base.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class Thinreports::Layout::TestBase < Minitest::Test
-  include Thinreports::TestHelper
-
-  Layout = Thinreports::Layout
-
-  def test_load_format
-    assert_instance_of Layout::Format, Layout::Base.load_format(layout_file.path)
-    assert_raises Thinreports::Errors::LayoutFileNotFound do
-      Layout::Base.load_format 'unknown.tlf'
-    end
-  end
-
-  def test_new
-    layout_filename = layout_file.path
-    layout = Layout::Base.new(layout_filename)
-
-    assert_nil layout.id
-    assert_equal layout_filename, layout.filename
-    assert_instance_of Layout::Format, layout.format
-  end
-
-  def test_id
-    layout_without_id = Layout::Base.new(layout_file.path)
-    assert_nil layout_without_id.id
-
-    layout_with_id = Layout::Base.new(layout_file.path, id: 'foo')
-    assert_equal 'foo', layout_with_id.id
-  end
-
-  def test_default?
-    layout_without_id = Layout::Base.new(layout_file.path)
-    assert_equal true, layout_without_id.default?
-
-    layout_with_id = Layout::Base.new(layout_file.path, id: 'bar')
-    assert_equal false, layout_with_id.default?
-  end
-end