chart-candy 0.0.7

data/lib/chart-candy/builder/base.rb

@@ -0,0 +1,70 @@
+class ChartCandy::Builder::Base
+  def initialize(id, options={})
+    options.reverse_merge! from: nil, to: nil, step: nil
+
+    @from = options[:from] ? Time.parse(options[:from]) : nil
+    @to = options[:to] ? Time.parse(options[:to]) : Time.now
+
+    @chart = { id: id }
+    @chart[:step] = options[:step] if options[:step]
+    @chart[:title] = t('title')
+    @chart[:period] = ChartCandy::Builder.period(@from, @to, step: @chart[:step]) if @from
+  end
+
+  def close_chart
+    # Hooks before closing a chart
+  end
+
+  def filename
+    name = [title.parameterize]
+    name << @from.strftime('%Y%m%d') if @from
+    name << @to.strftime('%Y%m%d') if @to
+
+    return name.compact.join('-')
+  end
+
+  def id
+    @chart[:id]
+  end
+
+  def l(date, options={})
+    options.reverse_merge!(format: :date_long)
+
+    return ChartCandy.localize(date, options)
+  end
+
+  def period
+    @chart[:period]
+  end
+
+  def set_period_from_data(data)
+    @from = data.first
+    @to = data.last
+
+    @chart[:step] = ChartCandy::Builder.get_step_from_interval(data[1] - data[0]) if not @chart[:step]
+
+    @chart[:period] = ChartCandy::Builder.period @from, @to, step: @chart[:step]
+  end
+
+  def t(path, vars={})
+    vars.reverse_merge! :default => ''
+
+    ChartCandy.translate("#{id.gsub('-', '_')}.#{path}", vars)
+  end
+
+  def title
+    @chart[:title]
+  end
+
+  def to_json
+    close_chart
+
+    return @chart.to_json
+  end
+
+  def to_xls
+    close_chart
+
+    return ChartCandy::Builder::XlsBuilder.chart_to_xls @chart
+  end
+end

data/lib/chart-candy/builder/counter.rb

@@ -0,0 +1,12 @@
+class ChartCandy::Builder::Counter < ChartCandy::Builder::Base
+
+  def initialize(id, options={})
+    super
+
+    @chart.merge! nature: 'count', data: []
+  end
+
+  def add_primary(id, value)
+    @chart[:data] << { nature: :primary, label: t("data.#{id}.label"), id: id, value: value }
+  end
+end

data/lib/chart-candy/builder/donut.rb

@@ -0,0 +1,73 @@
+class ChartCandy::Builder::Donut < ChartCandy::Builder::Base
+
+  def initialize(id, options={})
+    super
+
+    @chart.merge! hole: [], label: t('label'), nature: 'donut', slices: [], show_label: true, unit: :number, value: t('value')
+  end
+
+  def add_hole_item(name, value)
+    @chart[:hole] = [t('hole.title')].flatten if hole.empty?
+    hole << t("hole.#{name}", value: value)
+  end
+
+  def add_slice(name, value, options={})
+    options.reverse_merge! txt_vars: {}
+
+    return if value.to_i <= 0
+
+    value = value.round(2) if money?
+    valuef = money? ? format_money(value) : value
+
+    options[:txt_vars][:value] = valuef
+
+    label_str = t("slices.#{name}.label", options[:txt_vars])
+    tooltip = t("slices.#{name}.tooltip", options[:txt_vars])
+
+    @chart[:slices] << { label: label_str, percent: 0, tooltip: tooltip, value: value, valuef: valuef }
+  end
+
+  def close_chart
+    total = @chart[:slices].sum{ |s| s[:value] }
+
+    total = total.round(2) if money?
+
+    @chart[:total] = { label: 'Total', value: total }
+
+    fill_percents
+  end
+
+  def format_money(value)
+    sprintf("%0.02f", (value.to_f).round(2)).gsub('.', ',') + ' $'
+  end
+
+  def hole
+    @chart[:hole]
+  end
+
+  def money?
+    @chart[:unit] == :money
+  end
+
+  def show_label=(active)
+    @chart[:show_label] = active
+  end
+
+  def show_label
+    @chart[:show_label]
+  end
+
+  def unit=(unit_sym)
+    @chart[:unit] = unit_sym.to_sym if [:number, :money].include? unit_sym.to_sym
+  end
+
+  def unit
+    @chart[:unit]
+  end
+
+  private
+
+  def fill_percents
+    @chart[:slices].each { |s| s[:percent] = (s[:value].to_f * 100 / @chart[:total][:value]).round(2) }
+  end
+end

