thinreports 0.7.6 → 0.8.0

data/test/unit/core/shape/text_block/test_internal.rb

@@ -1,15 +1,15 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::TextBlock::TestInternal < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::TextBlock::TestInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  TextBlock = ThinReports::Core::Shape::TextBlock
-  
+  TextBlock = Thinreports::Core::Shape::TextBlock
+
   def create_parent
-    report = create_basic_report('basic_layout1.tlf')
+    report = new_report('layout_text1.tlf')
     report.start_new_page do |page|
       # Add to force TextBlock shape.
       page.manager.format.shapes[:foo] = TextBlock::Format.new('type' => 's-tblock',
@@ -18,111 +18,111 @@ class ThinReports::Core::Shape::TextBlock::TestInternal < MiniTest::Unit::TestCa
       page.item(:foo).value('foo value')
     end
   end
-  
+
   def create_internal(format_config = {})
     TextBlock::Internal.new(create_parent, TextBlock::Format.new(format_config))
   end
-  
+
   def test_multiple_asker_should_operate_as_delegator_of_format
     tblock = create_internal('multiple' => 'true')
     assert_equal tblock.multiple?, tblock.format.multiple?
   end
-  
+
   def test_style_should_return_the_instance_of_Style_Text
-    assert_instance_of ThinReports::Core::Shape::Style::Text, create_internal.style
+    assert_instance_of Thinreports::Core::Shape::Style::Text, create_internal.style
   end
-  
+
   def test_read_value_should_return_the_format_value_as_default
     tblock = create_internal('value' => 'default value')
     assert_equal tblock.read_value, 'default value'
   end
-  
+
   def test_read_value_should_return_the_value_of_referenced_shape
     tblock = create_internal('ref-id' => 'foo')
     assert_equal tblock.read_value, 'foo value'
   end
-  
+
   def test_read_value_should_return_the_value_stored_in_states
     tblock = create_internal
     tblock.states[:value] = 'value in states'
-    
+
     assert_equal tblock.read_value, 'value in states'
   end
-  
+
   def test_write_value_should_properly_set_the_specified_value_to_states
     tblock = create_internal
     tblock.write_value(1000)
-    
+
     assert_equal tblock.states[:value], 1000
   end
-  
+
   def test_write_value_should_show_warnings_when_tblock_has_reference
     tblock = create_internal('id' => 'bar', 'ref-id' => 'foo')
     out, err = capture_io do
       tblock.write_value('value')
     end
     assert_equal err.chomp, 'The set value was not saved, ' +
-                            "Because 'bar' refers to 'foo'."
+                            "Because 'bar' has reference to 'foo'."
   end
-  
+
   def test_real_value_should_return_the_formatted_value_when_tblock_has_any_format
     tblock = create_internal('format' => {'type'     => 'datetime',
                                           'datetime' => {'format' => '%Y/%m/%d'}})
     tblock.write_value(value = Time.now)
-    
+
     assert_equal tblock.real_value, value.strftime('%Y/%m/%d')
   end
-  
+
   def test_real_value_should_return_the_raw_value_when_tblock_has_no_format
     tblock = create_internal
     tblock.write_value('any value')
-    
+
     assert_equal tblock.real_value, 'any value'
   end
-  
+
   def test_format_enabled_should_properly_set_value_to_states_as_format_enabled
     tblock = create_internal
     tblock.format_enabled(false)
-    
+
     assert_equal tblock.states[:format_enabled], false
   end
-  
+
   def test_format_enabled_asker_should_return_true_when_format_has_any_type
     tblock = create_internal('format' => {'type' => 'datetime'})
-    
+
     assert_equal tblock.format_enabled?, true
   end
-  
+
   def test_format_enabled_asker_should_return_true_when_base_of_format_has_any_value
     tblock = create_internal('format' => {'base' => '{value}'})
-    
+
     assert_equal tblock.format_enabled?, true
   end
-  
+
   def test_format_enabled_asker_should_return_false_when_format_has_no_type_and_base_has_not_value
     assert_equal create_internal.format_enabled?, false
   end
-  
+
   def test_format_enabled_asker_should_return_false_constantly_when_tblock_is_multiple_mode
-    tblock = create_internal('multiple' => 'true', 
+    tblock = create_internal('multiple' => 'true',
                              'format'   => {'base' => '{value}',
                                             'type' => 'number'})
     tblock.format_enabled(true)
-    
+
     assert_equal tblock.format_enabled?, false
   end
-  
+
   def test_type_of_asker_should_return_true_when_value_is_tblock
     assert_equal create_internal.type_of?(:tblock), true
   end
-  
+
   def test_type_of_asker_should_return_true_when_value_is_block
     assert_equal create_internal.type_of?(:block), true
   end
-  
+
   def test_formatter_should_return_instance_of_FormatterBasic_when_format_is_enable
     tblock = create_internal('format' => {'type' => 'datetime'})
-    
+
     assert_kind_of TextBlock::Formatter::Basic, tblock.send(:formatter)
   end
-end
+end

data/test/unit/core/test_events.rb

@@ -1,12 +1,12 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::TestEvents < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::TestEvents < Minitest::Test
+  include Thinreports::TestHelper
   
   # Alias
-  Events = ThinReports::Core::Events
+  Events = Thinreports::Core::Events
   
   def setup
     @events = Events.new(:load, :change, :blur)
@@ -33,7 +33,7 @@ class ThinReports::Core::TestEvents < MiniTest::Unit::TestCase
   end
   
   def test_listen_raise_error_when_unknown_event_type_is_set
-    assert_raises ThinReports::Errors::UnknownEventType do
+    assert_raises Thinreports::Errors::UnknownEventType do
       @events.listen(:unknown) {|e| e.type }
     end
   end
@@ -77,12 +77,14 @@ class ThinReports::Core::TestEvents < MiniTest::Unit::TestCase
   end
   
   def test_copy
-    @events.on(:change) {|e| e.type }
-    @events.on(:load) {|e| e.type }
+    @events.on(:change) { :on_change }
+    @events.on(:load) { :on_load }
     
     copied = @events.copy
     
-    assert_equal @events.events, copied.events
+    assert @events.events.all? {|k,f|
+      copied.events[k].call == f.call
+    }
     refute_same  @events.events, copied.events
     
     @events.unlisten(:change)

data/test/unit/core/test_shape.rb

@@ -1,13 +1,17 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::TestShape < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::TestShape < Minitest::Test
+  include Thinreports::TestHelper
   
   # Alias
-  ShapeModule = ThinReports::Core::Shape
+  ShapeModule = Thinreports::Core::Shape
   
+  def test_find_by_type_should_return_PageNumber
+    assert_same ShapeModule.find_by_type('s-pageno'), ShapeModule::PageNumber
+  end
+
   def test_find_by_type_should_return_ImageBlock
     assert_same ShapeModule.find_by_type('s-iblock'), ShapeModule::ImageBlock
   end
@@ -41,7 +45,7 @@ class ThinReports::Core::TestShape < MiniTest::Unit::TestCase
   end
   
   def test_find_by_type_should_raise
-    assert_raises ThinReports::Errors::UnknownShapeType do
+    assert_raises Thinreports::Errors::UnknownShapeType do
       ShapeModule.find_by_type('unknown')
     end
   end
@@ -53,8 +57,8 @@ class ThinReports::Core::TestShape < MiniTest::Unit::TestCase
   
   def test_Configuration_should_raise
     # When shape don't have a Configuration
-    assert_raises ThinReports::Errors::NoConfigurationFound do
+    assert_raises Thinreports::Errors::NoConfigurationFound do
       ShapeModule::Configuration('s-line')
     end
   end
-end
+end

data/test/unit/core/test_utils.rb

@@ -0,0 +1,68 @@
+# coding: utf-8
+
+require 'test_helper'
+
+class Thinreports::Core::TestShape < Minitest::Test
+  include Thinreports::TestHelper
+  include Thinreports::Utils
+
+  def test_call_block_in
+    expected = '123'
+    assert_same expected, call_block_in(expected)
+
+    assert_equal '321', call_block_in('123', &proc { reverse! })
+    assert_equal [1, 2, 3], call_block_in([2, 1, 3], &proc { |a| a.sort! })
+  end
+
+  def test_deep_copy_in_unsupported_object
+    [123, nil, Struct.new(:foo).new].each do |unsupported_value|
+      assert_raises ArgumentError do
+        deep_copy(unsupported_value)
+      end
+    end
+  end
+
+  def test_deep_copy_in_Array
+    src = ['string', Time.now]
+    dup = deep_copy(src)
+
+    refute_same dup, src
+
+    src.each_with_index do |e, i|
+      assert_equal dup[i], e
+      refute_same dup[i], e
+    end
+  end
+
+  def test_deep_copy_in_Hash
+    src = { a: 'string', b: Time.now }
+    dup = deep_copy(src)
+
+    refute_same dup, src
+
+    src.each do |k, v|
+      assert_equal dup[k], v
+      refute_same dup[k], v
+    end
+  end
+
+  def test_blank_value_in_String
+    ["", ''].each do |val|
+      assert_equal true, blank_value?(val)
+    end
+
+    [' ', '　', 'abc', 'あいう'].each do |val|
+      assert_equal false, blank_value?(val)
+    end
+  end
+
+  def test_blank_value_in_NilClass
+    assert_equal true, blank_value?(nil)
+  end
+
+  def test_blank_value_in_other_classes
+    [0, 1, -1, 9.99, true, false, Time.now].each do |val|
+      assert_equal false, blank_value?(val)
+    end
+  end
+end

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

@@ -1,12 +1,12 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Generator::PDF::Graphics::TestAttributes < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Generator::PDF::Graphics::TestAttributes < Minitest::Test
+  include Thinreports::TestHelper
   
   def setup
-    @pdf = ThinReports::Generator::PDF::Document.new
+    @pdf = Thinreports::Generator::PDF::Document.new
   end
   
   def test_common_graphic_attrs_should_return_converted_Hash_as_attributes
@@ -56,6 +56,12 @@ class ThinReports::Generator::PDF::Graphics::TestAttributes < MiniTest::Unit::Te
     assert_equal valigns.map {|a| @pdf.text_valign(a) },
                  [:top, :center, :bottom, :top]
   end
+
+  def test_text_word_wrap
+    assert_equal @pdf.text_word_wrap('break-word'), :break_word
+    assert_equal @pdf.text_word_wrap('none'), :none
+    assert_equal @pdf.text_word_wrap(''), :none
+  end
   
   def test_extract_base64_string
     base64 = 'data:image/png;base64,iVBORw0KGg1+/AAy/plYlzil'

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

@@ -1,164 +1,171 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Generator::PDF::Graphics::TestText < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Generator::PDF::Graphics::TestText < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   def setup
-    @pdf = ThinReports::Generator::PDF::Document.new
+    @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'}
-    
+    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}
+    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|
+    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|
+    exec_with_text_styles(line_height: 30) do |attrs, styles|
       expected = @pdf.send(:text_line_leading,
                            @pdf.send(:s2f, 30),
-                           :name => 'Helvetica', :size => 18)
+                           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|
+    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|
+    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|
+    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|
+    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
-    
+    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')
+    @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)
+    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)
+    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)
+    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_draw_shape.rb

