thinreports 0.6.0.pre3 → 0.7.0

data/lib/thinreports/generator/pxd/page_renderer.rb

@@ -1,75 +0,0 @@
-# coding: utf-8
-
-require 'erb'
-
-module ThinReports
-  module Generator
-    
-    # @private
-    class Pxd::PageRenderer
-      include Pxd::Helper
-      
-      def initialize(format)
-        @engine  = ERB.new(read_layout(format))
-        @manager = {}
-        @lists   = {}
-      end
-      
-      # @param [ThinReports::Core::Shape::Manager::Internal] manager
-      # @return [String]
-      def render(manager)
-        @manager = manager
-        @engine.result(binding)
-      end
-      
-      def render_shape(id)
-        return '' unless shape = @manager.final_shape(id)
-        
-        shape = shape.internal
-        case 
-        when shape.type_of?(:tblock)
-          render_tblock(shape)
-        when shape.type_of?(:list)
-          render_list(shape)
-        when shape.type_of?(:text)
-          render_text(shape)
-        else
-          render_basic(shape)
-        end
-      end
-      alias_method :r, :render_shape
-      
-    private
-    
-      def render_basic(shape)
-        tag(shape.svg_tag, shape.attributes)
-      end
-      
-      def render_text(shape)
-        content_tag(shape.svg_tag, shape.svg_content,
-                    shape.attribute, :escape => false)
-      end
-      
-      def render_tblock(shape)
-        value = h(shape.real_value)
-        value = if shape.multiple?
-          value.gsub(/\r\n|\n/, '<tBreak/>')
-        else
-          value.gsub(/\r\n|\n/, ' ')
-        end
-        content_tag(shape.svg_tag, value, shape.attributes, :escape => false)
-      end
-      
-      def render_list(shape)
-        renderer = @lists[shape.id] ||= Pxd::ListRenderer.new
-        renderer.render(shape)
-      end
-      
-      def read_layout(format)
-        format.layout.gsub(/ x\-[a-z\d\-]+?=".*?"/, '').
-                      gsub(/ class=".*?"/, '')
-      end
-    end
-    
-  end
-end

data/tasks/clean.rake

@@ -1,6 +0,0 @@
-# coding: utf-8
-
-require 'rake/clean'
-
-CLEAN.include(['doc/yardoc', '.yardoc'])
-CLOBBER.include([ 'pkg' ])

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

@@ -1,125 +0,0 @@
-# coding: utf-8
-
-require 'test/unit/helper'
-
-class ThinReports::Core::Shape::Tblock::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
-    flunk exception_details(e, 'Building failed.')
-  end
-  
-  def test_config_readers
-    format = format(TEST_TBLOCK_FORMAT)
-    
-    assert_equal format.value, ''
-    assert_equal format.ref_id, ''
-    assert_equal format.format_base, '￥{value}'
-    assert_equal format.format_type, 'number'
-    assert_instance_of ::Hash, format.box
-    assert_equal format.box['x'], 100.0
-    
-    # Methods reference to unknown value returns a nil value
-    assert_nil format.format_datetime_format
-    assert_nil format.format_padding_char
-    assert_nil format.format_padding_dir
-    
-    # In face, #format_padding_length returns a nil value
-    assert_equal format.format_padding_length, 0
-
-    assert_equal format.format_padding_rdir?, false
-    assert_equal format.has_format?, true
-    assert_equal format.has_reference?, false
-    assert_equal format.multiple?, false
-  end
-  
-  def test_multiple?
-    assert format('multiple' => 'true').multiple?
-    refute format('multiple' => 'false').multiple?
-  end
-  
-  def test_format_padding_rdir?
-    data = {'format' => {'padding' => {'direction' => 'L'}}}
-    
-    refute format(data).format_padding_rdir?
-    
-    data['format']['padding']['direction'] = 'R'
-    assert format(data).format_padding_rdir?
-  end
-  
-  def test_format_padding_length
-    data = {'format' => {'padding' => {'length' => '0'}}}
-    
-    assert_equal format(data).format_padding_length, 0
-    
-    data['format']['padding']['length'] = '10'
-    assert_equal format(data).format_padding_length, 10
-  end
-  
-  def test_has_format?
-    data = {'format' => {'type' => ''}}
-    
-    refute format(data).has_format?
-    
-    data['format']['type'] = 'number'
-    assert format(data).has_format?
-    
-    data['format']['type'] = 'unknown'
-    refute format(data).has_format?
-  end
-  
-  def test_has_reference?
-    refute format('ref-id' => '').has_reference?
-    assert format('ref-id' => 'ref_tblock_1').has_reference?
-  end
-  
-  def build_format
-    ThinReports::Core::Shape::Tblock::Format.build(TEST_TBLOCK_FORMAT)
-  end
-  
-  def format(data)
-    ThinReports::Core::Shape::Tblock::Format.new(data)
-  end
-end

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

