thinreports 0.8.2 → 0.9.0

data/test/unit/core/shape/manager/test_target.rb

@@ -28,51 +28,42 @@ class Thinreports::Core::Shape::Manager::TestTarget < Minitest::Test
   end
 
   def create_manager
-    report = new_report('layout_text1.tlf')
+    report = Thinreports::Report.new layout: layout_file.path
     layout = report.layout
 
-    layout.format.shapes[:text_block1] = create_shape_format('s-tblock', 'text_block1')
-    layout.format.shapes[:text_block2] = create_shape_format('s-tblock', 'text_block2')
-    layout.format.shapes[:image_block] = create_shape_format('s-iblock', 'image_block')
-    layout.format.shapes[:rectangle] = create_shape_format('s-rect', 'rectangle')
-    layout.format.shapes[:line] = create_shape_format('s-line', 'line')
-    layout.format.shapes[:list1] = create_shape_format('s-list', 'list1')
-    layout.format.shapes[:list2] = create_shape_format('s-list', 'list2')
-    layout.format.shapes[:default] = create_shape_format('s-list', 'default')
-
     TestManager.new(report, layout)
   end
 
   def test_shorthand_for_finding_item
     manager = create_manager
 
-    text_block1 = manager[:text_block1]
+    text_block1 = manager[:text_block]
     text_block1.value = 'block1'
 
-    assert_instance_of Shape::TextBlock::Interface, manager[:text_block1]
+    assert_instance_of Shape::TextBlock::Interface, manager[:text_block]
     assert_instance_of Shape::ImageBlock::Interface, manager[:image_block]
-    assert_instance_of Shape::Basic::Interface, manager[:rectangle]
+    assert_instance_of Shape::Basic::Interface, manager[:rect_with_id]
 
     assert_raises Thinreports::Errors::UnknownItemId do
       manager[:unknown_id]
     end
 
     assert_raises Thinreports::Errors::UnknownItemId do
-      manager[:list1]
+      manager[:default]
     end
   end
 
   def test_shorthand_for_setting_value_to_block
     manager = create_manager
 
-    manager[:text_block1] = 'value of text block1'
-    assert_equal 'value of text block1', manager.item(:text_block1).value
+    manager[:text_block] = 'value of text block1'
+    assert_equal 'value of text block1', manager.item(:text_block).value
 
     manager[:image_block] = '/path/to/image.png'
     assert_equal '/path/to/image.png', manager.item(:image_block).src
 
-    assert_raises(NoMethodError) { manager[:rectangle] = 'value' }
-    assert_raises(Thinreports::Errors::UnknownItemId) { manager[:list1] = 'value' }
+    assert_raises(NoMethodError) { manager[:rect_with_id] = 'value' }
+    assert_raises(Thinreports::Errors::UnknownItemId) { manager[:default] = 'value' }
   end
 
   def test_manager_should_return_instance_of_ManagerInternal
@@ -80,11 +71,11 @@ class Thinreports::Core::Shape::Manager::TestTarget < Minitest::Test
   end
 
   def test_item_should_properly_return_shape_with_the_specified_Symbol_id
-    assert_equal create_manager.item(:text_block1).id, 'text_block1'
+    assert_equal create_manager.item(:text_block).id, 'text_block'
   end
 
   def test_item_should_properly_return_shape_with_the_specified_String_id
-    assert_equal create_manager.item('text_block2').id, 'text_block2'
+    assert_equal create_manager.item('text_block').id, 'text_block'
   end
 
   def test_item_should_raise_when_the_shape_with_the_specified_id_is_not_found
@@ -95,27 +86,27 @@ class Thinreports::Core::Shape::Manager::TestTarget < Minitest::Test
 
   def test_item_should_set_an_shape_as_argument_when_a_block_is_given
     id = nil
-    create_manager.item(:text_block1) {|s| id = s.id }
-    assert_equal id, 'text_block1'
+    create_manager.item(:text_block) {|s| id = s.id }
+    assert_equal id, 'text_block'
   end
 
   def test_item_should_raise_when_type_of_shape_with_the_specified_id_is_list
     assert_raises Thinreports::Errors::UnknownItemId do
-      create_manager.item(:list1)
+      create_manager.item(:default)
     end
   end
 
   def test_list_should_properly_return_list_with_the_specified_Symbol_id
-    assert_equal create_manager.list(:list1).id, 'list1'
+    assert_equal create_manager.list(:default).id, 'default'
   end
 
   def test_list_should_properly_return_list_with_the_specified_String_id