data/lib/chart-candy/builder/line.rb

@@ -0,0 +1,114 @@
+class ChartCandy::Builder::Line < ChartCandy::Builder::Base
+
+  def initialize(id, options={})
+    super
+
+    @chart.merge! axis: {}, legend: nil, lines: [], nature: 'line', tooltip: true
+  end
+
+  def add_dot(dot, id, x_name, y_name)
+    {
+      x: dot[x_name],
+      y: dot[y_name],
+      label_x: add_dot_label(id, dot[x_name], @chart[:axis][:x][:nature]),
+      label_y: add_dot_label(id, dot[y_name], @chart[:axis][:y][:nature])
+    }
+  end
+
+  def add_dot_label(id, value, nature)
+    case nature
+      when :date then add_dot_label_date value
+      when :money then add_dot_label_money value
+      else value.to_s + ' ' + t("lines.#{id}.unit")
+    end
+  end
+
+  def add_dot_label_date(date)
+    case @chart[:step]
+      when 'day' then l(date, format: :date_long)
+      when 'week' then ChartCandy.translate('date.week') + ' ' + l(date, format: :date_long).strip
+      when 'month' then l(date, format: :date_without_day).capitalize
+      else l(date, format: :date_long)
+    end
+  end
+
+  def add_dot_label_money(amount)
+    sprintf("%0.02f", amount.round(2)).gsub('.', ',') + ' $'
+  end
+
+  def add_line(id, original_data, options={})
+    options.reverse_merge! axis_y: "left", txt_vars: {}, key_x: "time", key_y: "value"
+
+    data = original_data.map{ |d| add_dot(d, id, options[:key_x], options[:key_y]) }
+
+    [:x, :y].each do |key|
+      [:min, :max].each { |m| @chart[:axis][key][m] = to_money_format(@chart[:axis][key][m]) } if money? key
+    end
+
+    data = original_data.map do |d|
+      [:key_x, :key_y].each { |key| d[options[key]] = to_money_format(d[options[key]]) if money?(key[-1,1]) }
+      add_dot(d, id, options[:key_x], options[:key_y])
+    end
+
+    @chart[:lines] << { axis_y: options[:axis_y], data: data, label: t("lines.#{id}.label", options[:txt_vars]), unit: t("lines.#{id}.unit"), total: get_total(data) }
+  end
+
+  def add_x_axis(nature, original_data, options={})
+    options.reverse_merge! key: "time"
+
+    data = original_data.map{ |d| d[options[:key]] }
+
+    set_period_from_data data if not @from and nature == :date
+
+    @chart[:axis][:x] = { nature: nature, label: t("axis.x.label"), min: data.min, max: data.max, max_ticks: data.length }
+  end
+
+  def add_y_axis(nature, original_data, options={})
+    options.reverse_merge! key: 'value', max: nil, min: nil
+
+    data = original_data.map{ |d| d[options[:key]] }
+
+    min = options[:min] ? options[:min] : data.min
+    max = options[:max] ? options[:max] : data.max
+
+    @chart[:axis][:y] = { nature: nature, label: t('axis.y.label'), min: min, max: max, max_ticks: data.length }
+  end
+
+  def close_chart
+    super
+
+    @chart[:legend] = (@chart[:lines].length > 1) if @chart[:legend].nil?
+  end
+
+  def date_based?
+    @chart[:axis][:x] and @chart[:axis][:x][:nature] == :date
+  end
+
+  def get_total(data)
+    { label: 'Total', value: data.sum{ |d| d[:y] } }
+  end
+
+  def legend=(active)
+    @chart[:legend] = active
+  end
+
+  def legend
+    @chart[:legend]
+  end
+
+  def money?(key)
+    @chart[:axis][key.to_sym][:nature] == :money
+  end
+
+  def to_money_format(value)
+    (BigDecimal.new(value) / 100).round(2)
+  end
+
+  def tooltip=(active)
+    @chart[:tooltip] = active
+  end
+
+  def tooltip
+    @chart[:tooltip]
+  end
+end