@@ -1,40 +0,0 @@
-# coding: utf-8
-
-require 'test/unit/helper'
-
-class ThinReports::Core::Shape::Tblock::TestInterface < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
-  Tblock = ThinReports::Core::Shape::Tblock
-  
-  def setup
-    @interface = Tblock::Interface.new(flexmock('parent'), flexmock('format'))
-  end
-  
-  def test_value_work_as_getter_when_receive_no_arguments
-    flexmock(@interface.internal).should_receive(:read_value).
-        and_return('value').once
-    
-    assert_equal @interface.value, 'value'
-  end
-  
-  def test_value_work_as_setter_when_receive_an_just_one_argument
-    flexmock(@interface.internal).should_receive(:write_value).once
-    
-    @interface.value('any value')
-  end
-  
-  def test_value_raise_error_when_receive_more_than_two
-    assert_raises ArgumentError do
-      @interface.value('arg1', 'arg2')
-    end
-  end
-  
-  def test_set
-    flexmock(@interface).
-        should_receive(:value).once.
-        should_receive(:styles).once
-    
-    @interface.set('value', :fill => 'red')
-  end
-end

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

@@ -1,139 +0,0 @@
-# coding: utf-8
-
-require 'test/unit/helper'
-
-class ThinReports::Core::Shape::Tblock::TestInternal < MiniTest::Unit::TestCase
-  include ThinReports::TestHelpers
-  
-  Tblock = ThinReports::Core::Shape::Tblock
-  
-  def test_read_value_return_the_format_value
-    format = flexmock('format')
-    format.should_receive(:value => 'format value').times(2)
-    format.should_receive(:has_reference? => false)
-    
-    internal = init_internal(format)
-    
-    assert_equal internal.read_value, 'format value'
-    assert_equal internal.value, 'format value'
-  end
-  
-  def test_read_value_return_the_value_of_referenced_shape
-    format = flexmock('format')
-    format.should_receive(:has_reference? => true)
-    format.should_receive(:ref_id => 'dummy')
-    
-    internal = init_internal(format)
-    
-    assert_equal internal.read_value, 'referenced value'
-    assert_equal internal.value, 'referenced value'
-  end
-  
-  def test_read_value_return_the_value_stored_in_states
-    format = flexmock('format')
-    format.should_receive(:has_reference? => false)
-    
-    internal = init_internal(format)
-    internal.states[:value] = 'any value'
-    
-    assert_equal internal.read_value, 'any value'
-    assert_equal internal.value, 'any value'
-  end
-  
-  def test_write_value
-    format = flexmock('format')
-    format.should_receive(:has_reference? => false)
-    
-    internal = init_internal(format)
-    internal.write_value('value written')
-    
-    assert_equal internal.value, 'value written'
-  end
-  
-  def test_write_value_show_warnings_when_has_reference
-    format = flexmock('format')
-    format.should_receive(:has_reference? => true,
-                          :ref_id => 'ref id',
-                          :id => 'id')
-    out, err = capture_io do
-      init_internal(format).write_value('value written')
-    end
-    assert_equal err.chomp, 'The set value is not reflected, ' +
-                            "Because 'id' refers to 'ref id'."
-  end
-  
-  def test_real_value_return_the_formatted_value
-    format = flexmock('format')
-    format.should_receive(:has_format? => true,
-                          :multiple?   => false)
-    
-    internal = init_internal(format)
-    flexmock(internal, :read_value => 'dummy')
-    
-    assert_equal internal.real_value, 'formatted value'
-  end
-  
-  def test_real_value_return_the_raw_value_when_has_not_format
-    format = flexmock('format')
-    format.should_receive(:has_format? => false,
-                          :multiple?   => false)
-    
-    internal = init_internal(format)
-    flexmock(internal, :read_value => 'raw value')
-    
-    assert_equal internal.real_value, 'raw value'
-  end
-  
-  def test_real_value_return_the_raw_value_constantly_when_is_multiple
-    format = flexmock('format')
-    format.should_receive(:has_format? => true,
-                          :multiple?   => true)
-    
-    internal = init_internal(format)
-    flexmock(internal, :read_value => 'raw value')
-    
-    assert_equal internal.real_value, 'raw value'    
-  end
-  
-  def test_format_enabled
-    internal = init_internal(flexmock('format'))
-    internal.format_enabled(true)
-    
-    assert_equal internal.states[:format_enabled], true
-  end
-  
-  def test_format_enabled?
-    internal = init_internal(flexmock(:has_format? => true,
-                                      :multiple?   => false))
-    
-    assert_equal internal.format_enabled?, true
-    
-    internal.format_enabled(false)
-    
-    assert_equal internal.format_enabled?, false
-    
-    flexmock(internal.format, :multiple? => true)
-    internal.format_enabled(true)
-    
-    assert_equal internal.format_enabled?, false
-  end
-  
-  def test_type_of?
-    assert_equal init_internal(flexmock('format')).type_of?(:tblock), true
-  end
-  
-  def init_internal(format)
-    parent = flexmock('parent')
-    parent.should_receive(:item).
-        and_return(flexmock(:value => 'referenced value'))
-    
-    formatter = flexmock('formatter')
-    formatter.should_receive(:apply).
-        and_return('formatted value')
-    
-    flexmock(Tblock::Internal).new_instances.should_receive(:formatter).
-        and_return(formatter)
-    
-    Tblock::Internal.new(parent, format)
-  end
-end