thinreports 0.7.6 → 0.8.0

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

@@ -1,121 +1,149 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::Manager::TestTarget < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::Manager::TestTarget < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   # Alias
-  Shape = ThinReports::Core::Shape
-  
+  Shape = Thinreports::Core::Shape
+
   class TestManager
     include Shape::Manager::Target
-    
+
     attr_reader :layout, :report
-    
+
     def initialize(report, layout)
       @report = report
       @layout = layout
-      
+
       initialize_manager(layout.format) do |f|
         Shape::Interface(self, f)
       end
     end
   end
-  
+
   def create_shape_format(type, id)
     Shape::Format(type).new('id' => id, 'type' => type)
   end
-  
+
   def create_manager
-    report = create_basic_report('basic_layout1.tlf')
+    report = new_report('layout_text1.tlf')
     layout = report.layout
-    
-    # Add to dummy shapes.
-    layout.format.shapes[:t1] = create_shape_format('s-tblock', 't1')
-    layout.format.shapes[:t2] = create_shape_format('s-tblock', 't2')
-    layout.format.shapes[:ls] = create_shape_format('s-list', 'ls')
+
+    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.value = 'block1'
+
+    assert_instance_of Shape::TextBlock::Interface, manager[:text_block1]
+    assert_instance_of Shape::ImageBlock::Interface, manager[:image_block]
+    assert_instance_of Shape::Basic::Interface, manager[:rectangle]
+
+    assert_raises Thinreports::Errors::UnknownItemId do
+      manager[:unknown_id]
+    end
+
+    assert_raises Thinreports::Errors::UnknownItemId do
+      manager[:list1]
+    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[: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' }
+  end
+
   def test_manager_should_return_instance_of_ManagerInternal
     assert_instance_of Shape::Manager::Internal, create_manager.manager
   end
-  
+
   def test_item_should_properly_return_shape_with_the_specified_Symbol_id
-    assert_equal create_manager.item(:t1).id, 't1'
+    assert_equal create_manager.item(:text_block1).id, 'text_block1'
   end
-  
+
   def test_item_should_properly_return_shape_with_the_specified_String_id
-    assert_equal create_manager.item('t2').id, 't2'
+    assert_equal create_manager.item('text_block2').id, 'text_block2'
   end
-  
+
   def test_item_should_raise_when_the_shape_with_the_specified_id_is_not_found
-    assert_raises ThinReports::Errors::UnknownItemId do
+    assert_raises Thinreports::Errors::UnknownItemId do
       create_manager.item(:unknown)
     end
   end
-  
+
   def test_item_should_set_an_shape_as_argument_when_a_block_is_given
     id = nil
-    create_manager.item(:t1) {|s| id = s.id }
-    assert_equal id, 't1'
+    create_manager.item(:text_block1) {|s| id = s.id }
+    assert_equal id, 'text_block1'
   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(:ls)
+    assert_raises Thinreports::Errors::UnknownItemId do
+      create_manager.item(:list1)
     end
   end
-  
+
   def test_list_should_properly_return_list_with_the_specified_Symbol_id
-    assert_equal create_manager.list(:ls).id, 'ls'
+    assert_equal create_manager.list(:list1).id, 'list1'
   end
-  
+
   def test_list_should_properly_return_list_with_the_specified_String_id
-    assert_equal create_manager.list('ls').id, 'ls'
+    assert_equal create_manager.list('list1').id, 'list1'
   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(:t1)
+    assert_raises Thinreports::Errors::UnknownItemId do
+      create_manager.list(:text_block1)
     end
   end
-  
+
   def test_list_should_use_default_as_id_when_id_is_omitted
     assert_equal create_manager.list.id, 'default'
   end
-  
+
   def test_values_should_properly_set_values_to_shapes_with_specified_id
     manager = create_manager
-    manager.values(:t1 => 1000, 't2' => 'value')
-    
-    assert_equal [manager.item(:t1).value, manager.item(:t2).value], [1000, 'value']
-  end
-  
-  def test_items_should_show_deprecation_warning
-    out, err = capture_io do
-      create_manager.items(:t1 => 1000)
-    end
-    assert_match %r!DEPRECATION!, err
+    manager.values(text_block1: 1000, 'text_block2' => 'value')
+
+    assert_equal [manager.item(:text_block1).value, manager.item(:text_block2).value], [1000, 'value']
   end
-  
+
   def test_item_exists_asker_should_return_true_when_shape_with_specified_Symbol_id_is_found
-    assert_equal create_manager.item_exists?(:t1), true
+    assert_equal create_manager.item_exists?(:text_block1), true
   end
-  
+
   def test_item_exists_asker_should_return_true_when_shape_with_specified_String_id_is_found
-    assert_equal create_manager.item_exists?('t2'), true
+    assert_equal create_manager.item_exists?('text_block2'), true
   end
-  
+
   def test_item_exists_asker_should_return_false_when_shape_with_specified_id_not_found
     assert_equal create_manager.item_exists?('unknown'), false
   end
-  
+
   def test_exists_asker_should_operate_like_as_item_exists_asker
     manager = create_manager
     assert_equal manager.exists?(:unknown), manager.item_exists?(:unknown)
   end
-end
+end

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

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+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"
+      }
+    }
+  }
+
+  Format = Thinreports::Core::Shape::PageNumber::Format
+
+  def format(raw_format = nil)
+    Format.new(raw_format || TEST_PAGENO_FORMAT)
+  end
+
+  def test_build
+    Format.build(TEST_PAGENO_FORMAT)
+  rescue => e
+    flunk exception_details(e, 'Failed to build')
+  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
+
+  def test_overflow
+    assert_equal format.overflow, 'truncate'
+  end
+
+  def test_target
+    assert_equal format.target, ''
+    assert_equal format("target" => "list-id").target, 'list-id'
+  end
+
+  def test_default_format
+    assert_equal format.default_format, '{page} / {total}'
+  end
+end

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

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+require 'test_helper'
+
+class Thinreports::Core::Shape::PageNumber::TestInterface < Minitest::Test
+  include Thinreports::TestHelper
+
+  PageNumber = Thinreports::Core::Shape::PageNumber
+
+  def create_pageno(format = {})
+    report = new_report 'layout_text1'
+    parent = report.start_new_page
+
+    PageNumber::Interface.new parent, PageNumber::Format.new(format)
+  end
+
+  def test_format
+    pageno = create_pageno 'format' => '{page}'
+
+    assert_equal pageno.format, '{page}'
+    pageno.format('{page} / {total}')
+    assert_equal pageno.format, '{page} / {total}'
+  end
+
+  def test_reset_format
+    pageno = create_pageno 'format' => '{page}'
+
+    pageno.format('-- {page} --')
+    pageno.reset_format
+
+    assert_equal pageno.format, '{page}'
+  end
+end

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

