thinreports 0.7.6 → 0.8.0

data/test/unit/core/shape/text_block/formatter/test_basic.rb

@@ -1,24 +1,24 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::TextBlock::Formatter::TestBasic < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::TextBlock::Formatter::TestBasic < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Formatter = ThinReports::Core::Shape::TextBlock::Formatter::Basic
-  
+  Formatter = Thinreports::Core::Shape::TextBlock::Formatter::Basic
+
   def test_apply_simple_format
-    format = flexmock(:format_base => 'Hello {value}!')
-    
-    assert_equal Formatter.new(format).apply('ThinReports'),
-                 'Hello ThinReports!'
+    format = stub(format_base: 'Hello {value}!')
+
+    assert_equal Formatter.new(format).apply('Thinreports'),
+                 'Hello Thinreports!'
   end
-  
+
   def test_apply_multiple_format
-    format = flexmock(:format_base => 'Hello {value}! And good bye {value}.')
-    
-    assert_equal Formatter.new(format).apply('ThinReports'),
-                 'Hello ThinReports! And good bye ThinReports.'
+    format = stub(format_base: 'Hello {value}! And good bye {value}.')
+
+    assert_equal Formatter.new(format).apply('Thinreports'),
+                 'Hello Thinreports! And good bye Thinreports.'
   end
-end
+end

data/test/unit/core/shape/text_block/formatter/test_datetime.rb

@@ -1,47 +1,49 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::TextBlock::Formatter::TestDatetime < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::TextBlock::Formatter::TestDatetime < Minitest::Test
+  include Thinreports::TestHelper
   
-  # Alias
-  Formatter = ThinReports::Core::Shape::TextBlock::Formatter::Datetime
+  # Aliases
+  TextBlock = Thinreports::Core::Shape::TextBlock
+  Formatter = TextBlock::Formatter::Datetime
   
   def setup
     @datetime_format = '%Y/%m/%d %H:%M:%S'
-    @time            = Time.now
-
-    @format = flexmock(:format_base => '', 
-                       :format_datetime_format => @datetime_format)
+    @time = Time.now
   end
   
+  def text_block_format(format = {})
+    default = {'base' => '', 'datetime' => {'format' => '%Y/%m/%d %H:%M:%S'}}
+    TextBlock::Format.new('format' => default.merge(format))
+  end
+
   def test_apply_datetime_format_without_basic_format
-    formatter = Formatter.new(@format)
+    formatter = Formatter.new(text_block_format)
     
-    assert_equal formatter.apply(@time), @time.strftime(@datetime_format)
+    assert_equal @time.strftime(@datetime_format), 
+                 formatter.apply(@time)
   end
   
   def test_apply_datetime_format_with_basic_format
-    # Partial mock
-    format = flexmock(@format, :format_base => 'Now: {value}')
-    
-    formatter = Formatter.new(format)
+    formatter = Formatter.new(text_block_format('base' => 'Now: {value}'))
     
-    assert_equal formatter.apply(@time),
-                 "Now: #{@time.strftime(@datetime_format)}"
+    assert_equal "Now: #{@time.strftime(@datetime_format)}", 
+                 formatter.apply(@time)
+                 
   end
   
   def test_not_apply_datetime_format_and_return_raw_value
     # When value is invalid
-    formatter = Formatter.new(@format)
+    formatter = Formatter.new(text_block_format)
     
     assert_same formatter.apply(val = 'invalid value'), val
     assert_same formatter.apply(val = 123456), val
     
     # When format is empty
-    format = flexmock(@format, :format_datetime_format => '')
+    formatter = Formatter.new(text_block_format('datetime' => {'format' => ''}))
     
     assert_same formatter.apply(@time), @time
   end
-end
+end

data/test/unit/core/shape/text_block/formatter/test_number.rb

@@ -1,24 +1,24 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::TextBlock::Formatter::TestNumber < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::TextBlock::Formatter::TestNumber < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Formatter = ThinReports::Core::Shape::TextBlock::Formatter::Number
-  
+  Formatter = Thinreports::Core::Shape::TextBlock::Formatter::Number
+
   def init_formatter(expect_formats)
