charts 0.0.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4da2755eb0417c5b0c4745ba3c48731b7885b976
+  data.tar.gz: aa2f198109cf7b2778a0e96a373d26f28747c613
+SHA512:
+  metadata.gz: aeb9f5516f4c5f4636158833639d369a1ab67c9b2b1a7a5beda73d13512a6fb78c981372c608ac13abf11171c51f22b0892a3caf6db58bece66418bce3111ae8
+  data.tar.gz: c7500f8d6819e229ef05890ace09bc27b66d597afd71bae33bd83adab7ff4b2a692e54dda9fdf18850ca4bbd5b9fa9b6f4a10117308d2c5e9c2c301962ee61db

data/lib/charts/bar_chart/bar/bar.rb

@@ -0,0 +1,34 @@
+class Charts::BarChart::Bar
+  attr_reader :graph, :data_value, :set_nr, :bar_nr_in_set
+
+  def initialize(graph, data_value, set_nr, bar_nr_in_set)
+    @graph = graph
+    @data_value = data_value
+    @set_nr = set_nr
+    @bar_nr_in_set = bar_nr_in_set
+  end
+
+  def draw
+    graph.renderer.rect x, y, width, height, fill: graph.colors[set_nr], class: 'bar'
+  end
+
+  def x
+    raise NotImplementedError
+  end
+
+  def y
+    raise NotImplementedError
+  end
+
+  def width
+    raise NotImplementedError
+  end
+
+  def height
+    raise NotImplementedError
+  end
+
+  def bar_number_in_graph
+    set_nr + bar_nr_in_set * graph.set_count
+  end
+end

data/lib/charts/bar_chart/bar/horizontal_bar.rb

@@ -0,0 +1,33 @@
+class Charts::BarChart::HorizontalBar < Charts::BarChart::Bar
+  def x
+    x_margin + x_offset
+  end
+
+  def x_margin
+    graph.outer_margin
+  end
+
+  def x_offset
+    graph.inner_width * [data_value, graph.base_line].min
+  end
+
+  def y
+    (y_margin + y_offset).floor.to_i
+  end
+
+  def y_margin
+    graph.outer_margin + graph.bar_margin + graph.group_margin * bar_nr_in_set
+  end
+
+  def y_offset
+    graph.bar_outer_width * bar_number_in_graph
+  end
+
+  def width
+    graph.inner_width * (data_value - graph.base_line).abs
+  end
+
+  def height
+    graph.bar_inner_width.floor.to_i
+  end
+end

data/lib/charts/bar_chart/bar/vertical_bar.rb

@@ -0,0 +1,33 @@
+class Charts::BarChart::VerticalBar < Charts::BarChart::Bar
+  def x
+    (x_margin + x_offset).floor.to_i
+  end
+
+  def x_margin
+    graph.outer_margin + graph.bar_margin + graph.group_margin * bar_nr_in_set
+  end
+
+  def x_offset
+    graph.bar_outer_width * bar_number_in_graph
+  end
+
+  def y
+    y_margin + y_offset
+  end
+
+  def y_margin
+    graph.outer_margin
+  end
+
+  def y_offset
+    graph.inner_height * [(1 - data_value), (1 - graph.base_line)].min
+  end
+
+  def width
+    graph.bar_inner_width.floor.to_i
+  end
+
+  def height
+    graph.inner_height * (data_value - graph.base_line).abs
+  end
+end

data/lib/charts/bar_chart/bar_chart.rb