@@ -0,0 +1,81 @@
+# coding: utf-8
+
+require 'test_helper'
+
+class Thinreports::Core::Shape::PageNumber::TestInternal < Minitest::Test
+  include Thinreports::TestHelper
+
+  PageNumber = Thinreports::Core::Shape::PageNumber
+
+  def setup
+    @report = new_report('layout_text1.tlf')
+    @report.start_new_page
+  end
+
+  def init_pageno(format = {})
+    PageNumber::Internal.new(@report.page, PageNumber::Format.new(format))
+  end
+
+  def test_read_format
+    pageno = init_pageno('format' => 'Page {page}')
+
+    assert_equal pageno.read_format, 'Page {page}'
+  end
+
+  def test_write_format
+    pageno = init_pageno('format' => 'Page {page}')
+    pageno.write_format('{page}')
+
+    assert_equal pageno.read_format, '{page}'
+  end
+
+  def test_reset_format
+    pageno = init_pageno('format' => '{page}')
+    pageno.write_format('Page {page}')
+    pageno.reset_format
+
+    assert_equal pageno.read_format, '{page}'
+  end
+
+  def test_build_format
+    pageno = init_pageno('format' => '{page} / {total}')
+    assert_equal pageno.build_format(1, 100), '1 / 100'
+
+    pageno.write_format('{page}')
+    assert_equal pageno.build_format(1, 100), '1'
+
+    @report.start_page_number_from 5
+    pageno = init_pageno('format' => '{page} / {total}')
+    assert_equal pageno.build_format(1, 100), '5 / 104'
+
+    # if counted target is a List shape
+    pageno = init_pageno('format' => '{page} / {total}',
+                         'target' => 'list-id')
+    assert_equal pageno.build_format(1, 100), '1 / 100'
+  end
+
+  def test_type_of
+    pageno = init_pageno
+    assert pageno.type_of?(:pageno)
+  end
+
+  def test_style
+    pageno = init_pageno
+    style = pageno.style
+
+    assert_instance_of PageNumber::Style, style
+    assert_same pageno.style, style
+  end
+
+  def test_for_report
+    pageno = init_pageno('target' => '')
+    assert_equal pageno.for_report?, true
+
+    pageno = init_pageno('target' => 'list-id')
+    assert_equal pageno.for_report?, false
+  end
+
+  def test_Style_class
+    refute_includes PageNumber::Style.accessible_styles, :valign
+  end
+end

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

