dyi 0.0.2 → 1.0.0

data/lib/dyi/canvas.rb

@@ -0,0 +1,202 @@
+# -*- 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/>.
+
+module DYI #:nodoc:
+
+  class Canvas < GraphicalElement
+    IMPLEMENT_ATTRIBUTES = [:view_box, :preserve_aspect_ratio]
+    attr_length :width, :height
+    attr_reader *IMPLEMENT_ATTRIBUTES
+    attr_reader :child_elements
+    # @since 1.0.0
+    attr_reader :event_listeners, :stylesheets
+
+    def initialize(width, height,
+                   real_width = nil, real_height = nil,
+                   preserve_aspect_ratio='none', options={})
+      self.width = width
+      self.height = height
+      @view_box = "0 0 #{width} #{height}"
+      @preserve_aspect_ratio = preserve_aspect_ratio
+      @child_elements = []
+      @scripts = []
+      @event_listeners = {}
+      @stylesheets = []
+      @seed_of_id = -1
+      @receive_event = false
+      self.css_class = options[:css_class]
+      self.real_width = real_width
+      self.real_height = real_height
+    end
+
+    def real_width
+      @real_width || width
+    end
+
+    def real_width=(width)
+      @real_width = Length.new_or_nil(width)
+    end
+
+    def real_height
+      @real_height || height
+    end
+
+    def real_height=(height)
+      @real_height = Length.new_or_nil(height)
+    end
+
+    # This method is depricated; use Canvas#root_element?
+    # @deprecated
+    def root_node?
+      msg = [__FILE__, __LINE__, ' waring']
+      msg << ' DYI::Canvas#root_node? is depricated; use DYI::Canvas#root_element?'
+      warn(msg.join(':'))
+      true
+    end
+
+    # @since 1.0.0
+    def root_element?
+      true
+    end
+
+    # Returns the canvas where the shape is drawn
+    # @return [Canvas] the canvas where the shape is drawn
+    # @since 1.0.0
+    def canvas
+      self
+    end
+
+    # @since 1.0.0
+    def event_listeners
+      @event_listeners ||= {}
+    end
+
+    def write_as(formatter, io=$>)
+      formatter.write_canvas(self, io)
+    end
+
+    def save(file_name, format=nil, options={})
+      get_formatter(format).save(file_name, options)
+    end
+
+    def puts_in_io(format=nil, io=$>)
+      get_formatter(format).puts(io)
+    end
+
+    def string(format=nil)
+      get_formatter(format).string
+    end
+
+    def attributes #:nodoc:
+      IMPLEMENT_ATTRIBUTES.inject({}) do |hash, attribute|
+        variable_name = '@' + attribute.to_s.split(/(?=[A-Z])/).map{|str| str.downcase}.join('_')
+        value = instance_variable_get(variable_name)
+        hash[attribute] = value.to_s if value
+        hash
+      end
+    end
+
+    # Create a new id for a descendant element
+    # @return [String] new id for a descendant element
+    # @since 1.0.0
+    def publish_shape_id
+      'elm%04d' % (@seed_of_id += 1)
+    end
+
+    # @since 1.0.0
+    def set_event(event)
+      super
+      @receive_event = true
+    end
+
+    # @return [Boolean] whether event is set to the shape
+    # @since 1.0.0
+    def receive_event?
+      @receive_event
+    end
+
+    # @since 1.0.0
+    def scripts
+      @init_script ? [@init_script].push(*@scripts) : @scripts
+    end
+
+    # @since 1.0.0
+    def add_script(script_body, content_type = 'application/ecmascript')
+      @scripts << Script::SimpleScript.new(script_body, content_type)
+    end
+
+    # @since 1.0.0
+    def reference_script_file(reference_path, content_type = 'application/ecmascript')
+      @scripts << Script::ScriptReference.new(reference_path, content_type)
+    end
+
+    # @since 1.0.0
+    def add_stylesheet(style_body, content_type = 'text/css')
+      @stylesheets << Stylesheet::Style.new(style_body, content_type)
+    end
+
+    # @since 1.0.0
+    def reference_stylesheet_file(reference_path, content_type = 'text/css')
+      @stylesheets << Stylesheet::StyleReference.new(reference_path, content_type)
+    end
+
+    # @since 1.0.0
+    def add_initialize_script(script_body)
+      if @init_script
+        @init_script = Script::EcmaScript::EventListener.new(
+            @init_script.instance_variable_get(:@body) + script_body, 'init')
+      else
+        @init_script = Script::EcmaScript::EventListener.new(script_body, 'init')
+        add_event_listener(:load, @init_script)
+      end
+    end
+
+    # @since 1.0.0
+    def add_event_listener(event_name, event_listener)
+      if event_listeners.key?(event_name)
+        unless event_listeners[event_name].include?(event_listener)
+          event_listeners[event_name] << event_listener
+        end
+      else
+        event_listeners[event_name] = [event_listener]
+      end
+    end
+
+    # @since 1.0.0
+    def remove_event_listener(event_name, event_listener)
+      if event_listeners.key?(event_name)
+        event_listeners[event_name].delete(event_listener)
+      end
+    end
+
+    private
+
+    def get_formatter(format=nil) #:nodoc:
+      case format
+        when :svg, nil then Formatter::SvgFormatter.new(self, 2)
+        when :xaml then Formatter::XamlFormatter.new(self, 2)
+        when :eps then Formatter::EpsFormatter.new(self)
+        when :png then Formatter::PngFormatter.new(self)
+        else raise ArgumentError, "`#{format}' is unknown format"
+      end
+    end
+  end
+end