data/lib/chart-candy/builder/xls_builder.rb

@@ -0,0 +1,159 @@
+require 'spreadsheet'
+
+class ChartCandy::Builder::XlsBuilder
+  attr_reader :current_row, :current_column, :workbook
+
+  def self.chart_to_xls(chart)
+    xls = self.new(chart)
+    xls.generate
+
+    return xls.workbook
+  end
+
+  def initialize(chart)
+    @chart = chart
+    @workbook = Spreadsheet::Workbook.new
+    @sheet = @workbook.create_worksheet
+    @formats = build_formats
+
+    @current_row = -1
+    @current_row_format = :normal
+    @current_column = 0
+
+    @columns_width = []
+    @max_column_width = 50
+    @default_column_width = 10
+  end
+
+  def add_align_right_formats(formats)
+    align_right = {}
+
+    formats.each do |k,origin|
+      new_format = origin.dup
+      new_format.horizontal_align = :right
+
+      align_right["#{k}_right".to_sym] = new_format
+    end
+
+    formats.merge! align_right
+  end
+
+  def build_formats
+    f = {}
+
+    f[:h1] = Spreadsheet::Format.new(weight: :bold,    size: 16,  horizontal_align: :left, vertical_align: :middle)
+    f[:h2] = Spreadsheet::Format.new(weight: :normal,  size: 12,  horizontal_align: :left, vertical_align: :middle)
+    f[:h3] = Spreadsheet::Format.new(weight: :normal,  size: 9,   horizontal_align: :left, vertical_align: :middle)
+    f[:h4] = Spreadsheet::Format.new(weight: :bold,    size: 8,   horizontal_align: :left, vertical_align: :middle)
+    f[:th] = Spreadsheet::Format.new(weight: :bold,    size: 8,   horizontal_align: :center, vertical_align: :middle, pattern_fg_color: :xls_color_19, pattern: 1)
+    f[:th_foot] = Spreadsheet::Format.new(weight: :bold, size: 8, horizontal_align: :left, vertical_align: :middle, pattern_fg_color: :xls_color_19, pattern: 1)
+    f[:normal] = Spreadsheet::Format.new(size: 8, horizontal_align: :left , vertical_align: :middle)
+
+    add_align_right_formats f
+
+    return f
+  end
+
+  def cell(content=nil, options={})
+    options.reverse_merge! format: nil, nature: :text
+
+    row_obj = @sheet.row(current_row)
+
+    row_obj.set_format current_column, @formats[options[:format]] if options[:format]
+    set_cell_format options[:nature]
+    row_obj.height = row_obj.format(0).font.size * 1.6
+
+    parsed_content = format_data(content)
+
+    @sheet[current_row, current_column] = parsed_content
+
+    @columns_width[current_column] = parsed_content.to_s.length if @columns_width[current_column].to_i < parsed_content.to_s.length
+
+    @current_column += 1
+  end
+
+  def format_data(data)
+    case
+      when data.is_a?(Time) then data.strftime('%d-%m-%Y')
+      else data
+    end
+  end
+
+  def generate
+    header
+
+    case @chart[:nature]
+      when 'line' then generate_chart_line_table
+      when 'donut' then generate_chart_donut_table
+    end
+
+    set_columns_width
+  end
+
+  def generate_chart_line_table
+    row @chart[:axis][:x][:label], :th
+
+    @chart[:lines].map { |l| cell l[:label] }
+
+    @chart[:lines][0][:data].each_with_index do |l,i|
+      row
+
+      cell l[:x], nature: @chart[:axis][:x][:nature]
+
+      @chart[:lines].each { |line| cell line[:data][i][:y], nature: @chart[:axis][:y][:nature] }
+    end
+
+    row @chart[:lines][0][:total][:label], :th_foot
+
+    @chart[:lines].map { |l| cell l[:total][:value], nature: :number }
+  end
+
+  def generate_chart_donut_table
+    row [@chart[:label], @chart[:value]], :th
+
+    @chart[:slices].map { |s| row [s[:label], s[:value]] }
+
+    row [@chart[:total][:label], @chart[:total][:value]], :th_foot
+  end
+
+  def header
+    row @chart[:title], :h1
+    row @chart[:period], :h3 if @chart[:period]
+
+    reset_columns_width
+
+    skip_row
+  end
+
+  def reset_columns_width
+    @columns_width = Array.new(@columns_width.length, @default_column_width)
+  end
+
+  def row(data=[], format = :normal)
+    @current_column = 0
+    @current_row += 1
+
+    @sheet.row(current_row).default_format = @formats[format]
+    @current_row_format = format
+
+    [data].flatten.each { |d| cell(d) }
+  end
+
+  def set_cell_format(nature)
+    if nature == :number
+      f = "#{@current_row_format}_right".gsub('right_right', 'right').to_sym
+
+      @sheet.row(current_row).set_format(current_column, @formats[f])
+    end
+  end
+
+  def set_columns_width
+    @columns_width.each_with_index do |c,i|
+      @sheet.column(i).width = (c.to_i < @default_column_width) ? @default_column_width : c.to_i
+    end
+  end
+
+  def skip_row
+    @current_row += 1
+  end
+end