-    format = flexmock({:format_base => '',
-                       :format_number_precision => nil,
-                       :format_number_delimiter => nil}.merge(expect_formats))
+    format = stub({ format_base: '',
+                    format_number_precision: nil,
+                    format_number_delimiter: nil }.merge(expect_formats))
     Formatter.new(format)
   end
-  
+
   def test_apply_precision_formats
     # When precision is 2
-    formatter = init_formatter(:format_number_precision => 2)
-    
+    formatter = init_formatter(format_number_precision: 2)
+
     assert_equal formatter.apply(1.005), '1.01'
     assert_equal formatter.apply(1.004), '1.00'
     assert_equal formatter.apply(1), '1.00'
@@ -28,49 +28,49 @@ class ThinReports::Core::Shape::TextBlock::Formatter::TestNumber < MiniTest::Uni
     assert_equal formatter.apply('9'), '9.00'
     # Cannot apply, Return the raw value
     assert_equal formatter.apply('invalid value'), 'invalid value'
-    
+
     # When precision is 0
-    formatter = init_formatter(:format_number_precision => 0)
-    
+    formatter = init_formatter(format_number_precision: 0)
+
     assert_equal formatter.apply(1.5), '2'
   end
-  
+
   def test_apply_precision_format_with_basic_format
-    formatter = init_formatter(:format_base => '$ {value}',
-                               :format_number_precision => 0)
-    
+    formatter = init_formatter(format_base: '$ {value}',
+                               format_number_precision: 0)
+
     assert_equal formatter.apply(199.5), '$ 200'
   end
-  
+
   def test_apply_delimiter_formats
     # When delimiter is ','
-    formatter = init_formatter(:format_number_delimiter => ',')
-    
+    formatter = init_formatter(format_number_delimiter: ',')
+
     assert_equal formatter.apply(1000000), '1,000,000'
     assert_equal formatter.apply(-1000000), '-1,000,000'
     assert_equal formatter.apply('1000.0'), '1,000.0'
     assert_equal formatter.apply('-1000.0'), '-1,000.0'
     # Cannot apply, Return the raw value
     assert_equal formatter.apply('invalid value'), 'invalid value'
-    
+
     # When delimiter is whitespace
-    formatter = init_formatter(:format_number_delimiter => ' ')
-    
+    formatter = init_formatter(format_number_delimiter: ' ')
+
     assert_equal formatter.apply(99999), '99 999'
   end
-  
+
   def test_apply_delimiter_format_with_basic_format
-    formatter = init_formatter(:format_base => '￥{value}',
-                               :format_number_delimiter => ',')
-    
+    formatter = init_formatter(format_base: '￥{value}',
+                               format_number_delimiter: ',')
+
     assert_equal formatter.apply(199800), '￥199,800'
   end
-  
+
   def test_apply_all_format
-    formatter = init_formatter(:format_base => '-- {value} --',
-                               :format_number_delimiter => ',',
-                               :format_number_precision => 2)
+    formatter = init_formatter(format_base: '-- {value} --',
+                               format_number_delimiter: ',',
+                               format_number_precision: 2)
 
     assert_equal formatter.apply(95618.88567), '-- 95,618.89 --'
   end
-end
+end

data/test/unit/core/shape/text_block/formatter/test_padding.rb

@@ -1,77 +1,77 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::TextBlock::Formatter::TestPadding < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::TextBlock::Formatter::TestPadding < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Formatter = ThinReports::Core::Shape::TextBlock::Formatter::Padding
-  
+  Formatter = Thinreports::Core::Shape::TextBlock::Formatter::Padding
+
   def init_formatter(expect_formats)
-    format = flexmock({:format_base           => nil,
-                       :format_padding_length => 0,
-                       :format_padding_char   => nil,
-                       :format_padding_rdir?  => false}.merge(expect_formats))
+    format = stub({ format_base: nil,
+                    format_padding_length: 0,
+                    format_padding_char: nil,
+                    format_padding_rdir?: false }.merge(expect_formats))
     Formatter.new(format)
   end
-  
+
   def test_apply_padding_formats_with_left_direction
-    formatter = init_formatter(:format_padding_length => 5,
-                               :format_padding_char   => '0')
-    
+    formatter = init_formatter(format_padding_length: 5,
+                               format_padding_char: '0')
+
     assert_equal formatter.apply(1), '00001'
     assert_equal formatter.apply('日本語'), '00日本語'
   end
