thinreports 0.7.6 → 0.7.7

data/test/unit/core/format/test_builder.rb

@@ -66,7 +66,6 @@ class ThinReports::Core::Format::TestBuilder < MiniTest::Unit::TestCase
       <svg width="595.2" height="841.8">
         <g class="canvas">
           <rect x="100" y="100" width="100" height="100" fill="red" x-attr="cleaned attr"></rect>
-          <%= r(:"t1")%>
           <!--LAYOUT<text x="60" y="103">t1</text>LAYOUT-->
         </g>
       </svg>
@@ -111,4 +110,4 @@ class ThinReports::Core::Format::TestBuilder < MiniTest::Unit::TestCase
   def test_shape_tag
     assert_equal TestFormat.shape_tag(flexmock(:id => :foo)), '<%= r(:"foo")%>'
   end
-end
+end

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

@@ -47,4 +47,12 @@ class ThinReports::Core::Shape::Basic::TestInternal < MiniTest::Unit::TestCase
     
     assert_equal result.all?, true
   end
-end
+
+  def test_identifier
+    basic = create_internal('id' => 'basic-id')
+    assert_equal basic.identifier, 'basic-id'
+
+    flexmock(basic.style).should_receive(:identifier => 'style-identifier')
+    assert_equal basic.identifier, 'basic-idstyle-identifier'
+  end
+end

data/test/unit/core/shape/list/test_configuration.rb

@@ -29,6 +29,10 @@ class ThinReports::Core::Shape::List::TestConfiguration < MiniTest::Unit::TestCa
   def test_store_return_nil_when_uninitialized_yet
     assert_nil @config.store
   end
+
+  def test_type
+    assert_equal @config.type, List::TYPE_NAME
+  end
   
   def test_copy
     copied_store = flexmock('copied store')
@@ -49,4 +53,5 @@ class ThinReports::Core::Shape::List::TestConfiguration < MiniTest::Unit::TestCa
     assert_same copied_config.events, copied_events
     assert_same copied_config.store, copied_store
   end
-end
+end
+

data/test/unit/core/shape/list/test_manager.rb

@@ -109,4 +109,14 @@ class ThinReports::Core::Shape::List::TestManager < MiniTest::Unit::TestCase
     
     assert_same list_used_in_event, current_list
   end
+
+  def test_page_count
+    report = create_report
+    assert_equal report.page_count, 0
+
+    report.list(:list).page_break
+    report.list(:list).page_break
+
+    assert_equal report.list(:list).manager.page_count, 2
+  end
 end

data/test/unit/core/shape/list/test_page_state.rb

@@ -28,4 +28,4 @@ class ThinReports::Core::Shape::List::TestPageState < MiniTest::Unit::TestCase
     @state.finalized!
     assert_equal @state.finalized?, true
   end
-end
+end

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

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::PageNumber::TestFormat < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+
+  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,30 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::PageNumber::TestInterface < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+
+  PageNumber = ThinReports::Core::Shape::PageNumber
+
+  def init_pageno(format = {})
+    PageNumber::Interface.new(flexmock('parent'), PageNumber::Format.new(format))
+  end
+
+  def test_format
+    pageno = init_pageno('format' => '{page}')
+
+    assert_equal pageno.format, '{page}'
+    pageno.format('{page} / {total}')
+    assert_equal pageno.format, '{page} / {total}'
+  end
+
+  def test_reset_format
+    pageno = init_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/unit/helper'
+
+class ThinReports::Core::Shape::PageNumber::TestInternal < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+
+  PageNumber = ThinReports::Core::Shape::PageNumber
+
+  def setup
+    @report = create_basic_report('basic_layout1.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_text.rb

@@ -13,7 +13,7 @@ class ThinReports::Core::Shape::Style::TestText < MiniTest::Unit::TestCase
     format ||= create_format
     ThinReports::Core::Shape::Style::Text.new(format)
   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 +302,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

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

@@ -5,43 +5,45 @@ require 'test/unit/helper'
 class ThinReports::Core::Shape::TextBlock::Formatter::TestDatetime < MiniTest::Unit::TestCase
   include ThinReports::TestHelpers
   
-  # 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/test_format.rb

@@ -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,
@@ -55,6 +56,10 @@ class ThinReports::Core::Shape::TextBlock::TestFormat < MiniTest::Unit::TestCase
   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, ''

data/test/unit/core/test_events.rb

@@ -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

@@ -8,6 +8,10 @@ class ThinReports::Core::TestShape < MiniTest::Unit::TestCase
   # Alias
   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
@@ -57,4 +61,4 @@ class ThinReports::Core::TestShape < MiniTest::Unit::TestCase
       ShapeModule::Configuration('s-line')
     end
   end
-end
+end

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

@@ -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/test_draw_shape.rb

@@ -33,4 +33,10 @@ 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
+

data/test/unit/generator/pdf/document/test_page.rb

@@ -8,7 +8,33 @@ class ThinReports::Generator::PDF::Document::TestPage < MiniTest::Unit::TestCase
   def create_pdf
     @pdf = ThinReports::Generator::PDF::Document.new
   end
-  
+
+  def test_page_geometry
+    page_geometry = Prawn::Document::PageGeometry::SIZES
+    assert_equal page_geometry['B4_JIS'], [728.5, 1031.8]
+    assert_equal page_geometry['B5_JIS'], [515.9, 728.5]
+  end
+
+  def test_B4_paper_size_should_be_converted_to_B4_JIS
+    create_pdf
+
+    format = create_basic_layout_format('basic_layout1.tlf')
+    flexmock(format).should_receive(:page_paper_type).and_return('B4')
+
+    @pdf.start_new_page(format)
+    assert_equal @pdf.internal.page.size, 'B4_JIS'
+  end
+
+  def test_B4_ISO_paper_size_should_be_converted_to_B4
+    create_pdf
+
+    format = create_basic_layout_format('basic_layout1.tlf')
+    flexmock(format).should_receive(:page_paper_type).and_return('B4_ISO')
+
+    @pdf.start_new_page(format)
+    assert_equal @pdf.internal.page.size, 'B4'
+  end
+
   def test_change_page_format_should_return_true_at_first_time
     create_pdf
     format = create_basic_layout_format('basic_layout1.tlf')
@@ -77,7 +103,7 @@ class ThinReports::Generator::PDF::Document::TestPage < MiniTest::Unit::TestCase
     @pdf.start_new_page(format)
     @pdf.start_new_page(format)
   end
-  
+
   def test_add_blank_page_should_create_an_A4_size_page_in_first_page
     create_pdf
     flexmock(@pdf.internal).should_receive(:start_new_page).with(:size => 'A4').once
@@ -92,4 +118,4 @@ class ThinReports::Generator::PDF::Document::TestPage < MiniTest::Unit::TestCase
     
     @pdf.add_blank_page
   end
-end
+end