@@ -0,0 +1,130 @@
+class Charts::BarChart < Charts::Chart
+  include Charts::Grid
+  include Charts::Legend
+
+  attr_reader :max_value,
+              :min_value,
+              :set_count,
+              :group_count,
+              :total_bar_count,
+              :base_line
+
+  def initialize_instance_variables
+    @set_count = data.count
+    @group_count = data.map(&:count).max
+    @total_bar_count = set_count * group_count
+    @max_value = calc_max
+    @min_value = calc_min
+    @base_line = calc_base_line
+  end
+
+  def default_options
+    super.merge(
+      width:        600,
+      height:       400,
+      include_zero: true,
+      group_margin: 20,
+      bar_margin:   3,
+      label_height: 20,
+      label_margin: 10,
+      direction:    :vertical
+    )
+  end
+
+  def validate_arguments(data, options)
+    super(data, options)
+    raise ArgumentError unless data.is_a? Array
+  end
+
+  def prepare_data
+    data.map do |set|
+      set.map do |value|
+        value.nil? ? nil : normalize(value)
+      end
+    end
+  end
+
+  def pre_draw
+    super
+    draw_grid
+    draw_group_labels
+    draw_labels
+  end
+
+  def draw_group_labels
+    return if options[:group_labels].nil? || group_labels.empty?
+    raise ArgumentError if group_labels.count != group_count
+    group_label_style = {
+      text_anchor:  'middle',
+      writing_mode: (vertical? ? 'lr' : 'tb'),
+      class:        'group_label'
+    }
+    group_labels.each_with_index do |group_label, i|
+      if vertical?
+        x = outer_margin + (i + 0.5) * all_bars_width / group_count + i * group_margin
+        y = outer_margin + inner_height + renderer.font_size
+      else
+        x = outer_margin - renderer.font_size
+        y = outer_margin + (i + 0.5) * all_bars_width / group_count + i * group_margin
+      end
+      renderer.text group_label, x, y, group_label_style
+    end
+  end
+
+  def draw
+    prepared_data.each_with_index do |set, set_nr|
+      set.each_with_index do |data_value, bar_nr_in_set|
+        bar_class = vertical? ? VerticalBar : HorizontalBar
+        bar_class.new(self, data_value, set_nr, bar_nr_in_set).draw unless data_value.nil?
+      end
+    end
+  end
+
+  def inner_width
+    width - 2 * outer_margin
+  end
+
+  def bar_inner_width
+    bar_outer_width - 2 * bar_margin
+  end
+
+  def bar_outer_width
+    all_bars_width.to_f / total_bar_count
+  end
+
+  def all_bars_width
+    (vertical? ? inner_width : inner_height) - sum_of_group_margins
+  end
+
+  def sum_of_group_margins
+    (group_count - 1) * group_margin
+  end
+
+  def inner_height
+    height - 2 * outer_margin - label_total_height
+  end
+
+  def calc_max
+    max = data.map{ |d| d.reject(&:nil?).max }.max
+    max = 0 if max < 0 && include_zero
+    options[:max] || max
+  end
+
+  def calc_min
+    min = data.map{ |d| d.reject(&:nil?).min }.min
+    min = 0 if min > 0 && include_zero
+    options[:min] || min
+  end
+
+  def calc_base_line
+    [[normalize(0), 0].max, 1].min # zero value normalized and clamped between 0 and 1
+  end
+
+  def normalize(value)
+    (value.to_f - min_value) / (max_value - min_value)
+  end
+
+  def vertical?
+    direction == :vertical
+  end
+end

data/lib/charts/bar_chart/grid/grid.rb

@@ -0,0 +1,48 @@
+module Charts::Grid
+  def draw_grid
+    lines.each { |l| l.draw }
+  end
+
+  def lines
+    grid_line_class = vertical? ? HorizontalGridLine : VerticalGridLine
+    grid_line_values.map { |v| grid_line_class.new(self, v) }
+  end
+
+  def grid_line_values
+    (0..number_of_grid_lines).map do |i|
+      value = i.to_f * rounded_spread / number_of_grid_lines + min_value
+      if spread_log10 < 1
+        value.round(-spread_order_of_magnitude + 1)
+      else
+        value.round
+      end
+    end
+  end
+
+  def number_of_grid_lines
+    (3..7).find { |line_count| spread_factor % line_count == 0 } || 4
+  end
+
+  def spread
+    max_value - min_value
+  end
+
+  def spread_order_of_magnitude
+    spread_log10.floor
+  end
+
+  def spread_log10
+    Math.log10(spread)
+  end
+
+  def rounded_spread
+    rs = spread_factor * 10 ** spread_order_of_magnitude
+    spread_log10 % 1 == 0 ? rs / 10 : rs
+  end
+
+  def spread_factor
+    f = (spread.to_f / 10 ** spread_order_of_magnitude).floor
+    spread_log10 % 1 == 0 ? 10 * f : f
+  end
+
+end

data/lib/charts/bar_chart/grid/grid_line.rb

@@ -0,0 +1,45 @@
+class Charts::Grid::GridLine
+  attr_accessor :graph, :value
+
+  def initialize(graph, value)
+    @graph = graph
+    @value = value
+  end
+
+  def draw
+    graph.renderer.line x1, y1, x2, y2, graph.renderer.grid_line_style
+    graph.renderer.text label_text, label_x, label_y, label_style
+  end
+
+  def x1
+    raise NotImplementedError
+  end
+
+  def x2
+    raise NotImplementedError
+  end
+
+  def y1
+    raise NotImplementedError
+  end
+
+  def y2
+    raise NotImplementedError
+  end
+
+  def label_x
+    raise NotImplementedError
+  end
+
+  def label_y
+    raise NotImplementedError
+  end
+
+  def label_text
+    if graph.spread_order_of_magnitude <= 0
+      value.to_f
+    else
+      value
+    end
+  end
+end

