thinreports 0.6.0.pre3

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

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Text::TestFormat < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+
+  TEST_TEXT_FORMAT = {
+    "type" => "s-text",
+    "id" => "text_1",
+    "display" => "true",
+    "text" => ["Text Content1", "Text Content2"],
+    "valign" => "top",
+    "line-height" => 60,
+    "box" => {
+      "x" => 100.0,
+      "y" => 100.0,
+      "width" => 100.0,
+      "height" => 100.0
+    },
+    "svg" => {
+      "tag" => "g",
+      "attrs" => {
+        "stroke-width" => "0",
+        "font-weight" => "normal",
+        "font-style" => "normal",
+        "font-family" => "Arial",
+        "font-size" => "12",
+        "text-anchor" => "start",
+        "fill" => "#000000",
+        "fill-opacity" => "1",
+        "text-decoration" => "none",
+        "letter-spacing" => "normal"
+      },
+      "content" => "<text class=\"s-text-l0\" xml:space=\"preserve\" " +
+                   "stroke=\"none\" fill=\"inherit\" fill-opacity=\"1\" " +
+                   "text-decoration=\"none\" x=\"92\" y=\"93\">" +
+                   "Text Content1</text>" +
+                   "<text class=\"s-text-l1\" xml:space=\"preserve\" " +
+                   "stroke=\"none\" fill=\"inherit\" fill-opacity=\"1\" " +
+                   "text-decoration=\"none\" x=\"92\" y=\"107\">" +
+                   "Text Content2</text>"
+    }
+  }
+
+  # Alias
+  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)
+    
+    assert_instance_of ::Hash, format.box
+    assert_equal format.box['x'], 100.0
+    
+    assert_instance_of ::Array, format.text
+    assert_equal format.text.first, 'Text Content1'
+    
+    assert_equal format.valign, 'top'
+    assert_equal format.line_height, 60
+    
+    assert_equal format.svg_content, TEST_TEXT_FORMAT['svg']['content']
+  end
+  
+  def build_format
+    Format.build(TEST_TEXT_FORMAT)
+  end
+end

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

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::Shape::Text::TestInternal < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  Text = ThinReports::Core::Shape::Text
+  
+  def setup
+    format = flexmock('format')
+    format.should_receive(:type => 's-text')
+    
+    @internal = Text::Internal.new(flexmock('parent'), format)
+  end
+  
+  def test_type_of?
+    assert_equal @internal.type_of?(:text), true
+    assert_equal @internal.type_of?(:basic), false
+  end
+end

data/test/unit/core/test_events.rb

@@ -0,0 +1,91 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::TestEvents < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Events = ThinReports::Core::Events
+  
+  def setup
+    @events = Events.new(:load, :change, :blur)
+  end
+  
+  def test_listen
+    load1_handler  = proc{|e| e.type }
+    load2_handler  = proc{|e| e.type }
+    change_handler = proc{|e| e.target }
+
+    @events.listen(:load, &load1_handler)
+    @events.listen(:change, &change_handler)
+    # Overwrite
+    @events.listen(:load, &load2_handler)
+    
+    # Using #on method
+    @events.on(:blur) do |e|
+      e.target
+    end
+    
+    assert_equal @events.events.size, 3
+    assert_same @events.events[:change], change_handler
+    assert_same @events.events[:load], load2_handler
+  end
+  
+  def test_listen_raise_error_when_unknown_event_type_is_set
+    assert_raises ThinReports::Errors::UnknownEventType do
+      @events.listen(:unknown) {|e| e.type }
+    end
+  end
+  
+  def test_listen_raise_error_when_no_block_is_given
+    assert_raises ::ArgumentError do
+      @events.listen(:blur)
+    end
+  end
+  
+  def test_unlisten
+    @events.listen(:load) {|e| e.type }
+    @events.listen(:change) {|e| e.type }
+    @events.listen(:blur) {|e| e.type }
+    
+    @events.unlisten(:load)
+    @events.un(:change)
+    @events.un(:blur)
+    
+    assert_empty @events.events
+  end
+  
+  def test_dispatch
+    # Expected returns a true value
+    @events.listen(:change) {|e| e.type == :change }
+    assert_equal @events.dispatch(Events::Event.new(:change)), true
+    
+    # Expected to reverse the string given as e#target
+    @events.on(:blur) {|e| e.target.reverse }
+    assert_equal @events.dispatch(Events::Event.new(:blur, '123')), '321'
+  end
+  
+  def test_dispatch_raise_error_when_no_event_type_is_given
+    assert_raises ::ArgumentError do
+      @events.dispatch(Events::Event.new)
+    end
+  end
+  
+  def test_dispatch_return_nil_when_event_type_is_not_listened
+    assert_nil @events.dispatch(Events::Event.new(:load, self))
+  end
+  
+  def test_copy
+    @events.on(:change) {|e| e.type }
+    @events.on(:load) {|e| e.type }
+    
+    copied = @events.copy
+    
+    assert_equal @events.events, copied.events
+    refute_same  @events.events, copied.events
+    
+    @events.unlisten(:change)
+    refute_nil copied.dispatch(Events::Event.new(:change, self))
+  end
+end