data/lib/dyi/chart.rb

@@ -22,6 +22,8 @@
 %w(
 
 base
+legend
+axis_util
 line_chart
 pie_chart
 table

data/lib/dyi/chart/array_reader.rb

@@ -23,95 +23,94 @@ module DYI #:nodoc:
   module Chart #:nodoc:
 
     class ArrayReader
+      include Enumerable
 
       def [](i, j)
-        @data[i][j]
+        @records[i].values[j]
       end
 
-      def row_title(i)
-        @row_titles[i]
+      # @return [Array] array of a struct
+      # @since 1.0.0
+      def records
+        @records.dup
       end
 
-      def column_title(j)
-        @col_titles[j]
+      # @return [Integer] number of the records
+      # @since 1.0.0
+      def records_size
+        @records.size
       end
 
-      def row_values(i)
-        @data[i].dup
+      # @return [Integer] number of the values
+      # @since 1.0.0
+      def values_size
+        @records.first.values.size rescue 0
       end
 
-      def column_values(j)
-        @data.map{|r| r[j]}
-      end
-
-      def row_count
-        @data.size
-      end
-
-      def column_count
-        @data.first.size
+      def clear_data
+        @records.clear
       end
 
-      def clear_data
-        @data.clear
-        @col_titles.clear
-        @row_titles.clear
+      # @return [void]
+      # @since 1.0.0
+      def values_each(&block)
+        @records.each do |record|
+          yield record.values
+        end
       end
 
-      def values
-        @data.dup
+      # @param [Integer] index index of series
+      # @return [Array]
+      # @since 1.0.0
+      def series(index)
+        @records.map do |record|
+          record.values[index]
+        end
       end
 
-      def column_titles
-        @col_titles.dup
+      # @since 1.0.0
+      def has_field?(field_name)
+        @schema.members.include?(field_name.to_s)
       end
 
-      def row_titles
-        @row_titles.dup
+      # @return [void]
+      # @since 1.0.0
+      def each(&block)
+        @records.each(&block)
       end
 
       def initialize
-        @data = []
-        @col_titles = []
-        @row_titles = []
+        @records = []
       end
 
       def read(array_of_array, options={})
         clear_data
+        row_range = options[:row_range] || (0..-1)
+        col_range = options[:column_range] || (0..-1)
+        schema = options[:schema] || [:value]
         data_types = options[:data_types] || []
-        row_skip = (options[:row_skip].to_i rescue 0)
-        col_skip = (options[:column_skip].to_i rescue 0)
-        title_row = ((options[:title_row] ? options[:title_row].to_i : nil) rescue nil)
-        title_col = ((options[:title_column] ? options[:title_column].to_i : nil) rescue nil)
-        row_limit = ((options[:row_limit] ? options[:row_limit].to_i : nil) rescue nil)
-        row_proc = options[:row_proc]
-        array_of_array.each_with_index do |row, i|
-          unless options[:transposed]
-            if i == title_row
-              @col_titles.replace(row[col_skip..-1].map{|v| primitive_title_value(v)})
-            end
-            next if i < row_skip
-            break if row_limit && row_limit + row_skip <= i
-            next if row_proc.respond_to?(:call) && !row_proc.call(*row[col_skip..-1])
-            @row_titles << primitive_title_value(row[title_col]) if title_col
-            vals = []
-            row[col_skip..-1].each_with_index do |value, j|
-              vals << primitive_value(value, data_types[j])
-            end
-            @data << vals
-          else
-            row_limit_number = row_limit ? row_limit + row_skip - 1 : -1
-            if i == title_col
-              @row_titles.replace(row[row_skip..row_limit_number].map{|v| primitive_title_value(v)})
-            end
-            next if i < col_skip
-            vals = row[row_skip..row_limit_number]
-            @data.replace(vals.map{|value| []}) if @data.empty?
-            @col_titles << primitive_title_value(row[title_row]) if title_row
-            vals.each_with_index do |value, j|
-              @data[j] << primitive_value(value, data_types[i])
+#        row_proc = options[:row_proc]
+        @schema = record_schema(schema)
+        array_of_array = transpose(array_of_array) if options[:transposed]
+
+        array_of_array[row_range].each do |row|
+          record_source = []
+          values = []
+          has_set_value = false
+          row[col_range].each_with_index do |cell, i|
+            cell = primitive_value(cell, data_types[i])
+            if schema[i].nil? || schema[i].to_sym == :value
+              unless has_set_value
+                record_source << cell
+                has_set_value = true
+              end
+              values << cell
+            else
+              record_source << cell
             end
           end
+          record_source << values
+          @records << @schema.new(*record_source)
         end
         self
       end
@@ -122,8 +121,58 @@ module DYI #:nodoc:
         value
       end
 
-      def primitive_title_value(value, type=nil)
-        primitive_value(value, type)
+      # Transposes row and column of array-of-array.
+      # @example
+      #   transpose([[0,1,2],[3,4,5]]) => [[0,3],[1,4],[2,5]]
+      # @param [Array] array_of_array array of array
+      # @return [Array] transposed array
+      # @since 1.0.0
+      def transpose(array_of_array)
+        transposed_array = []
+        array_of_array.each_with_index do |row, i|
+          row.each_with_index do |cell, j|
+            transposed_array[j] ||= Array.new(i)
+            transposed_array[j] << cell
+          end
+        end
+        transposed_array
+      end
+
+      # @param [Array] schema of the record
+      # @return [Class] subclass of Struct class
+      # @since 1.0.0
+      def record_schema(schema)
+        struct_schema =
+            schema.inject([]) do |result, name|
+              if result.include?(name.to_sym)
+                if name.to_sym == :value
+                  next result
+                else
+                  raise ArgumentError, "schema option has a duplicate name: `#{name}'"
+                end
+              end
+              if name.to_sym == :values
+                raise ArgumentError, "schema option may not contain `:values'"
+              end
+              result << name.to_sym
+            end
+        struct_schema << :values
+        Struct.new(*struct_schema)
+      end
+
+      # Makes the instance respond to xxx_values method.
+      # @example
+      #   data = ArrayReader.read([['Smith', 20, 3432], ['Thomas', 25, 9721]],
+      #                           :schema => [:name, :age, :value])
+      #   data.name_vlaues  # => ['Smith', 'Thomas']
+      #   data.age_values   # => [20, 25]
+      # @since 1.0.0
+      def method_missing(name, *args)
+        if args.size == 0 && name.to_s =~ /_values\z/ && @schema.members.include?($`)
+          @records.map{|r| r.__send__($`)}
+        else
+          super
+        end
       end
 
       class << self