data/lib/charts/bar_chart/grid/horizontal_grid_line.rb

@@ -0,0 +1,29 @@
+class Charts::Grid::HorizontalGridLine < Charts::Grid::GridLine
+  def x1
+    graph.outer_margin
+  end
+
+  def x2
+    graph.width - graph.outer_margin
+  end
+
+  def y1
+    graph.outer_margin + graph.inner_height * (1 - graph.normalize(value))
+  end
+
+  def y2
+    y1
+  end
+
+  def label_x
+    x1 - 5
+  end
+
+  def label_y
+    y1 + graph.renderer.font_size / 3
+  end
+
+  def label_style
+    { text_anchor: 'end' }
+  end
+end

data/lib/charts/bar_chart/grid/vertical_grid_line.rb

@@ -0,0 +1,31 @@
+class Charts::Grid::VerticalGridLine < Charts::Grid::GridLine
+  def y1
+    graph.outer_margin
+  end
+
+  def y2
+    graph.outer_margin + graph.inner_height
+  end
+
+  def x1
+    graph.outer_margin + graph.inner_width * graph.normalize(value)
+  end
+
+  def x2
+    x1
+  end
+
+  def label_y
+    y2 + graph.renderer.font_size + 5
+  end
+
+  def label_x
+    x1
+  end
+
+  def label_style
+    {
+      text_anchor: 'middle'
+    }
+  end
+end

data/lib/charts/bin/dispatcher.rb

@@ -0,0 +1,66 @@
+module Charts
+  class Dispatcher
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    def render
+      if options[:filename]
+        graph.render
+      else
+        puts graph.render
+      end
+    end
+
+    def graph
+      if type == :txt
+        SymbolCountChart.new(data, graph_options)
+      elsif [:svg, :png, :jpg, :gif].include? type
+        if style == :circle
+          CircleCountChart.new(data, graph_options)
+        elsif style == :cross
+          CrossCountChart.new(data, graph_options)
+        elsif style == :manikin
+          ManikinCountChart.new(data, graph_options)
+        elsif style == :bar
+          BarChart.new(data, graph_options)
+        elsif style == :pie
+          PieChart.new(data, graph_options)
+        end
+      end
+    end
+
+    def data
+      options[:data]
+    end
+
+    def graph_options
+      options.select do |key, _value|
+        [
+          :background_color,
+          :colors,
+          :columns,
+          :filename,
+          :group_labels,
+          :height,
+          :item_height,
+          :item_width,
+          :labels,
+          :title,
+          :type,
+          :width
+        ].include? key
+      end
+    end
+
+    def type
+      options[:type].to_sym
+    end
+
+    def style
+      options[:style].to_sym
+    end
+  end
+end

data/lib/charts/bin/opt_parser.rb