data/test/unit/core/test_shape.rb

@@ -0,0 +1,35 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Core::TestShape < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  ShapeModule = ThinReports::Core::Shape
+  
+  def test_find_by_type
+    assert_same ShapeModule.find_by_type('s-tblock'), ShapeModule::Tblock
+    assert_same ShapeModule.find_by_type('s-list'), ShapeModule::List
+    assert_same ShapeModule.find_by_type('s-text'), ShapeModule::Text
+
+    assert_same ShapeModule.find_by_type('s-image'), ShapeModule::Basic
+    assert_same ShapeModule.find_by_type('s-line'), ShapeModule::Basic
+    assert_same ShapeModule.find_by_type('s-rect'), ShapeModule::Basic
+    assert_same ShapeModule.find_by_type('s-ellipse'), ShapeModule::Basic
+    
+    assert_raises ThinReports::Errors::UnknownShapeType do
+      ShapeModule.find_by_type('unknown')
+    end
+  end
+  
+  def test_Configuration
+    assert_same ShapeModule::Configuration('s-list'),
+                ShapeModule::List::Configuration
+
+    # When shape don't have a Configuration
+    assert_raises ThinReports::Errors::NoConfigurationFound do
+      ShapeModule::Configuration('s-line')
+    end
+  end
+end

data/test/unit/core/utils_spec.rb

@@ -0,0 +1,56 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+include ThinReports::TestHelpers
+
+describe '#block_exec_on' do
+  it 'should return raw context if not given a block' do
+    expected = '123'
+    block_exec_on(expected).must_be_same_as expected
+  end
+  
+  it 'should be run correctly without receiver if no block argument' do
+    block_exec_on('123', &proc{ reverse! }).must_equal '321'
+  end
+  
+  it 'should be run correctly with an receiver if block has an argument' do
+    block_exec_on([2, 1, 3], &proc{ |a| a.sort! }).must_equal [1, 2, 3]
+  end
+end
+
+describe '#ruby_18' do
+  it 'should not be run and return false if ruby version more than 1.8' do
+    skip_if_ruby18
+    
+    ruby_18 {
+      flunk '#ruby_18 should not be executed!'
+    }.must_equal false
+  end
+  
+  it 'should be run if ruby version less than 1.9' do
+    skip_if_ruby19
+
+    ruby_18 {
+      pass '#ruby_18 was executed correctly!'; true
+    }.must_equal true
+  end
+end
+
+describe '#ruby_19' do
+  it 'should not be run and return false if ruby version less than 1.9' do
+    skip_if_ruby19
+    
+    ruby_19 {
+      flunk '#ruby_19 should not be executed!'
+    }.must_equal false
+  end
+  
+  it 'should be run if ruby version more than 1.9' do
+    skip_if_ruby18
+    
+    ruby_19 {
+      pass '#ruby_19 was executed correctly!'; true
+    }.must_equal true
+  end
+end

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