@@ -1,17 +1,20 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Generator::PDF::TestDrawShape < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Generator::PDF::TestDrawShape < Minitest::Test
+  include Thinreports::TestHelper
 
   def setup
-    @pdf = ThinReports::Generator::PDF::Document.new
+    @pdf = Thinreports::Generator::PDF::Document.new
   end
 
   def create_tblock_interface(format_config = {})
-    format = ThinReports::Core::Shape::TextBlock::Format.new(format_config)
-    ThinReports::Core::Shape::TextBlock::Interface.new(flexmock('parent'), format)
+    report = new_report 'layout_text1'
+    parent = report.start_new_page
+
+    format = Thinreports::Core::Shape::TextBlock::Format.new format_config
+    Thinreports::Core::Shape::TextBlock::Interface.new parent, format
   end
 
   def test_shape_text_attrs_should_return_attrs_containing_an_overflow_property
@@ -33,4 +36,9 @@ class ThinReports::Generator::PDF::TestDrawShape < MiniTest::Unit::TestCase
     tblock = create_tblock_interface('id' => 'text', 'line-height' => '')
     assert_nil @pdf.send(:shape_text_attrs, tblock.internal)[:line_height]
   end
+
+  def test_shape_text_attrs
+    tblock = create_tblock_interface('id' => 'text', 'word-wrap' => 'none')
+    assert_includes @pdf.send(:shape_text_attrs, tblock.internal).keys, :word_wrap
+  end
 end