thinreports 0.6.0.pre3 → 0.7.0

data/test/unit/core/shape/{tblock → text_block}/formatter/test_basic.rb

@@ -2,11 +2,11 @@
 
 require 'test/unit/helper'
 
-class ThinReports::Core::Shape::Tblock::Formatter::TestBasic < MiniTest::Unit::TestCase
+class ThinReports::Core::Shape::TextBlock::Formatter::TestBasic < MiniTest::Unit::TestCase
   include ThinReports::TestHelpers
   
   # Alias
-  Formatter = ThinReports::Core::Shape::Tblock::Formatter::Basic
+  Formatter = ThinReports::Core::Shape::TextBlock::Formatter::Basic
   
   def test_apply_simple_format
     format = flexmock(:format_base => 'Hello {value}!')

data/test/unit/core/shape/{tblock → text_block}/formatter/test_datetime.rb

@@ -2,11 +2,11 @@
 
 require 'test/unit/helper'
 
-class ThinReports::Core::Shape::Tblock::Formatter::TestDatetime < MiniTest::Unit::TestCase
+class ThinReports::Core::Shape::TextBlock::Formatter::TestDatetime < MiniTest::Unit::TestCase
   include ThinReports::TestHelpers
   
   # Alias
-  Formatter = ThinReports::Core::Shape::Tblock::Formatter::Datetime
+  Formatter = ThinReports::Core::Shape::TextBlock::Formatter::Datetime
   
   def setup
     @datetime_format = '%Y/%m/%d %H:%M:%S'

data/test/unit/core/shape/{tblock → text_block}/formatter/test_number.rb

@@ -2,11 +2,11 @@
 
 require 'test/unit/helper'
 
-class ThinReports::Core::Shape::Tblock::Formatter::TestNumber < MiniTest::Unit::TestCase
+class ThinReports::Core::Shape::TextBlock::Formatter::TestNumber < MiniTest::Unit::TestCase
   include ThinReports::TestHelpers
   
   # Alias