@@ -0,0 +1,103 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Generator::Pdf::Graphics::TestAttributes < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  class TestAttrs
+    include ThinReports::Generator::Pdf::Graphics    
+  end
+  
+  def setup
+    @attrs = TestAttrs.new
+  end
+  
+  def test_common_graphic_attrs
+    result = @attrs.common_graphic_attrs('stroke'       => '#ff0000',
+                                         'stroke-width' => '1',
+                                         'fill'         => '#0000ff')
+    assert_equal result.values_at(:stroke, :stroke_width, :fill),
+                 ['#ff0000', '1', '#0000ff']
+  end
+  
+  def test_common_graphic_attrs_with_stroke_dasharray
+    result1 = @attrs.common_graphic_attrs('stroke-dasharray' => '3,5')
+    result2 = @attrs.common_graphic_attrs('stroke-dasharray' => 'none')
+    result3 = @attrs.common_graphic_attrs({})
+    
+    assert_equal result1[:stroke_dash], %w( 3 5 )
+    assert_nil   result2[:stroke_dash]
+    assert_nil   result3[:stroke_dash]
+  end
+  
+  def test_common_graphic_attrs_set_0_to_stroke_width_when_opacity_is_0
+    result = @attrs.common_graphic_attrs('stroke-width' => '1',
+                                         'stroke-opacity' => '0')
+    assert_equal result[:stroke_width], 0
+  end
+  
+  def test_common_graphic_attrs_with_block
+    result = @attrs.common_graphic_attrs('stroke' => '#ff0000') do |attrs|
+      attrs[:stroke].gsub!(/0/, 'f')
+    end
+    assert_equal result[:stroke], '#ffffff'
+  end
+  
+  def test_text_align
+    aligns = ['start', 'middle', 'end', nil]
+    assert_equal aligns.map {|a| @attrs.text_align(a) },
+                 [:left, :center, :right, :left]
+  end
+  
+  def test_text_valign
+    valigns = ['top', 'center', 'bottom', nil]
+    assert_equal valigns.map {|a| @attrs.text_valign(a) },
+                 [:top, :center, :bottom, :top]
+  end
+  
+  def test_extract_base64_string
+    base64 = 'data:image/png;base64,iVBORw0KGg1+/AAy/plYlzil'
+    assert_equal @attrs.extract_base64_string(base64),
+                 'iVBORw0KGg1+/AAy/plYlzil'
+  end
+  
+  def test_font_styles_with_bold_and_italic
+    assert_equal @attrs.font_styles('font-weight' => 'bold'), [:bold]
+    assert_equal @attrs.font_styles('font-style' => 'italic'), [:italic]
+    
+    refute_includes @attrs.font_styles('font-weight' => 'normal'), :bold
+    refute_includes @attrs.font_styles('font-style'  => 'normal'), :italic
+  end
+  
+  def test_font_styles_with_underline_and_strikethrough_via_text_decoration
+    assert_equal @attrs.font_styles('text-decoration' => 'underline line-through'),
+                 [:underline, :strikethrough]
+  end
+  
+  def common_text_attrs
+    result = @attrs.common_text_attrs('font-family'     => 'IPAMincho',
+                                      'font-size'       => '12',
+                                      'fill'            => '#000000',
+                                      'text-anchor'     => 'middle',
+                                      'font-weight'     => 'bold',
+                                      'text-decoration' => 'line-through')
+    assert_equal result.values_at(:font, :size, :color, :align, :styles),
+                 ['IPAMincho', '12', '#000000', :center, [:bold, :strikethrough]]
+  end
+  
+  def common_text_attrs_with_letter_spacing
+    result1 = @attrs.common_text_attrs('letter-spacing' => '5')
+    result2 = @attrs.common_text_attrs('letter-spacing' => 'normal')
+    
+    assert_equal result1[:letter_spacing], '5'
+    assert_nil   result2[:letter_spacing]
+  end
+  
+  def common_text_attrs_with_block
+    result = @attrs.common_text_attrs('fill' => '#000000') do |attrs|
+      attrs[:color].gsub!(/0/, 'f')
+    end
+    assert_equal result[:color], '#ffffff'
+  end
+end

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