@@ -0,0 +1,183 @@
+require 'optparse'
+
+class Charts::OptParser
+  attr_reader :args, :options, :parser
+
+  FORMATS = [:txt, :svg, :png, :jpg, :gif].freeze
+  STYLES = [:circle, :cross, :manikin, :bar, :pie].freeze
+  DATA_EXAMPLE_ARGS = '-d 8,7'.freeze
+  COLOR_EXAMPLE_ARGS = '--colors red,gold'.freeze
+  FLOAT_INTEGER_REGEX = /^(?=.)([+-]?([0-9]*)(\.([0-9]+))?)$/.freeze
+
+  def initialize(args)
+    @args = args.empty? ? ['--help'] : args
+    # The options specified on the command line will be collected in *options*.
+    # We set default values here.
+    @options = {
+      type:  :svg,
+      style: :circle
+    }
+    @parser = opt_parser
+  end
+
+  # Return a hash describing the options.
+  def parse
+    parser.parse!(args) # this sets the options
+    post_process_options
+    infer_type_from_filename
+    validate_options
+
+    options
+  end
+
+  def post_process_options
+    # force 2-dimensional array for bar graph if only one data set is provided
+    if options[:style] == :bar and !options[:data].first.is_a? Array
+      options[:data] = [options[:data]]
+    end
+  end
+
+  def infer_type_from_filename
+    return if options[:help]
+    return unless options[:filename]
+    type = options[:filename].match(/.*\.(#{FORMATS.join("|")})/)
+    if type
+      options[:type] = type[1].to_sym
+    else
+      options[:type] = false
+    end
+  end
+
+  def validate_options
+    return if options[:help]
+    unless options[:type]
+      raise 'No type provided. Set a type with --type flag or by setting a valid --filename'
+    end
+    unless options[:data]
+      raise "No data provided. Please pass in data using the --data flag: 'bin/charts #{DATA_EXAMPLE_ARGS}'"
+    end
+  end
+
+  def opt_parser
+    OptionParser.new do |opts|
+      opts.banner = 'Usage: bin/charts [options]'
+      opts.on(
+        '-d DATA',
+        '--data DATA',
+        Array,
+        "Provide multiple data points, ie: 'bin/charts #{DATA_EXAMPLE_ARGS}'"
+      ) do |data|
+        data = data.map { |d| d.match(FLOAT_INTEGER_REGEX) ? Float(d) : nil }
+        # if multiple --data arguments are provided,
+        # the data option becomes a two dimensional array
+        if !options[:data]
+          options[:data] = data
+        else
+          options[:data] = [options[:data]] unless options[:data].first.is_a? Array
+          options[:data].push(data)
+        end
+      end
+      opts.on(
+        '-f FILENAME',
+        '--filename FILENAME',
+        "Set the filename the result is stored in. Supported formats are: : #{FORMATS.join(', ')}"
+      ) do |filename|
+        options[:filename] = filename
+      end
+      opts.on(
+        '-s STYLE',
+        '--style STYLE',
+        STYLES,
+        "Choose the graph style: #{STYLES.join(', ')} (circle, cross and manikin are count graphs)"
+      ) do |style|
+        options[:style] = style
+      end
+      opts.on(
+        '-t TITLE',
+        '--title TITLE',
+        "Set the title"
+      ) do |title|
+        options[:title] = title
+      end
+      opts.on(
+        '--labels LABELS',
+        Array,
+        "Set the labels to be used, ie: 'bin/charts #{DATA_EXAMPLE_ARGS} --labels Failures,Successes' "
+      ) do |labels|
+        options[:labels] = labels
+      end
+      opts.on(
+        '--group-labels GROUP_LABELS',
+        Array,
+        "Set the group-labels to be used, ie: 'bin/charts #{DATA_EXAMPLE_ARGS} --style bar --group-labels Summer,Winter' "
+      ) do |group_labels|
+        options[:group_labels] = group_labels
+      end
+      opts.on(
+        '--colors COLORS',
+        Array,
+        "Set the colors to be used, ie: 'bin/charts #{DATA_EXAMPLE_ARGS} #{COLOR_EXAMPLE_ARGS}' "
+      ) do |colors|
+        options[:colors] = colors
+      end
+      opts.on(
+        '--columns COLUMNS',
+        Integer,
+        'Set number of columns'
+      ) do |columns|
+        options[:columns] = columns
+      end
+      opts.on(
+        '-w WIDTH',
+        '--width WIDTH (not for count graphs)',
+        Integer,
+        'Sets the image width'
+      ) do |width|
+        options[:width] = width
+      end
+      opts.on(
+        '-h HEIGHT',
+        '--height HEIGHT (not for count graphs)',
+        Integer,
+        'Sets the image height'
+      ) do |height|
+        options[:height] = height
+      end
+      opts.on(
+        '--item-width WIDTH',
+        Integer,
+        'Sets the width of the individual item (count graphs only)'
+      ) do |item_width|
+        options[:item_width] = item_width
+      end
+      opts.on(
+        '--item-height HEIGHT',
+        Integer,
+        'Sets the height of the individual item (count graphs only)'
+      ) do |item_height|
+        options[:item_height] = item_height
+      end
+      opts.on(
+        '--type TYPE',
+        FORMATS,
+        "If no filename is provided, output is sent to STDOUT, choose the format: #{FORMATS.join(', ')}"
+      ) do |type|
+        options[:type] = type
+      end
+      opts.on(
+        '--help',
+        'Prints this help'
+      ) do
+        puts opts
+        options[:help] = true
+      end
+      opts.on(
+        '--background_color BACKGROUNDCOLOR',
+        Array,
+        "Set the backgroundcolor to be used, ie: 'bin/charts #{DATA_EXAMPLE_ARGS} --background_color Silver"
+      ) do |background_color|
+        options[:background_color] = background_color
+      end
+    end
+  end
+end

data/lib/charts/chart.rb

@@ -0,0 +1,105 @@
+class Charts::Chart
+  attr_reader :data,
+              :options,
+              :prepared_data,
+              :renderer
+
+  def initialize(data, opts = {})
+    validate_arguments(data, opts)
+    @data = data
+    @options = default_options.merge opts
+    create_options_methods
+    initialize_instance_variables
+    @prepared_data = prepare_data
+  end
+
+  def validate_arguments(data, options)
+    raise ArgumentError.new('Data missing') if data.empty?
+    raise ArgumentError.new('Data not an array') unless data.is_a? Array
+    raise ArgumentError.new('Options missing') unless options.is_a? Hash
+    if options[:outer_margin] and !options[:outer_margin].is_a?(Numeric)
+      raise ArgumentError.new('outer_margin not a number')
+    end
+    if options[:colors]
+      unless options[:colors].is_a? Array
+        raise ArgumentError.new('colors not an array')
+      end
+      if options[:colors].any? and data.count > options[:colors].count
+        raise ArgumentError.new('not enough colors')
+      end
+    end
+    if options[:labels]
+      unless options[:labels].is_a? Array
+        raise ArgumentError.new('labels not an array')
+      end
+      if options[:labels].any? and data.count > options[:labels].count
+        raise ArgumentError.new('not enough labels')
+      end
+    end
+  end
+
+  def default_options
+    {
+      title:            nil,
+      type:             :svg,
+      outer_margin:     30,
+      background_color: 'white',
+      labels:           [],
+      colors:           [
+        '#e41a1d',
+        '#377eb9',
+        '#4daf4b',
+        '#984ea4',
+        '#ff7f01',
+        '#ffff34',
+        '#a65629',
+        '#f781c0',
+        '#888888'
+      ]
+    }
+  end
+
+  def prepare_data
+    data
+  end
+
+  def render
+    pre_draw
+    draw
+    post_draw
+  end
+
+  def pre_draw
+    @renderer = Charts::Renderer.new(self)
+    draw_background
+    draw_title
+  end
+
+  def draw
+    raise NotImplementedError
+  end
+
+  def post_draw
+    renderer.post_draw
+  end
+
+  def draw_background
+    renderer.rect 0, 0, width, height, fill: background_color, class: 'background_color'
+  end
+
+  def draw_title
+    return unless options[:title]
+    x = width / 2
+    y = outer_margin / 2 + 2 * renderer.font_size / 5
+    renderer.text options[:title], x, y, text_anchor: 'middle', class: 'title'
+  end
+
+  def initialize_instance_variables
+  end
+
+  def create_options_methods
+    options.each do |key, value|
+      define_singleton_method key, proc { value }
+    end
+  end
+end

data/lib/charts/count_chart/circle_count_chart.rb

@@ -0,0 +1,9 @@
+class Charts::CircleCountChart < Charts::CountChart
+  def draw_item(x, y, color)
+    cx = x + item_width / 2
+    cy = y + item_height / 2
+    radius = item_width / 2
+
+    renderer.circle cx, cy, radius, fill: color
+  end
+end

data/lib/charts/count_chart/count_chart.rb

@@ -0,0 +1,83 @@
+class Charts::CountChart < Charts::Chart
+  def default_options
+    super.merge(
+      columns:      10,
+      inner_margin: 2,
+      item_width:   20,
+      item_height:  20
+    )
+  end
+
+  def validate_arguments(data, options)
+    super(data, options)
+    raise ArgumentError if options[:inner_margin] and !options[:inner_margin].is_a?(Numeric)
+    raise ArgumentError unless data.all? { |x| Integer(x) }
+  end
+
+  def prepare_data
+    prepared_data = []
+    data.each_with_index do |value, index|
+      value.to_i.times { prepared_data << colors[index].to_s }
+    end
+    prepared_data.each_slice(columns).to_a
+  end
+
+  def draw
+    prepared_data.each_with_index do |row, row_count|
+      row.each_with_index do |color, column_count|
+        x = offset_x(column_count) + inner_margin + outer_margin
+        y = offset_y(row_count) + inner_margin + outer_margin
+        draw_item(x, y, color)
+      end
+    end
+    draw_labels
+  end
+
+  def draw_labels
+    return if labels.empty?
+    data.each_with_index do |data, index|
+      x = inner_margin + outer_margin
+      y = offset_y(prepared_data.count + (index + 1)) + inner_margin + outer_margin
+      draw_item(x, y, colors[index])
+      draw_label_text(x, y, labels[index]) # expand total image size according to labels
+    end
+  end
+
+  def draw_label_text(x, y, label)
+    x = x + item_width + inner_margin
+    y = y + item_height / 2 + 2 * renderer.font_size / 5
+    renderer.text(label, x, y, class: 'label_text')
+  end
+
+  def offset_x(column_count)
+    column_count * outer_item_width
+  end
+
+  def offset_y(row_count)
+    row_count * outer_item_height
+  end
+
+  def outer_item_width
+    item_width + 2 * inner_margin
+  end
+
+  def outer_item_height
+    item_height + 2 * inner_margin
+  end
+
+  def draw_item(_x, _y, _color)
+    raise NotImplementedError
+  end
+
+  def width
+    prepared_data.first.count * outer_item_width + (2 * outer_margin) # + label_count?
+  end
+
+  def height
+    (prepared_data.count + label_count) * outer_item_height + (2 * outer_margin)
+  end
+
+  def label_count
+    labels.any? ? (labels.count + 1) : 0
+  end
+end

data/lib/charts/count_chart/cross_count_chart.rb

@@ -0,0 +1,13 @@
+class Charts::CrossCountChart < Charts::CountChart
+  def draw_item(x, y, color)
+    left   = x + 4
+    right  = x + item_width - 4
+    top    = y + 4
+    bottom = y + item_height - 4
+
+    style  = { stroke: color, stroke_width: 6, stroke_linecap: 'round' }
+
+    renderer.line left, top, right, bottom, style
+    renderer.line left, bottom, right, top, style
+  end
+end

data/lib/charts/count_chart/manikin_count_chart.rb

@@ -0,0 +1,47 @@
+class Charts::ManikinCountChart < Charts::CountChart
+  def draw_item(x, y, color)
+    head x + width_percent(50), y, style(color)
+    body x + width_percent(50), y, style(color)
+    arms x + width_percent(50), y, style(color)
+  end
+
+  def head(x, y, style)
+    cy = y + height_percent(20)
+    radius = height_percent(10)
+
+    renderer.circle x, cy, radius, style.merge(class: 'head')
+  end
+
+  def body(x, y, style)
+    top    = y + height_percent(40)
+    bottom = y + height_percent(95)
+
+    renderer.line x, top, x, bottom, style.merge(stroke_width: width_percent(30), class: 'body')
+  end
+
+  def arms(x, y, style)
+    top    = y + height_percent(40)
+    bottom = y + height_percent(70)
+    left_x = x - width_percent(25)
+    right_x = x + width_percent(25)
+
+    renderer.line left_x, top, left_x, bottom, style.merge(class: 'left-arm')
+    renderer.line right_x, top, right_x, bottom, style.merge(class: 'right-arm')
+  end
+
+  def style(color)
+    {
+      fill:         color,
+      stroke:       color,
+      stroke_width: width_percent(10)
+    }
+  end
+
+  def width_percent(multiplicator)
+    multiplicator * item_width / 100
+  end
+
+  def height_percent(multiplicator)
+    multiplicator * item_height / 100
+  end
+end

data/lib/charts/count_chart/symbol_count_chart.rb

@@ -0,0 +1,10 @@
+class Charts::SymbolCountChart < Charts::CountChart
+  def render
+    render = prepared_data.map { |row| row.map(&:chr).join }.join("\n")
+    if options[:filename]
+      File.open(options[:filename], 'w') { |file| file.write(render) }
+    else
+      render
+    end
+  end
+end

data/lib/charts/legend.rb

@@ -0,0 +1,31 @@
+module Charts::Legend
+  def draw_labels
+    return if options[:labels].nil? || labels.empty?
+    label_row_length_sum = 0
+    label_row = 1
+    labels.each_with_index do |label, index|
+      x = outer_margin + label_row_length_sum
+      y = height - outer_margin - label_total_height + label_row * (label_height + label_margin)
+      label_row_length_sum += label.length * 10 + label_height + 2 * label_margin
+      if label_row_length_sum > inner_width
+        label_row_length_sum = 0
+        label_row += 1
+      end
+      renderer.rect x, y, label_height, label_height, fill: colors[index], stroke: colors[index]
+      label_x = x + label_height + label_margin
+      label_y = y + label_height - renderer.font_size / 3
+      renderer.text label, label_x, label_y, text_anchor: 'start', class: 'label'
+    end
+  end
+
+  def label_total_height
+    return 0 if options[:labels].nil? || labels.empty?
+    label_rows * (label_height + label_margin)
+  end
+
+  def label_rows
+    return 0 if options[:labels].nil? || labels.empty?
+    avg_character_width = 10
+    ((labels.join.length * avg_character_width + 2 * labels.count * label_margin) / inner_width.to_f).ceil
+  end
+end

data/lib/charts/pie_chart/pie_chart.rb

@@ -0,0 +1,78 @@
+class Charts::PieChart < Charts::Chart
+  include Charts::Legend
+
+  attr_reader :sum,
+              :sub_sums
+
+  def validate_arguments(data, options)
+    super(data, options)
+    raise ArgumentError unless data.is_a? Array
+    raise ArgumentError if options[:labels] && !options[:labels].empty? && options[:labels].count != data.count
+    raise ArgumentError if options[:explode] && !options[:explode].empty? && options[:explode].count != data.count
+  end
+
+  def default_options
+    super.merge(
+      width:        600,
+      height:       400,
+      label_height: 20,
+      label_margin: 10,
+      explode:      nil,
+      border_width: 2
+    )
+  end
+
+  def prepare_data
+    @sum = data.reduce 0, :+
+    normalized_data = data.map { |value| value.to_f / sum }
+    @sub_sums = (normalized_data.length + 1).times.map { |i| normalized_data.first(i).reduce 0.0, :+ }
+    normalized_data
+  end
+
+  def pre_draw
+    super
+    draw_labels
+  end
+
+  def draw
+    prepared_data.length.times do |i|
+      start_deg = Math::PI * 2 * sub_sums[i]
+      end_deg = Math::PI * 2 * sub_sums[i + 1]
+      middle_deg = (start_deg + end_deg) / 2
+      expl = explode ? explode[i] : 0
+      middle_x = center_x + expl * Math.sin(middle_deg)
+      middle_y = center_y - expl * Math.cos(middle_deg)
+      start_x = middle_x + radius * Math.sin(start_deg)
+      start_y = middle_y - radius * Math.cos(start_deg)
+      end_x = middle_x + radius * Math.sin(end_deg)
+      end_y = middle_y - radius * Math.cos(end_deg)
+      more_than_half = prepared_data[i] > 0.5 ? 1 : 0
+      path = "M#{middle_x} #{middle_y}
+              L#{start_x} #{start_y}
+              A#{radius} #{radius} 0 #{more_than_half} 1 #{end_x} #{end_y}
+              L#{middle_x} #{middle_y}
+              "
+      renderer.path(path, fill: colors[i], stroke: background_color, stroke_width: border_width)
+    end
+  end
+
+  def radius
+    [inner_width, inner_height].min / 2
+  end
+
+  def center_x
+    outer_margin + inner_width / 2
+  end
+
+  def center_y
+    outer_margin + inner_height / 2
+  end
+
+  def inner_width
+    width - 2 * outer_margin
+  end
+
+  def inner_height
+    height - 2 * outer_margin - label_total_height
+  end
+end

data/lib/charts/renderer/renderer.rb

@@ -0,0 +1,40 @@
+class Charts::Renderer
+  attr_reader :graph
+
+  def initialize(graph)
+    @graph = graph
+    if graph.type == :svg
+      extend Charts::Renderer::SvgRenderer
+    else
+      extend Charts::Renderer::RvgRenderer
+    end
+    pre_draw
+  end
+
+  def post_draw
+    filename = graph.options[:filename]
+    if filename
+      save filename
+    else
+      print
+    end
+  end
+
+  def grid_line_style
+    {
+      stroke:       '#BBBBBB',
+      stroke_width: 1
+    }
+  end
+
+  def font_style
+    {
+      font_family: 'arial',
+      font_size:   font_size
+    }
+  end
+
+  def font_size
+    16
+  end
+end

data/lib/charts/renderer/rvg_renderer.rb

@@ -0,0 +1,46 @@
+require 'rvg/rvg'
+
+module Charts::Renderer::RvgRenderer
+  attr_reader :rvg
+
+  def pre_draw
+    @rvg = Magick::RVG.new(graph.width, graph.height) do |canvas|
+      canvas.background_fill = 'white'
+    end
+  end
+
+  def print
+    rvg.draw.to_blob { |attrs| attrs.format = 'PNG' }
+  end
+
+  def save(filename)
+    rvg.draw.write filename
+  end
+
+  def line(x1, y1, x2, y2, style)
+    canvas(style) { |c| c.line x1, y1, x2, y2 }
+  end
+
+  def circle(cx, cy, radius, style)
+    canvas(style) { |c| c.circle radius, cx, cy }
+  end
+
+  def rect(x, y, width, height, style)
+    canvas(style) { |c| c.rect width, height, x, y }
+  end
+
+  def path(d, style)
+    canvas(style) { |c| c.path d }
+  end
+
+  def text(text, x, y, style = {})
+    canvas(font_style.merge(style)) { |c| c.text x, y, text }
+  end
+
+  def canvas(style)
+    style.delete(:class)
+    rvg.rvg(graph.width, graph.height) do |canvas|
+      yield(canvas).styles(style)
+    end
+  end
+end

data/lib/charts/renderer/svg_renderer.rb

@@ -0,0 +1,38 @@
+require 'victor'
+
+module Charts::Renderer::SvgRenderer
+  attr_reader :svg
+
+  def pre_draw
+    @svg = SVG.new width: graph.width, height: graph.height
+  end
+
+  def print
+    svg.render
+  end
+
+  def save(filename)
+    svg.save filename
+  end
+
+  def line(x1, y1, x2, y2, style = {})
+    svg.line style.merge(x1: x1, y1: y1, x2: x2, y2: y2)
+  end
+
+  def circle(cx, cy, radius, style = {})
+    svg.circle style.merge(cx: cx, cy: cy, r: radius)
+  end
+
+  def rect(x, y, width, height, style = {})
+    svg.rect style.merge(x: x, y: y, width: width, height: height)
+  end
+
+  def path(d, style = {})
+    svg.path style.merge(d: d)
+  end
+
+  def text(text, x, y, style = {})
+    svg.text text, font_style.merge(style).merge(x: x, y: y)
+  end
+end
+

data/lib/charts.rb

@@ -0,0 +1,29 @@
+module Charts
+end
+
+# Includes:
+require_relative 'charts/renderer/renderer'
+require_relative 'charts/renderer/rvg_renderer'
+require_relative 'charts/renderer/svg_renderer'
+
+# Classes:
+require_relative 'charts/chart'
+require_relative 'charts/legend'
+require_relative 'charts/bar_chart/grid/grid'
+require_relative 'charts/bar_chart/grid/grid_line'
+require_relative 'charts/bar_chart/grid/vertical_grid_line'
+require_relative 'charts/bar_chart/grid/horizontal_grid_line'
+require_relative 'charts/bar_chart/bar_chart'
+require_relative 'charts/bar_chart/bar/bar'
+require_relative 'charts/bar_chart/bar/vertical_bar'
+require_relative 'charts/bar_chart/bar/horizontal_bar'
+require_relative 'charts/pie_chart/pie_chart'
+require_relative 'charts/count_chart/count_chart'
+require_relative 'charts/count_chart/circle_count_chart'
+require_relative 'charts/count_chart/cross_count_chart'
+require_relative 'charts/count_chart/manikin_count_chart'
+require_relative 'charts/count_chart/symbol_count_chart'
+
+# Helper for command line charts
+require_relative 'charts/bin/opt_parser'
+require_relative 'charts/bin/dispatcher'

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: charts
+version: !ruby/object:Gem::Version
+  version: 0.0.9
+platform: ruby
+authors:
+- Eike Send
+- Maximilian Maintz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-01-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: victor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: rmagick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Create charts, graphs and info graphics with ruby as SVG, JPG or PNG
+  images
+email: charts@eike.se
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/charts.rb
+- lib/charts/bar_chart/bar/bar.rb
+- lib/charts/bar_chart/bar/horizontal_bar.rb
+- lib/charts/bar_chart/bar/vertical_bar.rb
+- lib/charts/bar_chart/bar_chart.rb
+- lib/charts/bar_chart/grid/grid.rb
+- lib/charts/bar_chart/grid/grid_line.rb
+- lib/charts/bar_chart/grid/horizontal_grid_line.rb
+- lib/charts/bar_chart/grid/vertical_grid_line.rb
+- lib/charts/bin/dispatcher.rb
+- lib/charts/bin/opt_parser.rb
+- lib/charts/chart.rb
+- lib/charts/count_chart/circle_count_chart.rb
+- lib/charts/count_chart/count_chart.rb
+- lib/charts/count_chart/cross_count_chart.rb
+- lib/charts/count_chart/manikin_count_chart.rb
+- lib/charts/count_chart/symbol_count_chart.rb
+- lib/charts/legend.rb
+- lib/charts/pie_chart/pie_chart.rb
+- lib/charts/renderer/renderer.rb
+- lib/charts/renderer/rvg_renderer.rb
+- lib/charts/renderer/svg_renderer.rb
+homepage: http://github.com/eikes/charts
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Renders beautiful charts
+test_files: []