data/lib/dyi/chart/axis_util.rb

@@ -0,0 +1,298 @@
+# -*- 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/>.
+
+require 'csv'
+
+module DYI #:nodoc:
+  module Chart #:nodoc:
+
+    module AxisUtil
+
+      private
+
+      def moderate_axis(data, axis_length, min=nil, max=nil, scale_count_limit=nil)
+        raise ArgumentError, 'no data' if (data = data.flatten.compact).empty?
+
+        axis_length = Length.new(axis_length)
+        data_min, data_max = chart_range(data, min, max)
+
+        base_value = base_value(data_min, data_max, min.nil?, max.nil?)
+        scale_count_limit ||= (axis_length / Length.new(30)).to_i
+        scale_count_limit = 10 if 10 < scale_count_limit
+        scale_count_limit = 2 if scale_count_limit < 2
+        scale_interval = scale_interval(base_value, data_min, data_max, scale_count_limit)
+        min_scale_value = nil
+        (base_value + scale_interval).step(data_min, -scale_interval) {|n| min_scale_value = n}
+        min ||= (min_scale_value.nil? ? base_value : min_scale_value - scale_interval)
+        min_scale_value ||= min + scale_interval
+        unless max
+          base_value.step(data_max, scale_interval) {|n| max = n}
+          max += scale_interval if max < data_max
+        end
+        {
+          :min => min || min_scale_value - scale_interval,
+          :max => max,
+          :axis_length => axis_length,
+          :min_scale_value => min_scale_value,
+          :scale_interval => scale_interval
+        }
+      end
+
+      def top_digit(num, n=1) #:nodoc:
+        num.div(10 ** (figures_count(num) - n + 1))
+      end
+
+      def suitable_1digit_value(a, b) #:nodoc:
+        return a if a == b
+        a, b = b, a if a > b
+        return 0 if a == 0
+        return 5 if a <= 5 && 5 <= b
+        return 2 if a <= 2 && 2 <= b
+        return 4 if a <= 4 && 4 <= b
+        return 6 if a <= 6 && 6 <= b
+        8
+      end
+
+      def figures_count(num) #:nodoc:
+        Math.log10(num).floor
+      end
+
+      def base_value(a, b, allow_under=true, allow_over=true) #:nodoc:
+        return 0 if a * b <= 0 || a == b
+        a, b = -a, -b if negative = (a < 0)
+        a, b = b, a if a > b
+        return 0 if ((negative && allow_over) || (!negative && allow_under)) &&  a < b * 0.3 
+        suitable_value_positive(a, b) * (negative ? -1 : 1)
+      end
+
+      def suitable_value_positive(a, b) #:nodoc:
+        if figures_count(a) != (dig = figures_count(b))
+          return 10 ** dig
+        end
+        n = 1
+        n += 1 while (dig_a = top_digit(a, n)) == (dig_b = top_digit(b, n))
+        (suitable_1digit_value(dig_a - dig_a.div(10) * 10 + (dig_a == dig_a.div(10) * 10 ? 0 : 1), dig_b - dig_b.div(10) * 10) + dig_a.div(10) * 10) * (10 ** (dig - figures_count(dig_a)))
+      end
+
+      def scale_interval(base_value, data_min, data_max, scale_count_limit) #:nodoc:
+        if base_value - data_min < data_max - base_value
+          allocate_scale_count = (data_max - base_value).div((data_max - data_min).quo(scale_count_limit))
+          scale_interval_base2edge(base_value, data_max, allocate_scale_count)
+        else
+          allocate_scale_count = (base_value - data_min).div((data_max - data_min).quo(scale_count_limit))
+          scale_interval_base2edge(base_value, data_min, allocate_scale_count)
+        end
+      end
+
+      def scale_interval_base2edge(base_value, edge_value, scale_count_limit) #:nodoc:
+        raise ArgumentError, 'base_value should not equal edge_value' if edge_value == base_value
+        range = (base_value - edge_value).abs
+
+        top_2_digits = top_digit(range, 2)
+        case scale_count_limit.to_i
+          when 1
+            case top_2_digits
+              when 10 then label_range = 10
+              when 11..20 then label_range = 20
+              when 21..40 then label_range = 40
+              when 41..50 then label_range = 50
+              when 51..99 then label_range = 100
+            end
+          when 2
+            case top_2_digits
+              when 10 then label_range = 5
+              when 11..20 then label_range = 10
+              when 21..40 then label_range = 20
+              when 41..50 then label_range = 25
+              when 51..99 then label_range = 50
+            end
+          when 3
+            case top_2_digits
+              when 10 then label_range = 4
+              when 11..15 then label_range = 5
+              when 16..30 then label_range = 10
+              when 31..60 then label_range = 20
+              when 61..75 then label_range = 25
+              when 76..99 then label_range = 40
+            end
+          when 4
+            case top_2_digits
+              when 10 then label_range = 2.5
+              when 11..15 then label_range = 4
+              when 16..20 then label_range = 5
+              when 21..40 then label_range = 10
+              when 41..80 then label_range = 20
+              when 81..99 then label_range = 25
+            end
+          when 5
+            case top_2_digits
+              when 10 then label_range = 2
+              when 11..12 then label_range = 2.5
+              when 13..15 then label_range = 4
+              when 16..25 then label_range = 5
+              when 26..50 then label_range = 10
+              when 51..99 then label_range = 20
+            end
+          when 6
+            case top_2_digits
+              when 10..12 then label_range = 2
+              when 13..15 then label_range = 2.5
+              when 16..20 then label_range = 4
+              when 21..30 then label_range = 5
+              when 31..60 then label_range = 10
+              when 61..99 then label_range = 20
+            end
+          when 7
+            case top_2_digits
+              when 10..14 then label_range = 2
+              when 15..17 then label_range = 2.5
+              when 18..20 then label_range = 4
+              when 21..35 then label_range = 5
+              when 35..70 then label_range = 10
+              when 71..99 then label_range = 20
+            end
+          when 8
+            case top_2_digits
+              when 10..16 then label_range = 2
+              when 17..20 then label_range = 2.5
+              when 21..25 then label_range = 4
+              when 26..40 then label_range = 5
+              when 41..80 then label_range = 10
+              when 81..99 then label_range = 20
+            end
+          when 9
+            case top_2_digits
+              when 10..18 then label_range = 2
+              when 19..22 then label_range = 2.5
+              when 23..30 then label_range = 4
+              when 31..45 then label_range = 5
+              when 46..90 then label_range = 10
+              when 91..99 then label_range = 20
+            end
+          else
+            case top_2_digits
+              when 10 then label_range = 1
+              when 11..20 then label_range = 2
+              when 21..25 then label_range = 2.5
+              when 26..30 then label_range = 4
+              when 31..50 then label_range = 5
+              when 51..99 then label_range = 10
+            end
+        end
+        label_range * (10 ** (figures_count(range) - 1))
+      end
+
+      def moderate_sub_axis(data, main_axis_settings, min=nil, max=nil)
+        if min && max
+          axis_ratio = (max - min).quo(main_axis_settings[:max] - main_axis_settings[:min])
+          return {
+            :max => max,
+            :min => min,
+            :min_scale_value => min + (main_axis_settings[:min_scale_value] - main_axis_settings[:min]) * axis_ratio,
+            :axis_length => main_axis_settings[:axis_length],
+            :scale_interval => main_axis_settings[:scale_interval] * axis_ratio
+          }
+        end
+        scale_count = (main_axis_settings[:max] - main_axis_settings[:min_scale_value]).div(main_axis_settings[:scale_interval]) + (main_axis_settings[:min_scale_value] == main_axis_settings[:min] ? 0 : 1)
+        data_min, data_max = chart_range(data, min, max)
+
+        base_value = base_value(data_min, data_max, min.nil?, max.nil?)
+
+        scale_interval = scale_interval(base_value, data_min, data_max, scale_count)
+        min_scale_value = nil
+        (base_value + scale_interval).step(data_min, -scale_interval) {|n| min_scale_value = n}
+        min ||= (min_scale_value.nil? ? base_value : min_scale_value - scale_interval)
+        min_scale_value ||= min + scale_interval
+        max = scale_interval * scale_count + min
+
+        {
+          :min => min || min_scale_value - scale_interval,
+          :max => max,
+          :axis_length => main_axis_settings[:axis_length],
+          :min_scale_value => min_scale_value,
+          :scale_interval => scale_interval
+        }
+      end
+
+      def chart_range(data, min=nil, max=nil)
+        data = data.compact.flatten
+        if min.nil? && max.nil?
+          data_min, data_max = 
+            data.inject([nil, nil]) do |(_min, _max), value|
+              [value < (_min ||= value) ? value : _min,  (_max ||= value) < value ? value : _max]
+            end
+        elsif min && max && max < min
+          data_min, data_max = max, min
+        else
+          data_min = min || [data.min, max].min
+          data_max = max || [data.max, min].max
+        end
+
+        if data_min == data_max
+          if data_min > 0
+            data_min = 0
+          elsif data_max < 0
+            data_max = 0
+          else
+            data_min = 0
+            data_max = 100
+          end
+        end
+        [data_min, data_max]
+      end
+
+      def value_position_on_chart(chart_margin, axis_settings, value, reverse_direction = false)
+        axis_settings[:axis_length] * 
+          ((reverse_direction ? (axis_settings[:max] - value) : (value - axis_settings[:min])).to_f / (axis_settings[:max] - axis_settings[:min])) + 
+          Length.new(chart_margin)
+      end
+
+      def order_position_on_chart(chart_margin, axis_length, count, index, type=:point, renge_width_ratio=0, reverse_direction=false)
+        chart_margin = Length.new(chart_margin)
+        pos =
+            case type
+              when :point then index.to_f / (count - 1)
+              when :range then (index + 0.5 - renge_width_ratio.to_f / 2) / count
+              else raise ArgumentError, "\"#{type}\" is invalid type"
+            end
+        axis_length * pos + chart_margin
+      end
+
+      def round_top_2_digit(max, min) #:nodoc:
+        digit = Math.log10([max.abs, min.abs].max).floor - 1
+        [max.quo(10 ** digit).ceil * (10 ** digit), min.quo(10 ** digit).floor * (10 ** digit)]
+      end
+
+      def min_scale_value(max, min, scale_interval) #:nodoc:
+        return scale_interval if min == 0
+        if (max_digit = Math.log10(max).to_i) != Math.log10(min).to_i
+          base_value = 10 ** max_digit
+        elsif max.div(10 ** max_digit) != min.div(10 ** max_digit)
+          base_value = 9 * 10 ** max_digit
+        else
+          range_digit = Math.log10(max - min).floor
+          base_value = max.div(10 ** range_digit) * (10 ** range_digit)
+        end
+        base_value - ((base_value - min).quo(scale_interval).ceil - 1) * scale_interval
+      end
+    end
+  end
+end