@@ -1,15 +1,15 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Style::TestBase < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::Style::TestBase < Minitest::Test
+  include Thinreports::TestHelper
   
   # Alias
-  Style = ThinReports::Core::Shape::Style::Base
+  Style = Thinreports::Core::Shape::Style::Base
   
   def create_basic_format(attrs = {})
-    ThinReports::Core::Shape::Basic::Format.new('svg' => {'attrs' => attrs})
+    Thinreports::Core::Shape::Basic::Format.new('svg' => {'attrs' => attrs})
   end
   
   def create_style(base = {})
@@ -178,17 +178,17 @@ class ThinReports::Core::Shape::Style::TestBase < MiniTest::Unit::TestCase
   end
   
   def test_reader_method_caller_should_raise_when_style_is_not_accessible
-    assert_raises ThinReports::Errors::UnknownShapeStyleName do
+    assert_raises Thinreports::Errors::UnknownShapeStyleName do
       create_new_style[:unknown]
     end
   end
   
   def test_writer_method_caller_should_raise_when_style_is_not_accessible
-    assert_raises ThinReports::Errors::UnknownShapeStyleName do
+    assert_raises Thinreports::Errors::UnknownShapeStyleName do
       create_new_style[:unknown] = 'value'
     end
   end
-  
+
   def test_copy_should_return_the_instance_of_the_same_class_as_itself
     style = create_style
     assert_instance_of Style, style.copy
@@ -216,4 +216,4 @@ class ThinReports::Core::Shape::Style::TestBase < MiniTest::Unit::TestCase
     
     assert_equal style.identifier, style.styles.hash.to_s
   end
-end
+end

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

@@ -1,13 +1,13 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Style::TestBasic < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+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)
+    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

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

@@ -1,69 +1,55 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
+
+class Thinreports::Core::Shape::Style::TestGraphic < Minitest::Test
+  include Thinreports::TestHelper
 
-class ThinReports::Core::Shape::Style::TestGraphic < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
   def create_graphic_style
-    format = ThinReports::Core::Shape::Basic::Format.new({})
-    ThinReports::Core::Shape::Style::Graphic.new(format)
+    format = Thinreports::Core::Shape::Basic::Format.new({})
+    Thinreports::Core::Shape::Style::Graphic.new(format)
   end
-  
+
   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
   end
-  
+
   def test_border_width_should_set_stroke_opacity_to_1_when_width_is_not_zero
     style = create_graphic_style
     style.border_width = 5
-    
+
     assert_equal style.styles['stroke-opacity'], '1'
   end
-  
+
   def test_fill_color_should_properly_set_to_internal_styles_as_fill_style
     style = create_graphic_style
     style.fill_color = '#0000ff'
-    
+
     assert_equal style.styles['fill'], '#0000ff'
   end