@@ -0,0 +1,54 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Generator::Pdf::TestFont < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  # Alias
+  Font = ThinReports::Generator::Pdf::Font
+  
+  def setup
+    @doc = ThinReports::Generator::Pdf::Document.new
+  end
+  
+  def test_setup_fonts_install_builtin_fonts
+    Font::BUILTIN_FONTS.each_key do |font|
+      assert_includes @doc.internal.font_families.keys, font
+    end
+  end
+  
+  def test_setup_fonts_install_fallback_font
+    assert_includes @doc.internal.font_families.keys, 'FallbackFont'
+    assert_includes @doc.internal.fallback_fonts, 'FallbackFont'
+  end
+  
+  def test_fallback_font_has_all_styles_as_normal_IPAMincho
+    ipam = Font::BUILTIN_FONTS['IPAMincho'][:normal]
+    [:normal, :bold, :italic, :bold_italic].each do |style|
+       assert_same @doc.internal.font_families['FallbackFont'][style], ipam
+    end
+  end
+  
+  def test_setup_fonts_install_alias_fonts_of_CourierNew_and_TimesNewRoman
+    assert_same @doc.internal.font_families['Courier New'],
+                @doc.internal.font_families['Courier']
+    assert_same @doc.internal.font_families['Times New Roman'],
+                @doc.internal.font_families['Times-Roman']
+  end
+  
+  def test_default_family
+    assert_equal @doc.send(:default_family), 'Helvetica'
+  end
+  
+  def test_default_family_if_missing
+    assert_equal @doc.send(:default_family_if_missing, 'unknown font'),
+                 @doc.send(:default_family)
+    assert_equal @doc.send(:default_family_if_missing, 'IPAMincho'), 'IPAMincho'
+  end
+  
+  def test_font_has_style?
+    assert_equal @doc.send(:font_has_style?, 'IPAMincho', :bold), false
+    assert_equal @doc.send(:font_has_style?, 'Courier New', :bold), true
+  end
+end

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

@@ -0,0 +1,43 @@
+# coding: utf-8
+
+require 'test/unit/helper'
+
+class ThinReports::Generator::Pdf::TestGraphics < MiniTest::Unit::TestCase
+  include ThinReports::TestHelpers
+  
+  class TestGraphics
+    attr_accessor :pdf
+    include ThinReports::Generator::Pdf::Graphics
+  end
+  
+  def setup
+    @g     = TestGraphics.new
+    @g.pdf = flexmock('pdf')
+  end
+  
+  def test_setup_custom_graphic_states
+    @g.pdf.
+      should_receive(:line_width).
+      with(TestGraphics::BASE_LINE_WIDTH).once
+    
+    @g.send(:setup_custom_graphic_states)
+  end
+  
+  def test_line_width
+    @g.pdf.
+      should_receive(:line_width).
+      with(10 * TestGraphics::BASE_LINE_WIDTH).once
+    
+    @g.send(:line_width, 10)
+  end
+  
+  def test_save_graphics_state
+    @g.pdf.should_receive(:save_graphics_state).once
+    @g.send(:save_graphics_state)
+  end
+  
+  def test_restore_graphics_state
+    @g.pdf.should_receive(:restore_graphics_state).once
+    @g.send(:restore_graphics_state)
+  end
+end