-    assert_equal create_manager.list('list1').id, 'list1'
+    assert_equal create_manager.list('default').id, 'default'
   end
 
   def test_list_should_raise_when_type_of_shape_with_the_specified_id_is_not_list
     assert_raises Thinreports::Errors::UnknownItemId do
-      create_manager.list(:text_block1)
+      create_manager.list(:text_block)
     end
   end
 
@@ -125,17 +116,17 @@ class Thinreports::Core::Shape::Manager::TestTarget < Minitest::Test
 
   def test_values_should_properly_set_values_to_shapes_with_specified_id
     manager = create_manager
-    manager.values(text_block1: 1000, 'text_block2' => 'value')
+    manager.values(text_block: 1000)
 
-    assert_equal [manager.item(:text_block1).value, manager.item(:text_block2).value], [1000, 'value']
+    assert_equal manager.item(:text_block).value, 1000
   end
 
   def test_item_exists_asker_should_return_true_when_shape_with_specified_Symbol_id_is_found
-    assert_equal create_manager.item_exists?(:text_block1), true
+    assert_equal create_manager.item_exists?(:text_block), true
   end
 
   def test_item_exists_asker_should_return_true_when_shape_with_specified_String_id_is_found
-    assert_equal create_manager.item_exists?('text_block2'), true
+    assert_equal create_manager.item_exists?('text_block'), true
   end
 
   def test_item_exists_asker_should_return_false_when_shape_with_specified_id_not_found

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

@@ -5,69 +5,51 @@ require 'test_helper'
 class Thinreports::Core::Shape::PageNumber::TestFormat < Minitest::Test
   include Thinreports::TestHelper
 
