dyi 0.0.0

data/lib/util.rb

@@ -0,0 +1,231 @@
+# -*- encoding: UTF-8 -*-
+
+# Copyright (c) 2009-2011 Sound-F Co., Ltd. All rights reserved.
+#
+# Author:: Mamoru Yuo
+#
+# This file is part of DYI.
+#
+# DYI is free software: you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# DYI is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with DYI.  If not, see <http://www.gnu.org/licenses/>.
+
+class Numeric
+
+  def strfnum(format)
+    decimal_separator = (defined? ::Numeric::DECIMAL_SEPARATOR) ? ::Numeric::DECIMAL_SEPARATOR : '.'
+    group_separator = (defined? ::Numeric::GROUP_SEPARATOR) ? ::Numeric::GROUP_SEPARATOR : ','
+    group_sizes = (defined? ::Numeric::GROUP_SIZES) ? ::Numeric::GROUP_SIZES : 3
+    percent_symbol = (defined? ::Numeric::PERCENT_SYMBOL) ? ::Numeric::PERCENT_SYMBOL : '%'
+
+    # lexical analysis
+    sec = {:int => [], :dec => [], :int_digit => 0, :dec_digit => 0, :place => 0}
+    sections = [sec]
+    escaped = false
+    forcibly = false
+    format.split(//).each do |char|
+      if escaped
+        if sec[:decimal]
+          sec[:dec].push(char)
+        else
+          sec[:int].push(char)
+        end
+        escaped = false
+        next
+      end
+
+      case char
+      when '0'
+        if sec[:decimal]
+          sec[:dec_digit] += 1
+          sec[:dec].push(:zero)
+        else
+          forcibly = true
+          sec[:int_digit] += 1
+          sec[:int].push(:zero)
+          if sec[:place] != 0
+            sec[:use_separater] = true
+            sec[:place] = 0
+          end
+        end
+      when '#'
+        if sec[:decimal]
+          sec[:dec_digit] += 1
+          sec[:dec].push(:sharp)
+        else
+          sec[:int_digit] += 1
+          sec[:int].push(forcibly ? :zero : :sharp)
+          if sec[:place] != 0
+            sec[:use_separater] = true
+            sec[:place] = 0
+          end
+        end
+      when '.'
+        sec[:decimal] = true
+      when ','
+        sec[:place] += group_sizes unless sec[:decimal]
+      when ';'
+        forcibly = false
+        sec = {:int => [], :dec => [], :int_digit => 0, :dec_digit => 0, :place => 0}
+        sections.push(sec)
+      when '%'
+        sec[:percent] = true
+        if sec[:decimal]
+          sec[:dec].push(percent_symbol)
+        else
+          sec[:int].push(percent_symbol)
+        end
+      when '\\'
+        escaped = true
+      else
+        if sec[:decimal]
+          sec[:dec].push(char)
+        else
+          sec[:int].push(char)
+        end
+      end
+    end
+
+    # choosing of the format (fmt)
+    need_minus_sign = false
+    case sections.size
+    when 1
+      need_minus_sign = (self < 0)
+      frm = sections[0]
+    when 2
+      if self >= 0
+        frm = sections[0]
+      else
+        frm = sections[1]
+      end
+    else
+      if self > 0
+        frm = sections[0]
+      elsif self < 0
+        frm = sections[1]
+      else
+        frm = sections[2]
+      end
+    end
+
+    value = self
+
+    value *= 100 if frm[:percent]
+    value = value.quo(10 ** frm[:place]) if frm[:place] != 0
+
+    int_part, dec_part = ("%.#{frm[:dec_digit]}f" % value.abs).split('.')
+
+    if self.nonzero? && int_part == '0' && !(dec_part =~ /[^0]/)
+      if sections[2]
+        frm = sections[2]
+        value = 0
+        int_part, dec_part = ("%.#{frm[:dec_digit]}f" % value.abs).split('.')
+      elsif self < 0 && sections[1]
+        frm = sections[0]
+        value = 0
+        int_part, dec_part = ("%.#{frm[:dec_digit]}f" % value.abs).split('.')
+      end
+    end
+
+    # formatting of integer part
+    first = 0
+    last = int_part.size - frm[:int_digit]
+    int_index = frm[:int_digit]
+    last_num = nil
+    frm[:int].each_with_index do |place_holder, index|
+      case place_holder
+      when :zero
+        if frm[:use_separater]
+          if first == last || last < 0
+            num = last < 0 ? '0' : int_part[first, 1]
+            if last_num && int_index % group_sizes == 0
+              frm[:int][index] = group_separator + num
+            elsif last_num.nil? && need_minus_sign
+              frm[:int][index] = '-' + num
+            else
+              frm[:int][index] = num
+            end
+          else
+            num = int_part[first..last]
+            i = (int_part.size - 1) % 3 + 1
+            while i < num.size
+              num.insert(i, group_separator)
+              i += 4
+            end
+            frm[:int][index] = last_num.nil? && need_minus_sign ? '-' + num : num
+          end
+        else
+          num = last < 0 ? '0' : int_part[first..last]
+          num = '-' + num if last_num.nil? && need_minus_sign
+          frm[:int][index] = num
+        end
+        first = (last += 1)
+        int_index -= 1
+        last_num = frm[:int][index]
+      when :sharp
+        if last < 0
+          frm[:int][index] = nil
+        elsif frm[:use_separater]
+          if first == last
+            if last_num && int_index % group_sizes == 0
+              frm[:int][index] = group_separator + int_part[first, 1]
+            elsif last_num.nil? && need_minus_sign
+              frm[:int][index] = '-' + int_part[first, 1]
+            else
+              frm[:int][index] = int_part[first, 1]
+            end
+          else
+            num = int_part[first..last]
+            i = (int_part.size - 1) % 3 + 1
+            while i < num.size
+              num.insert(i, group_separator)
+              i += 4
+            end
+            frm[:int][index] = last_num.nil? && need_minus_sign ? '-' + num : num
+          end
+        else
+          num = int_part[first..last]
+          num = '-' + num if last_num.nil? && need_minus_sign
+          frm[:int][index] = num
+        end
+        first = (last += 1)
+        int_index -= 1
+        last_num = frm[:int][index]
+      end
+    end
+
+    # formatting of decimal part
+    needs_replaceing = false
+    needs_decimal_separator = nil
+    dec_index = frm[:dec_digit]
+    (frm[:dec].size - 1).downto(0) do |index|
+      case frm[:dec][index]
+      when :zero
+        dec_index -= 1
+        frm[:dec][index] = dec_part[dec_index, 1]
+        needs_replaceing = true
+        needs_decimal_separator = decimal_separator
+      when :sharp
+        dec_index -= 1
+        if needs_replaceing || dec_part[dec_index, 1] != '0'
+          frm[:dec][index] = dec_part[dec_index, 1]
+          needs_replaceing = true
+          needs_decimal_separator = decimal_separator
+        else
+          frm[:dec][index] = nil
+        end
+      end
+    end
+
+    (frm[:int] + [needs_decimal_separator] + frm[:dec]).join
+  end
+end

data/test/path_command_test.rb

@@ -0,0 +1,217 @@
+# -*- encoding: UTF-8 -*-
+
+require 'test/unit'
+require File.join(File.dirname(__FILE__), '../lib/dyi')
+require 'pp'
+
+class PathCommandTest < Test::Unit::TestCase
+  def setup
+    @start_point = DYI::Coordinate.new([100,200])
+    @start_command = DYI::Shape::Path::MoveCommand.new(false, nil, @start_point)
+    @absolute_points = [[110,220],[80,180],[130,120],[60,200],[-30,100],[-85,165]].map{|pt| DYI::Coordinate.new(pt)}
+    @relative_points = [[10,20],[-30,-40],[50,-60],[-70,80],[-90,-100],[-55,65]].map{|pt| DYI::Coordinate.new(pt)}
+
+    @absolute_points_2 = [[70,160],[0,240],[-55,305]].map{|pt| DYI::Coordinate.new(pt)}
+    @absolute_points_3 = [[150,140],[95,205]].map{|pt| DYI::Coordinate.new(pt)}
+    @absolute_control_points_2 = [[110,220],[120,100],[-90,140]].map{|pt| DYI::Coordinate.new(pt)}
+    @absolute_control_points_3 = [[110,220],[70,160],[80,220],[60,40]].map{|pt| DYI::Coordinate.new(pt)}
+  end
+
+  def test_absolute_move_command
+    cmds = DYI::Shape::Path::MoveCommand.absolute_commands(nil, *([@start_point] + @absolute_points))
+    assert_equal(7, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(i == 0 ? DYI::Shape::Path::MoveCommand : DYI::Shape::Path::LineCommand, c)
+      assert(c.absolute?)
+      assert_equal(@start_point, c.start_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points[i-1], c.point)
+      assert_equal(i == 0 ? @start_point : @absolute_points[i-1], c.last_point)
+      assert_equal(case i
+                     when 0 then nil
+                     when 1 then @start_point
+                     else @absolute_points[i-2]
+                   end, c.preceding_point)
+    end
+  end
+
+  def test_relative_move_command
+    cmds = DYI::Shape::Path::MoveCommand.relative_commands(nil, *([@start_point] + @relative_points))
+    assert_equal(7, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(i == 0 ? DYI::Shape::Path::MoveCommand : DYI::Shape::Path::LineCommand, c)
+      assert(i == 0 ? c.absolute? : c.relative?)
+      assert_equal(i == 0 ? @start_point : @relative_points[i-1], c.point)
+      assert_equal(@start_point, c.start_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points[i-1], c.last_point)
+      assert_equal(case i
+                     when 0 then nil
+                     when 1 then @start_point
+                     else @absolute_points[i-2]
+                   end, c.preceding_point)
+    end
+  end
+
+  def test_absolute_line_command
+    cmds = DYI::Shape::Path::LineCommand.absolute_commands(@start_command, *@absolute_points)
+    assert_equal(6, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(DYI::Shape::Path::LineCommand, c)
+      assert(c.absolute?)
+      assert_equal(@absolute_points[i], c.point)
+      assert_equal(@start_point, c.start_point)
+      assert_equal(@absolute_points[i], c.last_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points[i-1], c.preceding_point)
+    end
+  end
+
+  def test_relative_line_command
+    cmds = DYI::Shape::Path::LineCommand.relative_commands(@start_command, *@relative_points)
+    assert_equal(6, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(DYI::Shape::Path::LineCommand, c)
+      assert(c.relative?)
+      assert_equal(@relative_points[i], c.point)
+      assert_equal(@start_point, c.start_point)
+      assert_equal(@absolute_points[i], c.last_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points[i-1], c.preceding_point)
+    end
+  end
+
+  def test_close_command
+    pre_cmd = DYI::Shape::Path::LineCommand.absolute_commands(@start_command, *@absolute_points).last
+    assert_raise(NoMethodError){DYI::Shape::Path::CloseCommand.absolute_commands(pre_cmd)}
+    assert_raise(NoMethodError){DYI::Shape::Path::CloseCommand.relative_commands(pre_cmd)}
+
+    cmds = DYI::Shape::Path::CloseCommand.commands(pre_cmd)
+    assert_equal(1, cmds.size)
+    cmd = cmds.first
+    assert_nil(cmd.point)
+    assert_equal(@start_point, cmd.start_point)
+    assert_equal(@start_point, cmd.last_point)
+    assert_equal(@absolute_points.last, cmd.preceding_point)
+  end
+
+  def test_absolute_curve_command
+    cmds = DYI::Shape::Path::CurveCommand.absolute_commands(@start_command, *@absolute_points)
+    assert_equal(2, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(DYI::Shape::Path::CurveCommand, c)
+      assert(c.absolute?)
+      assert_equal(@absolute_points[i*3+2], c.point)
+      assert_equal(@absolute_points[i*3,2], [c.control_point1,c.control_point2])
+      assert_equal(@start_point, c.start_point)
+      assert_equal(@absolute_points[i*3+2], c.last_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points[i*3-1], c.preceding_point)
+    end
+  end
+
+  def test_relative_curve_command
+    cmds = DYI::Shape::Path::CurveCommand.relative_commands(@start_command, *@relative_points)
+    assert_equal(2, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(DYI::Shape::Path::CurveCommand, c)
+      assert(c.relative?)
+      assert_equal(@relative_points[i*3+2], c.point)
+      assert_equal(@relative_points[i*3,2], [c.control_point1,c.control_point2])
+      assert_equal(@start_point, c.start_point)
+      assert_equal(@absolute_points_3[i], c.last_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points_3[i-1], c.preceding_point)
+    end
+  end
+
+  def test_absolute_shorthand_curve_command
+#               [100,200],[110,220],[80,180],[130,120], [60,200],[-30,100],[-85,165]
+    ctrl_pts = [[100,200],[110,220],[50,140],[130,120],[-10,280],[-30,100]].map{|pt| DYI::Coordinate.new(pt)}
+
+    cmds = DYI::Shape::Path::ShorthandCurveCommand.absolute_commands(@start_command, *@absolute_points)
+    assert_equal(3, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(DYI::Shape::Path::ShorthandCurveCommand, c)
+      assert(c.absolute?)
+      assert_equal(@absolute_points[i*2+1], c.point)
+      assert_equal(ctrl_pts[i*2,2], [c.control_point1,c.control_point2])
+      assert_equal(@start_point, c.start_point)
+      assert_equal(@absolute_points[i*2+1], c.last_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points[i*2-1], c.preceding_point)
+    end
+  end
+
+  def test_relative_shorthand_curve_command
+#           [100,200],[10,20],[-30,-40],[50,-60],  [-70,80],[-90,-100],[-55,65]
+    ctrl_pts = [[0,0],[10,20],[-40,-60],[50,-60],[-120,140],[-90,-100]].map{|pt| DYI::Coordinate.new(pt)}
+
+    cmds = DYI::Shape::Path::ShorthandCurveCommand.relative_commands(@start_command, *@relative_points)
+    assert_equal(3, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(DYI::Shape::Path::ShorthandCurveCommand, c)
+      assert(c.relative?)
+      assert_equal(@relative_points[i*2+1], c.point)
+      assert_equal(ctrl_pts[i*2,2], [c.control_point1,c.control_point2])
+      assert_equal(@start_point, c.start_point)
+      assert_equal(@absolute_points_2[i], c.last_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points_2[i-1], c.preceding_point)
+    end
+  end
+
+  def test_absolute_quadratic_curve_command
+    cmds = DYI::Shape::Path::QuadraticCurveCommand.absolute_commands(@start_command, *@absolute_points)
+    assert_equal(3, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(DYI::Shape::Path::QuadraticCurveCommand, c)
+      assert(c.absolute?)
+      assert_equal(@absolute_points[i*2+1], c.point)
+      assert_equal(@absolute_points[i*2], c.control_point)
+      assert_equal(@start_point, c.start_point)
+      assert_equal(@absolute_points[i*2+1], c.last_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points[i*2-1], c.preceding_point)
+    end
+  end
+
+  def test_relative_quadratic_curve_command
+    cmds = DYI::Shape::Path::QuadraticCurveCommand.relative_commands(@start_command, *@relative_points)
+    assert_equal(3, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(DYI::Shape::Path::QuadraticCurveCommand, c)
+      assert(c.relative?)
+      assert_equal(@relative_points[i*2+1], c.point)
+      assert_equal(@relative_points[i*2], c.control_point)
+      assert_equal(@start_point, c.start_point)
+      assert_equal(@absolute_points_2[i], c.last_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points_2[i-1], c.preceding_point)
+    end
+  end
+
+  def test_absolute_shorthand_quadratic_curve_command
+#               [100,200],[110,220],[80,180],[130,120],  [60,200],[-30,100],[-85,165]
+    ctrl_pts = [[100,200],[120,240],[40,120],[220,120],[-100,280],[40,-80]].map{|pt| DYI::Coordinate.new(pt)}
+
+    cmds = DYI::Shape::Path::ShorthandQuadraticCurveCommand.absolute_commands(@start_command, *@absolute_points)
+    assert_equal(6, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(DYI::Shape::Path::ShorthandQuadraticCurveCommand, c)
+      assert(c.absolute?)
+      assert_equal(@absolute_points[i], c.point)
+      assert_equal(ctrl_pts[i], c.control_point)
+      assert_equal(@start_point, c.start_point)
+      assert_equal(@absolute_points[i], c.last_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points[i-1], c.preceding_point)
+    end
+  end
+
+  def test_relative_shorthand_quadratic_curve_command
+#           [100,200],[10,20],[-30,-40],[50,-60], [-70,80],[-90,-100],[-55,65]
+    ctrl_pts = [[0,0],[10,20],[-40,-60],  [90,0],[-160,80],[70,-180]].map{|pt| DYI::Coordinate.new(pt)}
+
+    cmds = DYI::Shape::Path::ShorthandQuadraticCurveCommand.relative_commands(@start_command, *@relative_points)
+    assert_equal(6, cmds.size)
+    cmds.each_with_index do |c, i|
+      assert_kind_of(DYI::Shape::Path::ShorthandQuadraticCurveCommand, c)
+      assert(c.relative?)
+      assert_equal(@relative_points[i], c.point)
+      assert_equal(ctrl_pts[i], c.control_point)
+      assert_equal(@start_point, c.start_point)
+      assert_equal(@absolute_points[i], c.last_point)
+      assert_equal(i == 0 ? @start_point : @absolute_points[i-1], c.preceding_point)
+    end
+  end
+end

data/test/test_length.rb

@@ -0,0 +1,91 @@
+require 'test/unit'
+require '../lib/dyi/length'
+
+class TC_Length < Test::Unit::TestCase
+  include DYI
+  
+  def setup
+    @one_px = Length.new(1)
+  end
+  
+  def test_initialize
+    assert_not_nil @one_px
+    assert Length.new(3)
+    assert_instance_of(Length, @one_px)
+    
+    assert equal_f?(1, @one_px)
+    assert equal_f?(@one_px, Length.new(@one_px))
+    assert equal_f?(Length.new(0), Length::ZERO)
+    
+    assert_same(@one_px, Length.new(@one_px))
+  end
+  
+  def test_unit_conversion
+    assert equal_f?(Length.new('4px'), Length.new(4))
+    
+    assert equal_f?(1, Length.new('1px').to_f)
+    assert equal_f?(1.25, Length.new('1pt').to_f)
+    assert equal_f?(35.43307, Length.new('1cm').to_f)
+    assert equal_f?(3.543307, Length.new('1mm').to_f)
+    assert equal_f?(90.0, Length.new('1in').to_f)
+    assert equal_f?(15.0, Length.new('1pc').to_f)
+    
+    assert equal_f?(Length.new('1px') * 1.25, Length.new('1pt'))
+    assert equal_f?(Length.new('1px') * 35.43307, Length.new('1cm'))
+    assert equal_f?(Length.new('1px') * 3.543307, Length.new('1mm'))
+    assert equal_f?(Length.new('1px') * 90.0, Length.new('1in'))
+    assert equal_f?(Length.new('1px') * 15.0, Length.new('1pc'))
+    
+    assert equal_f?(1.25, Length.new('1px') * 1.25)
+    assert equal_f?(1.25, Length.new('1cm') * 1.25 / 35.43307)
+    assert equal_f?(1.25, Length.new('1mm') * 1.25 / 3.543307)
+    assert equal_f?(1.25, Length.new('1in') * 1.25 / 90.0)
+    assert equal_f?(1.25, Length.new('1pc') * 1.25 / 15.0)
+  end
+  
+  def test_unary
+    assert equal_f?(@one_px, +@one_px)
+    assert equal_f?(Length.new(-2), -Length.new(2))
+  end
+  
+  def test_binary_operator
+    assert equal_f?(3+5, Length.new(3) + Length.new(5))
+    assert equal_f?(4.2+5.3, Length.new(4.2) + Length.new(5.3))
+    assert equal_f?(Length.new(5 + 2), Length.new(5) + 2)
+    
+    assert equal_f?(12 - 5, Length.new(12) - Length.new(5))
+    assert equal_f?(4.2 - 5.3, Length.new(4.2) - Length.new(5.3))
+    assert equal_f?(Length.new(7 - 4), Length.new(7) - Length.new(4))
+    assert equal_f?(Length.new(7 - 4), Length.new(7) - 4)
+    
+    assert equal_f?(4 * 7, Length.new(4) * 7)
+    assert equal_f?(3.82 * 1.2, Length.new(3.82) * 1.2)
+    assert_raise(TypeError){
+      Length.new(4) * Length.new(7)
+    }
+    
+    assert equal_f?(5 ** 3, Length.new(5) ** 3)
+    assert_raise(TypeError){
+      Length.new(5) ** Length.new(3)
+    }
+    
+    assert equal_f?(6 / 5, Length.new(6).div(Length.new(5)))
+    assert_raise(TypeError){
+      Length.new(6).div(2)
+    }
+    
+    assert equal_f?(7 % 5, Length.new(7) % Length.new(5))
+    assert_raise(TypeError){
+      Length.new(2) % 3
+    }
+    
+    assert equal_f?(3.82 / 1.2, Length.new(3.82) / 1.2)
+    assert equal_f?(4 / 2, Length.new(4) / Length.new(2))
+  end
+  
+  private
+  
+  def equal_f?(left, right)
+    (left.to_f - right.to_f).abs <= 0.0000001
+  end
+end