-  
+
   def test_apply_padding_formats_should_not_apply_when_character_length_is_short
-    formatter = init_formatter(:format_padding_length => 5,
-                               :format_padding_char   => '0')
-    
+    formatter = init_formatter(format_padding_length: 5,
+                               format_padding_char: '0')
+
     assert_equal formatter.apply('1234567'), '1234567'
   end
-  
+
   def test_apply_padding_formats_with_right_direction
-    formatter = init_formatter(:format_padding_length => 5,
-                               :format_padding_char   => '0',
+    formatter = init_formatter(format_padding_length: 5,
+                               format_padding_char: '0',
                                :format_padding_rdir?  => true)
-    
+
     assert_equal formatter.apply(123), '12300'
   end
-  
+
   def test_apply_padding_format_with_basic_format
-    formatter = init_formatter(:format_base           => '[{value}]',
-                               :format_padding_length => 10,
-                               :format_padding_char   => ' ')
+    formatter = init_formatter(format_base: '[{value}]',
+                               format_padding_length: 10,
+                               format_padding_char: ' ')
 
     assert_equal formatter.apply('ABC'), '[       ABC]'
   end
-  
+
   def test_return_raw_value_when_length_is_0
-    formatter = init_formatter(:format_padding_length => 0,
-                               :format_padding_char   => '0')
-    
+    formatter = init_formatter(format_padding_length: 0,
+                               format_padding_char: '0')
+
     assert_same formatter.apply(v = 123), v
-    
+
     # But apply only basic format if have basic-format.
-    formatter = init_formatter(:format_base           => '<{value}>',
-                               :format_padding_length => 0,
-                               :format_padding_char   => '0')
-    
+    formatter = init_formatter(format_base: '<{value}>',
+                               format_padding_length: 0,
+                               format_padding_char: '0')
+
     assert_equal formatter.apply(123), '<123>'
   end
-  
+
   def test_return_raw_value_when_char_is_empty
-    formatter = init_formatter(:format_padding_length => 10,
-                               :format_padding_char   => '')
-    
+    formatter = init_formatter(format_padding_length: 10,
+                               format_padding_char: '')
+
     assert_same formatter.apply(v = '1'), v
 
     # But apply only basic format if have basic-format.
-    formatter = init_formatter(:format_base           => '<{value}>',
-                               :format_padding_length => 0,
-                               :format_padding_char   => '0')
-    
+    formatter = init_formatter(format_base: '<{value}>',
+                               format_padding_length: 0,
+                               format_padding_char: '0')
+
     assert_equal formatter.apply('1'), '<1>'
   end
-end
+end

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

@@ -1,9 +1,9 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::TextBlock::TestFormat < Minitest::Test
+  include Thinreports::TestHelper
 
   TEST_TBLOCK_FORMAT = {
     "type" => "s-tblock",
@@ -11,6 +11,7 @@ class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
     "display" => "true", 
     "multiple" => "false",
     "overflow" => "truncate",
+    "word-wrap" => "break-word",
     "box" => {
       "x" => 100.0,
       "y" => 100.0,
@@ -24,7 +25,7 @@ class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
         "delimiter" => ",", 
         "precision" => 1
       }
-    }, 
+    },
     "value" => "", 
     "ref-id" => "", 
     "svg" => {
@@ -37,7 +38,7 @@ class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
         "fill" => "#000000", 
         "fill-opacity" => "1", 
         "font-size" => "12", 
-        "font-family" => "\uFF2D\uFF33 \u30B4\u30B7\u30C3\u30AF", 
+        "font-family" => "Helvetica", 
         "font-weight" => "bold", 
         "font-style" => "normal", 
         "text-decoration" => "none", 
@@ -51,10 +52,14 @@ class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
   rescue => e
     flunk exception_details(e, 'Building failed.')
   end
-  
+
   def test_value_reader_via_TEST_TBLOCK_FORMAT
     assert_equal format(TEST_TBLOCK_FORMAT).value, ''
   end
+
+  def test_word_wrap_reader_via_TEST_TBLOCK_FORMAT
+    assert_equal format(TEST_TBLOCK_FORMAT).word_wrap, 'break-word'
+  end
   
   def test_ref_id_reader_via_TEST_TBLOCK_FORMAT
     assert_equal format(TEST_TBLOCK_FORMAT).ref_id, ''
@@ -156,10 +161,10 @@ class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
   end
   
   def build_format
-    ThinReports::Core::Shape::TextBlock::Format.build(TEST_TBLOCK_FORMAT)
+    Thinreports::Core::Shape::TextBlock::Format.build(TEST_TBLOCK_FORMAT)
   end
   
   def format(data)
-    ThinReports::Core::Shape::TextBlock::Format.new(data)
+    Thinreports::Core::Shape::TextBlock::Format.new(data)
   end
 end

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

@@ -1,28 +1,28 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::TextBlock::TestFormatter < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::TextBlock::TestFormatter < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Formatter = ThinReports::Core::Shape::TextBlock::Formatter
-  
+  Formatter = Thinreports::Core::Shape::TextBlock::Formatter
+
   def test_initialize_formatter_by_type
     assert_instance_of Formatter::Basic,
-      Formatter.setup( flexmock(:format_type => '') )
-    
+      Formatter.setup( stub(format_type: '') )
+
     assert_instance_of Formatter::Number,
-      Formatter.setup( flexmock(:format_type => 'number') )
-      
+      Formatter.setup( stub(format_type: 'number') )
+
     assert_instance_of Formatter::Datetime,
-      Formatter.setup( flexmock(:format_type => 'datetime') )
-    
+      Formatter.setup( stub(format_type: 'datetime') )
+
     assert_instance_of Formatter::Padding,
-      Formatter.setup( flexmock(:format_type => 'padding') )
-      
-    assert_raises ThinReports::Errors::UnknownFormatterType do
-      Formatter.setup( flexmock(:format_type => 'unknown') )
+      Formatter.setup( stub(format_type: 'padding') )
+
+    assert_raises Thinreports::Errors::UnknownFormatterType do
+      Formatter.setup( stub(format_type: 'unknown') )
     end
   end
-end
+end

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

@@ -1,46 +1,63 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::TextBlock::TestInterface < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::TextBlock::TestInterface < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  TextBlock = ThinReports::Core::Shape::TextBlock
-  
+  TextBlock = Thinreports::Core::Shape::TextBlock
+
   def create_interface(format_config = {})
-    TextBlock::Interface.new(flexmock('parent'),
-                             TextBlock::Format.new(format_config))
+    report = new_report 'layout_text1'
+    parent = report.start_new_page
+
+    TextBlock::Interface.new parent, TextBlock::Format.new(format_config)
   end
-  
+
   def test_format_enabled_asker_should_operate_as_delegator_of_internal
     tblock = create_interface('format' => {'type' => 'datetime'})
     assert_equal tblock.format_enabled?, tblock.internal.format_enabled?
   end
-  
+
   def test_format_enabled_should_properly_set_value_to_internal
     tblock = create_interface('format' => {'type' => 'number'})
     tblock.format_enabled(false)
-    
+
     assert_equal tblock.internal.format_enabled?, false
   end
-  
+
   def test_set_should_properly_set_a_value
     tblock = create_interface
-    tblock.set(1000, :visible => false)
-    
+    tblock.set(1000, visible: false)
+
     assert_equal tblock.value, 1000
   end
-  
+
   def test_set_should_properly_set_styles
     tblock = create_interface
-    tblock.set(1000, :color  => '#ff0000',
-                     :bold   => true,
-                     :italic => true)
-    
+    tblock.set(1000, color: '#ff0000',
+                     bold: true,
+                     italic: true)
+
     assert_equal [tblock.style(:color),
                   tblock.style(:bold),
                   tblock.style(:italic)],
                  ['#ff0000', true, true]
   end
-end
+
+  def test_value=
+    report = new_report 'layout_block.tlf'
+    page = report.start_new_page
+
+    page.item(:text_block1).value = 'foo'
+    assert_equal 'foo', page.item(:text_block1).value
+
+    page.item(:text_block1).value += 'bar'
+    assert_equal 'foobar', page.item(:text_block1).value
+
+    page.item(:text_block1).value = 1000
+    page.item(:text_block1).value += 999
+    assert_equal 1999, page.item(:text_block1).value
+  end
+end