-  Formatter = ThinReports::Core::Shape::Tblock::Formatter::Number
+  Formatter = ThinReports::Core::Shape::TextBlock::Formatter::Number
   
   def init_formatter(expect_formats)
     format = flexmock({:format_base => '',

data/test/unit/core/shape/{tblock → text_block}/formatter/test_padding.rb

@@ -2,11 +2,11 @@
 
 require 'test/unit/helper'
 
-class ThinReports::Core::Shape::Tblock::Formatter::TestPadding < MiniTest::Unit::TestCase
+class ThinReports::Core::Shape::TextBlock::Formatter::TestPadding < MiniTest::Unit::TestCase
   include ThinReports::TestHelpers
   
   # Alias
-  Formatter = ThinReports::Core::Shape::Tblock::Formatter::Padding
+  Formatter = ThinReports::Core::Shape::TextBlock::Formatter::Padding
   
   def init_formatter(expect_formats)
     format = flexmock({:format_base           => nil,
@@ -16,17 +16,22 @@ class ThinReports::Core::Shape::Tblock::Formatter::TestPadding < MiniTest::Unit:
     Formatter.new(format)
   end
   
-  def test_apply_padding_formats
+  def test_apply_padding_formats_with_left_direction
     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')
     
-    # Text length is longer than the specified length.
     assert_equal formatter.apply('1234567'), '1234567'
-    
-    # When direction is right
+  end
+  
+  def test_apply_padding_formats_with_right_direction
     formatter = init_formatter(:format_padding_length => 5,
                                :format_padding_char   => '0',
                                :format_padding_rdir?  => true)

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

@@ -0,0 +1,160 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+
+  TEST_TBLOCK_FORMAT = {
+    "type" => "s-tblock",
+    "id" => "block_1", 
+    "display" => "true", 
+    "multiple" => "false",
+    "box" => {
+      "x" => 100.0,
+      "y" => 100.0,
+      "width" => 100.0,
+      "height" => 100.0
+    },
+    "format" => {
+      "base" => "￥{value}", 
+      "type" => "number", 
+      "number" => {
+        "delimiter" => ",", 
+        "precision" => 1
+      }
+    }, 
+    "value" => "", 
+    "ref-id" => "", 
+    "svg" => {
+      "tag" => "text", 
+      "attrs" => {
+        "x" => 200.1, 
+        "y" => 65.6, 
+        "text-anchor" => "end", 
+        "xml:space" => "preserve", 
+        "fill" => "#000000", 
+        "fill-opacity" => "1", 
+        "font-size" => "12", 
+        "font-family" => "\uFF2D\uFF33 \u30B4\u30B7\u30C3\u30AF", 
+        "font-weight" => "bold", 
+        "font-style" => "normal", 
+        "text-decoration" => "none", 
+        "clip-path" => "url(#_svgdef_0)"
+      }
+    }
+  }
+
+  def test_build
+    build_format
+  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_ref_id_reader_via_TEST_TBLOCK_FORMAT
+    assert_equal format(TEST_TBLOCK_FORMAT).ref_id, ''
+  end
+  
+  def test_format_base_reader_via_TEST_TBLOCK_FORMAT
+    assert_equal format(TEST_TBLOCK_FORMAT).format_base, '￥{value}'
+  end
+  
+  def test_format_type_reader_via_TEST_TBLOCK_FORMAT
+    assert_equal format(TEST_TBLOCK_FORMAT).format_type, 'number'
+  end
+  
+  def test_box_reader_via_TEST_TBLOCK_FORMAT
+    assert_equal format(TEST_TBLOCK_FORMAT).box.values_at('x', 'y', 'width', 'height'),
+                 [100.0, 100.0, 100.0, 100.0]
+  end
+  
+  def test_format_datetime_format_reader_via_TEST_TBLOCK_FORMAT
+    assert_nil format(TEST_TBLOCK_FORMAT).format_datetime_format
+  end
+  
+  def test_format_padding_char_reader_via_TEST_TBLOCK_FORMAT
+    assert_nil format(TEST_TBLOCK_FORMAT).format_padding_char
+  end
+  
+  def test_format_padding_dir_reader_via_TEST_TBLOCK_FORMAT
+    assert_nil format(TEST_TBLOCK_FORMAT).format_padding_dir
+  end
+  
+  def test_format_padding_length_via_TEST_TBLOCK_FORMAT
+    assert_equal format(TEST_TBLOCK_FORMAT).format_padding_length, 0
+  end
+  
+  def test_format_padding_rdir_checker_via_TEST_TBLOCK_FORMAT
+    assert_equal format(TEST_TBLOCK_FORMAT).format_padding_rdir?, false
+  end
+  
+  def test_format_has_format_asker_via_TEST_TBLOCK_FORMAT
+    assert_equal format(TEST_TBLOCK_FORMAT).has_format?, true
+  end
+  
+  def test_format_has_reference_asker_via_TEST_TBLOCK_FORMAT
+    assert_equal format(TEST_TBLOCK_FORMAT).has_reference?, false
+  end
+  
+  def test_format_multiple_checker_via_TEST_TBLOCK_FORMAT
+    assert_equal format(TEST_TBLOCK_FORMAT).multiple?, false
+  end
+  
+  def test_multiple_checker_should_return_true
+    assert format('multiple' => 'true').multiple?
+  end
+  
+  def test_multiple_checker_should_return_false
+    refute format('multiple' => 'false').multiple?
+  end
+  
+  def test_format_padding_rdir_checker_should_return_false
+    data = {'format' => {'padding' => {'direction' => 'L'}}}
+    refute format(data).format_padding_rdir?
+  end
+  
+  def test_format_padding_rdir_checker_should_return_true
+    data = {'format' => {'padding' => {'direction' => 'R'}}}
+    assert format(data).format_padding_rdir?
+  end
+  
+  def test_format_padding_length_should_return_Numeric
+    data = {'format' => {'padding' => {'length' => '999'}}}
+    assert_kind_of ::Numeric, format(data).format_padding_length
+  end
+  
+  def test_has_format_asker_should_return_false_with_empty_value
+    data = {'format' => {'type' => ''}}
+    refute format(data).has_format?
+  end
+  
+  def test_has_format_asker_should_return_false_with_unknown_type
+    data = {'format' => {'type' => 'unknown'}}
+    refute format(data).has_format?
+  end
+  
+  def test_has_format_asker_should_return_true
+    data = {'format' => {'type' => 'number'}}
+    assert format(data).has_format?
+  end
+  
+  def test_has_reference_asker_should_return_false
+    refute format('ref-id' => '').has_reference?
+  end
+  
+  def test_has_reference_asker_should_return_true
+    assert format('ref-id' => 'ref_tblock_1').has_reference?
+  end
+  
+  def build_format
+    ThinReports::Core::Shape::TextBlock::Format.build(TEST_TBLOCK_FORMAT)
+  end
+  
+  def format(data)
+    ThinReports::Core::Shape::TextBlock::Format.new(data)
+  end
+end

data/test/unit/core/shape/{tblock → text_block}/test_formatter.rb

@@ -2,11 +2,11 @@
 
 require 'test/unit/helper'
 
-class ThinReports::Core::Shape::Tblock::TestFormatter < MiniTest::Unit::TestCase
+class ThinReports::Core::Shape::TextBlock::TestFormatter < MiniTest::Unit::TestCase
   include ThinReports::TestHelpers
   
   # Alias
-  Formatter = ThinReports::Core::Shape::Tblock::Formatter
+  Formatter = ThinReports::Core::Shape::TextBlock::Formatter
   
   def test_initialize_formatter_by_type
     assert_instance_of Formatter::Basic,

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

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::TextBlock::TestInterface < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  TextBlock = ThinReports::Core::Shape::TextBlock
+  
+  def create_interface(format_config = {})
+    TextBlock::Interface.new(flexmock('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)
+    
+    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)
+    
+    assert_equal [tblock.style(:color),
+                  tblock.style(:bold),
+                  tblock.style(:italic)],
+                 ['#ff0000', true, true]
+  end
+end

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

@@ -0,0 +1,128 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::TextBlock::TestInternal < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  TextBlock = ThinReports::Core::Shape::TextBlock
+  
+  def create_parent
+    report = create_basic_report('basic_layout1.tlf')
+    report.start_new_page do |page|
+      # Add to force TextBlock shape.
+      page.manager.format.shapes[:foo] = TextBlock::Format.new('type' => 's-tblock',
+                                                               'id'   => 'foo')
+      # Set value to TextBlock.
+      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
+  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'."
+  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', 
+                             '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

data/test/unit/core/test_shape.rb

@@ -8,25 +8,50 @@ class ThinReports::Core::TestShape < MiniTest::Unit::TestCase
   # Alias
   ShapeModule = ThinReports::Core::Shape
   
-  def test_find_by_type
-    assert_same ShapeModule.find_by_type('s-tblock'), ShapeModule::Tblock
+  def test_find_by_type_should_return_ImageBlock
+    assert_same ShapeModule.find_by_type('s-iblock'), ShapeModule::ImageBlock
+  end
+  
+  def test_find_by_type_should_return_TextBlock
+    assert_same ShapeModule.find_by_type('s-tblock'), ShapeModule::TextBlock
+  end
+  
+  def test_find_by_type_should_return_List
     assert_same ShapeModule.find_by_type('s-list'), ShapeModule::List
+  end
+  
+  def test_find_by_type_should_return_Text
     assert_same ShapeModule.find_by_type('s-text'), ShapeModule::Text
-
+  end
+  
+  def test_find_by_type_should_return_Basic_as_Image
     assert_same ShapeModule.find_by_type('s-image'), ShapeModule::Basic
+  end
+  
+  def test_find_by_type_should_return_Basic_as_Line
     assert_same ShapeModule.find_by_type('s-line'), ShapeModule::Basic
+  end
+  
+  def test_find_by_type_should_return_Basic_as_Rect
     assert_same ShapeModule.find_by_type('s-rect'), ShapeModule::Basic
+  end
+  
+  def test_find_by_type_should_return_Basic_as_Ellipse
     assert_same ShapeModule.find_by_type('s-ellipse'), ShapeModule::Basic
-    
+  end
+  
+  def test_find_by_type_should_raise
     assert_raises ThinReports::Errors::UnknownShapeType do
       ShapeModule.find_by_type('unknown')
     end
   end
   
-  def test_Configuration
+  def test_Configuration_should_return_Configuration_of_List
     assert_same ShapeModule::Configuration('s-list'),
                 ShapeModule::List::Configuration
-
+  end
+  
+  def test_Configuration_should_raise
     # When shape don't have a Configuration
     assert_raises ThinReports::Errors::NoConfigurationFound do
       ShapeModule::Configuration('s-line')