-  
-  def test_fill_should_operate_like_the_fill_color_method
-    style = create_graphic_style
-    style.fill = '#ff0000'
-    
-    assert_same style.fill_color, style.fill
-  end
-  
-  def test_stroke_should_operate_like_the_border_width_method
-    style = create_graphic_style
-    style.stroke = 5
-    
-    assert_same style.border_width, style.stroke
-  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'
-    
+
     assert_equal style.border, [style.border_width, style.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']
-    
+
     assert_equal style.border, [5, '#000000']
   end
-end
+end

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

@@ -1,19 +1,30 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Style::TestText < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::Style::TestText < Minitest::Test
+  include Thinreports::TestHelper
   
   def create_format(format = {})
-    ThinReports::Core::Shape::Text::Format.new(format)
+    Thinreports::Core::Shape::Text::Format.new(format)
   end
   
   def create_text_style(format = nil)
     format ||= create_format
-    ThinReports::Core::Shape::Style::Text.new(format)
+    Thinreports::Core::Shape::Style::Text.new(format)
   end
-  
+
+  def test_font_size
+    format = create_format('svg' => {'attrs' => {'font-size' => '12'}})
+    style  = create_text_style(format)
+
+    assert_equal style.font_size, '12'
+
+    style.font_size = 19
+
+    assert_equal style.styles['font-size'], 19
+  end
+
   def test_bold_should_return_true_when_font_weight_property_of_format_is_bold
     format = create_format('svg' => {'attrs' => {'font-weight' => 'bold'}})
     style  = create_text_style(format)
@@ -302,6 +313,17 @@ class ThinReports::Core::Shape::Style::TestText < MiniTest::Unit::TestCase
       create_text_style.valign = :unknonw
     end
   end
+
+  def test_initialize
+    klass = Class.new(Thinreports::Core::Shape::Style::Text)
+    klass.class_eval do
+      accessible_styles.delete(:valign)
+    end
+
+    style = klass.new(create_format('valign' => ''))
+    assert_equal style.valign, :top, 'should be set :top as default to @valign style ' + 
+                                     'if :valign is not accessible'
+  end
   
   def test_identifier_should_return_the_same_value_as_create_identifier_method_when_valign_has_not_been_changed
     style = create_text_style
@@ -315,4 +337,4 @@ class ThinReports::Core::Shape::Style::TestText < MiniTest::Unit::TestCase
     assert_equal style.identifier,
                  style.send(:create_identifier, style.styles) + 'bottom'
   end
-end
+end

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

@@ -1,9 +1,9 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Text::TestFormat < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::Text::TestFormat < Minitest::Test
+  include Thinreports::TestHelper
 
   TEST_TEXT_FORMAT = {
     "type" => "s-text",
@@ -44,14 +44,14 @@ class ThinReports::Core::Shape::Text::TestFormat < MiniTest::Unit::TestCase
   }
 
   # Alias
-  Format = ThinReports::Core::Shape::Text::Format
+  Format = Thinreports::Core::Shape::Text::Format
 
   def test_build_format
     build_format
   rescue => e
     flunk exception_details(e, 'Building failed.')
   end
-  
+
   def test_config_readers
     format = Format.new(TEST_TEXT_FORMAT)
     
@@ -70,4 +70,4 @@ class ThinReports::Core::Shape::Text::TestFormat < MiniTest::Unit::TestCase
   def build_format
     Format.build(TEST_TEXT_FORMAT)
   end
-end
+end

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

@@ -1,21 +1,20 @@
 # coding: utf-8
 
-require 'test/unit/helper'
+require 'test_helper'
 
-class ThinReports::Core::Shape::Text::TestInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
+class Thinreports::Core::Shape::Text::TestInternal < Minitest::Test
+  include Thinreports::TestHelper
   
-  Text = ThinReports::Core::Shape::Text
+  Text = Thinreports::Core::Shape::Text
   
-  def setup
-    format = flexmock('format')
-    format.should_receive(:type => 's-text')
-    
-    @internal = Text::Internal.new(flexmock('parent'), format)
+  def create_internal(format_config = {})
+    report = new_report('layout_text1.tlf')
+    Text::Internal.new(report.start_new_page, Text::Format.new(format_config))
   end
   
   def test_type_of?
-    assert_equal @internal.type_of?(:text), true
-    assert_equal @internal.type_of?(:basic), false
+    assert create_internal.type_of?(:text), true
+    refute create_internal.type_of?(:basic), false
   end
-end
+
+end