-  TEST_PAGENO_FORMAT = {
-    "type" => "s-pageno", 
-    "id" => "", 
-    "display" => "true", 
-    "box" => {
-      "x" => 100.0, 
-      "y" => 100.0, 
-      "width" => 100.0, 
-      "height" => 100.0
-    },
-    "format" => "{page} / {total}",
-    "overflow" => "truncate", 
-    "target" => "",
-    "svg" => {
-      "tag" => "text",
-      "attrs" => {
-        "x" => 308.2,
-        "y" => 239,
-        "kerning" => "auto",
-        "id" => "goog_939685354",
-        "fill" => "#000000",
-        "fill-opacity" => "1",
-        "font-size" => "18",
-        "font-family" => "Helvetica",
-        "font-weight" => "normal",
-        "font-style" => "normal",
-        "text-anchor" => "middle",
-        "text-decoration" => "none"
-      }
+  PAGE_NUMBER_FORMAT = {
+    'id' => '',
+    'type' => 'page-number',
+    'display' => true,
+    'x' => 100.0,
+    'y' => 200.0,
+    'width' => 300.0,
+    'height' => 400.0,
+    'format' => '{page} / {total}',
+    'target' => '',
+    'style' => {
+      'overflow' => 'truncate',
+      'letter-spacing' => 'normal',
+      'color' => '#000000',
+      'font-size' => 18,
+      'font-family' => ['Helvetica'],
+      'line-height' => 60,
+      'line-height-ratio' => 1.5,
+      'text-align' => 'left'
     }
   }
 
-  Format = Thinreports::Core::Shape::PageNumber::Format
+  PageNumber = Thinreports::Core::Shape::PageNumber
 
-  def format(raw_format = nil)
-    Format.new(raw_format || TEST_PAGENO_FORMAT)
-  end
+  def test_attribute_readers
+    format = PageNumber::Format.new(PAGE_NUMBER_FORMAT)
 
-  def test_build
-    Format.build(TEST_PAGENO_FORMAT)
-  rescue => e
-    flunk exception_details(e, 'Failed to build')
+    assert_equal 'truncate', format.overflow
+    assert_equal '', format.target
+    assert_equal '{page} / {total}', format.default_format
   end
 
   def test_id
-    pageno = format('id' => 'pageno_id')
-    assert_equal pageno.id, 'pageno_id'
-
-    pageno = format('id' => '')
-    assert_equal pageno.id, '__pageno1'
-    assert_same pageno.id, pageno.id
-  end
+    format = PageNumber::Format.new(PAGE_NUMBER_FORMAT)
+    assert_match(/^__pageno\d+$/, format.id)
 
-  def test_overflow
-    assert_equal format.overflow, 'truncate'
+    format = PageNumber::Format.new(PAGE_NUMBER_FORMAT.merge('id' => 'foo'))
+    assert_equal 'foo', format.id
   end
 
-  def test_target
-    assert_equal format.target, ''
-    assert_equal format("target" => "list-id").target, 'list-id'
-  end
+  def test_for_report?
+    format_for_report = PageNumber::Format.new(PAGE_NUMBER_FORMAT)
+    assert_equal true, format_for_report.for_report?
 
-  def test_default_format
-    assert_equal format.default_format, '{page} / {total}'
+    format_for_list = PageNumber::Format.new(PAGE_NUMBER_FORMAT.merge('target' => 'target_list_id'))
+    assert_equal false, format_for_list.for_report?
   end
 end

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

@@ -8,7 +8,7 @@ class Thinreports::Core::Shape::PageNumber::TestInterface < Minitest::Test
   PageNumber = Thinreports::Core::Shape::PageNumber
 
   def create_pageno(format = {})
-    report = new_report 'layout_text1'
+    report = Thinreports::Report.new layout: layout_file.path
     parent = report.start_new_page
 
     PageNumber::Interface.new parent, PageNumber::Format.new(format)

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

@@ -8,7 +8,7 @@ class Thinreports::Core::Shape::PageNumber::TestInternal < Minitest::Test
   PageNumber = Thinreports::Core::Shape::PageNumber
 
   def setup
-    @report = new_report('layout_text1.tlf')
+    @report = Thinreports::Report.new layout: layout_file.path
     @report.start_new_page
   end
 
@@ -56,7 +56,7 @@ class Thinreports::Core::Shape::PageNumber::TestInternal < Minitest::Test
 
   def test_type_of
     pageno = init_pageno
-    assert pageno.type_of?(:pageno)
+    assert pageno.type_of?('page-number')
   end
 
   def test_style

data/test/unit/core/shape/styles/test_base.rb

@@ -8,17 +8,17 @@ class Thinreports::Core::Shape::Style::TestBase < Minitest::Test
   # Alias
   Style = Thinreports::Core::Shape::Style::Base
 
-  def create_basic_format(attrs = {})
-    Thinreports::Core::Shape::Basic::Format.new('svg' => {'attrs' => attrs})
+  def create_basic_format(base_style = {})
+    Thinreports::Core::Shape::Basic::Format.new('style' => base_style)
   end
 
-  def create_style(base = {})
-    Style.new(create_basic_format(base))
+  def create_style(base_style = {})
+    Style.new(create_basic_format(base_style))
   end
 
-  def create_new_style(base = {}, &block)
+  def create_new_style(base_style = {}, &block)
     klass = ::Class.new(Style, &block)
-    klass.new(create_basic_format(base))
+    klass.new(create_basic_format(base_style))
   end
 
   def test_self_style_reader_should_properly_define_a_reading_method
@@ -96,41 +96,6 @@ class Thinreports::Core::Shape::Style::TestBase < Minitest::Test
     assert_equal style.styles['hoge'], 'hoge_style'
   end
 
-  def test_finalized_svg_attributes_should_return_the_Hash_of_having_combined_styles_and_base
-    style = create_style('hoge' => 'base_hoge_style',
-                         'foo'  => 'base_foo_style')
-    style.write_internal_style('hoge', 'modified_hoge_style')
-
-    assert_equal style.finalized_svg_attributes.values_at('hoge', 'foo'),
-                 ['modified_hoge_style', 'base_foo_style']
-  end
-
-  def test_finalized_svg_attributes_should_return_a_base_when_styles_is_empty
-    style = create_style
-    assert_equal style.finalized_svg_attributes, style.instance_variable_get(:@base_styles)
-  end
-
-  def test_finalized_svg_attributes_should_return_a_cloned_base_when_styles_is_empty
-    style = create_style
-    refute_same style.finalized_svg_attributes, style.instance_variable_get(:@base_styles)
-  end
-
-  def test_finalized_svg_attributes_should_return_same_value_constantly
-    style = create_style('hoge' => 'hoge_style')
-    style.write_internal_style('foo', 'foo_style')
-
-    assert_same style.finalized_svg_attributes,
-                style.finalized_svg_attributes
-  end
-
-  def test_svg_attrs_should_operate_like_a_finalized_svg_attributes
-    style = create_style('hoge' => 'hoge_style',
-                         'foo'  => 'foo_style')
-    style.write_internal_style('foo', 'overwrite_foo_style')
-
-    assert_same style.finalized_svg_attributes, style.svg_attrs
-  end
-
   def test_has_style_asker_should_return_true_when_specified_style_method_is_accessible
     style = create_new_style {
       style_accessible :hoge, :foo
@@ -213,4 +178,14 @@ class Thinreports::Core::Shape::Style::TestBase < Minitest::Test
 
     assert_equal style.identifier, style.styles.hash.to_s
   end
+
+  def test_finalized_styles
+    base_styles = { 'foo' => 'default foo', 'bar' => 'default bar' }
+
+    style = create_style(base_styles)
+    style.write_internal_style('foo', 'new foo')
+
+    assert_equal({ 'foo' => 'new foo', 'bar' => 'default bar' }, style.finalized_styles)
+    assert_same style.finalized_styles, style.finalized_styles
+  end
 end

data/test/unit/core/shape/styles/test_basic.rb

@@ -4,21 +4,21 @@ require 'test_helper'
 
 class Thinreports::Core::Shape::Style::TestBasic < Minitest::Test
   include Thinreports::TestHelper
-  
+
   def create_basic_style(format_config = {})
     format = Thinreports::Core::Shape::Basic::Format.new(format_config)
     Thinreports::Core::Shape::Style::Basic.new(format)
   end
-  
+
   def test_visible_should_return_visibility_of_format_as_default
-    style = create_basic_style('display' => 'false')
+    style = create_basic_style('display' => false)
     assert_equal style.visible, false
   end
-  
+
   def test_visible_should_properly_set_visibility
-    style = create_basic_style('display' => 'false')
+    style = create_basic_style('display' => false)
     style.visible = true
-    
+
     assert_equal style.visible, true
   end
-end
+end

data/test/unit/core/shape/styles/test_graphic.rb

@@ -5,51 +5,46 @@ require 'test_helper'
 class Thinreports::Core::Shape::Style::TestGraphic < Minitest::Test
   include Thinreports::TestHelper
 
-  def create_graphic_style
-    format = Thinreports::Core::Shape::Basic::Format.new({})
-    Thinreports::Core::Shape::Style::Graphic.new(format)
-  end
+  def test_border_color
+    style = create_graphic_style('border-color' => 'red')
+    assert_equal 'red', style.border_color
 
-  def test_border_color_should_properly_set_to_internal_styles_as_stroke_style
-    style = create_graphic_style
     style.border_color = '#ff0000'
-
-    assert_equal style.styles['stroke'], '#ff0000'
-  end
-
-  def test_border_width_should_properly_set_to_internal_styles_as_stroke_width_style
-    style = create_graphic_style
-    style.border_width = 1
-
-    assert_equal style.styles['stroke-width'], 1
+    assert_equal '#ff0000', style.styles['border-color']
+    assert_equal '#ff0000', style.border_color
   end
 
-  def test_border_width_should_set_stroke_opacity_to_1_when_width_is_not_zero
-    style = create_graphic_style
-    style.border_width = 5
+  def test_border_width
+    style = create_graphic_style('border-width' => 2.0)
+    assert_equal 2.0, style.border_width
 
-    assert_equal style.styles['stroke-opacity'], '1'
+    style.border_width = 10.9
+    assert_equal 10.9, style.styles['border-width']
+    assert_equal 10.9, style.border_width
   end
 
-  def test_fill_color_should_properly_set_to_internal_styles_as_fill_style
-    style = create_graphic_style
-    style.fill_color = '#0000ff'
+  def test_fill_color
+    style = create_graphic_style('fill-color' => '#0000ff')
+    assert_equal '#0000ff', style.fill_color
 
-    assert_equal style.styles['fill'], '#0000ff'
+    style.fill_color = 'blue'
+    assert_equal 'blue', style.styles['fill-color']
+    assert_equal 'blue', style.fill_color
   end
 
-  def test_border_should_return_an_Array_included_border_width_and_border_color
-    style = create_graphic_style
-    style.border_width = 1
-    style.border_color = '#ff0000'
+  def test_border
+    style = create_graphic_style('border-color' => 'red', 'border-width' => 1)
+    assert_equal [1, 'red'], style.border
 
-    assert_equal style.border, [style.border_width, style.border_color]
+    style.border = [2.0, '#ff0000']
+    assert_equal 2.0, style.styles['border-width']
+    assert_equal '#ff0000', style.styles['border-color']
   end
 
-  def test_border_should_properly_set_both_border_width_and_border_color_from_the_specified_array_argument
-    style = create_graphic_style
-    style.border = [5, '#000000']
+  private
 
-    assert_equal style.border, [5, '#000000']
+  def create_graphic_style(default_style = {})
+    format = Thinreports::Core::Shape::Basic::Format.new('style' => default_style)
+    Thinreports::Core::Shape::Style::Graphic.new(format)
   end
 end