data/lib/chart-candy/engine.rb

@@ -0,0 +1,5 @@
+module ChartCandy
+  class Engine < Rails::Engine
+    #auto wire
+  end
+end

data/lib/chart-candy/helpers.rb

@@ -0,0 +1,169 @@
+module ChartCandy::Helpers
+  def counter_chart(id, options={})
+    ChartCandyTagHelper.new(self, id, options[:from], options[:to], options[:step]).counter(options)
+  end
+
+  def d3_include_tag
+    ('<![if ! lt IE 9]>' + javascript_include_tag("d3") + '<![endif]>').html_safe
+  end
+
+  def donut_chart(id, options={})
+    ChartCandyTagHelper.new(self, id, options[:from], options[:to], options[:step]).donut(options)
+  end
+
+  def line_chart(id, options={})
+    ChartCandyTagHelper.new(self, id, options[:from], options[:to], options[:step]).line(options)
+  end
+
+  def excel_chart_button(id, options={})
+    ChartCandyTagHelper.new(self, id, options[:from], options[:to], options[:step]).excel_chart_button(options)
+  end
+
+  class ChartCandyTagHelper
+    def initialize(rails_helpers, id, from, to, step)
+      @rails_helpers = rails_helpers
+      @id = id
+      @from = from
+      @to = to
+      @step = step || 'month'
+    end
+
+    def counter(options={})
+      options.reverse_merge! update_every: 1.minute, tools: nil
+
+      chart 'counter', options
+    end
+
+    def excel_chart_button(options={})
+      build_url 'line', options if not @url
+
+      tool_export_xls options[:label]
+    end
+
+    def line(options={})
+      options.reverse_merge! tools: {}
+      options[:tools].reverse_merge! export_xls: true, step: true, template: true
+
+      chart 'line', options
+    end
+
+    def donut(options={})
+      options.reverse_merge! tools: {}
+      options[:tools].reverse_merge! export_xls: true, step: false, template: true
+
+      chart 'donut', options
+    end
+
+    private
+
+    def build_url(nature, options={})
+      params = { from: @from, format: 'json', id: @id, nature: nature, nonce: SecureRandom.hex(20), step: @step, timestamp: Time.now.utc.iso8601, to: @to, version: 'v1' }
+
+      options.each { |k,v| params[k] = v if not ['class', 'tools'].include? k.to_s }
+
+      params[:token] = build_url_token(params)
+
+      @url = @rails_helpers.candy_chart_url params
+    end
+
+    def build_url_token(params)
+      compacted_params = ChartCandy::Authentication.compact_params(params)
+
+      url = @rails_helpers.candy_charts_url + compacted_params
+
+      return ChartCandy::Authentication.tokenize(url)
+    end
+
+    def chart(nature, options={})
+      options.reverse_merge! class: ""
+      options[:class] += " wrapper-chart chart-#{nature}"
+
+      build_url nature, options
+
+      content = ''
+      content += title_tag
+      content += chart_tools(nature, options[:tools]) if options[:tools]
+      content += content_tag(:div, content_tag(:div, '', class: 'chart') + content_tag(:div, '', class: 'table'), class: 'templates')
+
+      wrapper_options = { id: @id, class: options[:class], 'data-chart-candy' => nature, 'data-url' => @url}
+      wrapper_options['data-update-delay'] = options[:update_every].to_i if options[:update_every]
+
+      return content_tag(:div, content.html_safe, wrapper_options)
+    end
+
+    def chart_select_tag(name, choices, selection)
+      if form_candy?
+        candy.select(name, choices, selection)
+      else
+        select_tag(name, options_for_select(choices, selection), id: nil)
+      end
+    end
+
+    def chart_switch_tag(name, choices, selection)
+      if form_candy?
+        candy.switch(name, choices, selection)
+      else
+        select_tag(name, options_for_select(choices, selection), id: nil)
+      end
+    end
+
+    def chart_tools(nature, options={})
+      content = form_tag(@url) do
+        tools = ''
+        tools += tool_export_xls if options[:export_xls]
+        tools += tool_step if options[:step]
+        tools += tool_template if options[:template]
+
+        tools.html_safe
+      end
+
+      return content_tag(:div, content.html_safe, class: 'tools')
+    end
+
+    def form_candy?
+      begin
+        (candy ? true : false)
+      rescue
+        false
+      end
+    end
+
+    def t(path)
+      ChartCandy.translate(path)
+    end
+
+    def title_tag
+      content_tag(:h2, t("#{@id.underscore}.title").html_safe, class: 'title-chart')
+    end
+
+    def tool_export_xls(label=nil)
+      label = t('base.xls_export') if not label
+
+      content = link_to(content_tag(:span, label, class: 'text'), @url.gsub('.json', '.xls'), class: 'button', title: t('base.xls_export'))
+
+      return content_tag(:div, content.html_safe, class: 'tool holder-export-xls')
+    end
+
+    def tool_step
+      choices = ['day', 'week', 'month'].map{ |c| [t("base.steps.#{c}"), c] }
+
+      return content_tag(:div, chart_select_tag('step', choices, 'month'), class: 'tool holder-step')
+    end
+
+    def tool_template
+      choices = ['chart', 'table'].map { |c| [t("base.template.#{c}"), c] }
+
+      return content_tag(:div, chart_switch_tag('template', choices, 'chart'), class: 'tool holder-template')
+    end
+
+    def method_missing(*args, &block)
+      if [:candy, :content_tag, :form_tag, :link_to, :options_for_select, :select_tag].include?(args.first)
+        return @rails_helpers.send(*args, &block)
+      else
+        raise NoMethodError.new("undefined local variable or method '#{args.first}' for #{self.class}")
+      end
+    end
+  end
+
+  ::ActionView::Base.send :include, self
+end