active_charts 1.0.1

data/lib/active_charts/helpers/line_chart_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'active_charts/util'
+
+module ActiveCharts
+  module Helpers #:nodoc:
+    module LineChartHelper
+      def line_chart(collection, options = {})
+        LineChart.new(collection, options).to_html
+      end
+      
+      def line_chart_for(resource_collection, columns = [], options = {})
+        return line_chart([[]], options) unless Util.valid_collection?(resource_collection)
+        
+        parser = CollectionParser.new(resource_collection, columns, options[:label_column])
+        series_labels = options[:series_labels] || parser.xy_series_labels
+        options = options.merge(series_labels: series_labels, rows: parser.rows)
+        
+        line_chart(parser.xy_collection, options)
+      end
+    end
+  end
+end

data/lib/active_charts/helpers/scatter_plot_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'active_charts/util'
+
+module ActiveCharts
+  module Helpers #:nodoc:
+    module ScatterPlotHelper
+      def scatter_plot(collection, options = {})
+        ScatterPlot.new(collection, options).to_html
+      end
+      
+      def scatter_plot_for(resource_collection, columns = [], options = {})
+        return scatter_plot([[]], options) unless Util.valid_collection?(resource_collection)
+        
+        parser = CollectionParser.new(resource_collection, columns, options[:label_column])
+        series_labels = options[:series_labels] || parser.xy_series_labels
+        options = options.merge(series_labels: series_labels, rows: parser.rows)
+        
+        scatter_plot(parser.xy_collection, options)
+      end
+    end
+  end
+end

data/lib/active_charts/line_chart.rb

@@ -0,0 +1,61 @@
+module ActiveCharts
+  class LineChart < XYChart
+    attr_reader :line_labels
+    
+    def chart_svg_tag
+      inner_html = [grid_rect_tag, ticks(x_ticks, y_ticks), lines, line_label_tags, 
+                    side_label_text_tags, bottom_label_text_tags].flatten.join('
+          ')
+      
+      tag.svg(inner_html.html_safe, svg_options)
+    end
+    
+    def lines
+      dots_specs.map.with_index do |line_dots, index|
+        d = line_dots.map do |dot| 
+          [dot[:cx], dot[:cy]].join(' ') 
+        end
+        
+        tag.path('', d: 'M' + d.join(' L '), class: line_classes(index))
+      end
+    end
+    
+    def line_label_tags
+      dots_specs.flatten.map do |dot| 
+        tag.text(dot[:label], x: dot[:cx] + OFFSET, y: dot[:cy] - OFFSET, class: label_classes)
+      end
+    end
+
+    def dots_specs
+      (0..columns_count - 1).map do |col_index|
+        collection.map.with_index do |row, row_index|
+          dot_spec(row[col_index], row_index)
+        end
+      end
+    end
+    
+    private
+    
+    def process_options(options)
+      super
+      
+      @line_labels = options[:rows] || []
+    end
+    
+    def dot_spec(cell, row_index)
+      { cx: dot_cx(cell.first), cy: dot_cy(cell.last), label: line_labels[row_index] }
+    end
+    
+    def dot_cx(value)
+      Util.scaled_position(value, x_min, x_max, grid_width).round(6)
+    end
+    
+    def dot_cy(value)
+      grid_height - Util.scaled_position(value, y_min, y_max, grid_height).round(6)
+    end
+    
+    def line_classes(col)
+      ['ac-line-chart-line', series_class(col)].join(' ')
+    end
+  end
+end

data/lib/active_charts/rectangular_chart.rb

@@ -0,0 +1,64 @@
+module ActiveCharts
+  class RectangularChart < Chart
+    TOP_LEFT_OFFSET = 1
+    
+    def initialize(collection, options = {})
+      super
+      
+      prereq_calcs
+      
+      values = values_calcs
+      
+      width_calcs(values.map(&width_filter))
+      height_calcs(values.map(&height_filter))
+    end
+    
+    attr_reader :grid_height, :grid_width, :svg_height, :svg_width
+    
+    def grid_rect_tag
+      tag.rect(
+        x: TOP_LEFT_OFFSET,
+        y: TOP_LEFT_OFFSET,
+        height: grid_height - TOP_LEFT_OFFSET * 2, 
+        width: grid_width - TOP_LEFT_OFFSET * 2, 
+        class: 'grid'
+      )
+    end
+    
+    private
+
+    def process_options(options)
+      super
+      
+      @grid_width = @svg_width = options[:width] || MARGIN * 30
+      @grid_height = @svg_height = options[:height] || MARGIN * 20
+    end
+    
+    def prereq_calcs; end
+    
+    def values_calcs
+      []
+    end
+    
+    def width_filter
+      :first
+    end
+
+    def height_filter
+      :last
+    end
+    
+    def width_calcs(_values); end
+    
+    def height_calcs(_values); end
+    
+    def ticks(vertical_ticks, horizontal_ticks)
+      (vertical_ticks.map { |x| tick_line_tag(x, x, TOP_LEFT_OFFSET, grid_height - TOP_LEFT_OFFSET) } + 
+        horizontal_ticks.map { |y| tick_line_tag(TOP_LEFT_OFFSET, grid_width - TOP_LEFT_OFFSET, y, y) })
+    end
+    
+    def tick_line_tag(x1, x2, y1, y2)
+      %(<line #{tag_options(x1: x1, x2: x2, y1: y1, y2: y2)} class="ac-grid-line" />)
+    end
+  end
+end

data/lib/active_charts/scatter_plot.rb

@@ -0,0 +1,55 @@
+module ActiveCharts
+  class ScatterPlot < XYChart
+    attr_reader :dot_labels
+    
+    def chart_svg_tag
+      inner_html = [grid_rect_tag, ticks(x_ticks, y_ticks), dots, 
+                    side_label_text_tags, bottom_label_text_tags].flatten.join('
+          ')
+      
+      tag.svg(inner_html.html_safe, svg_options)
+    end
+    
+    def dots
+      whitelist = %w[cx cy class]
+      
+      dots_specs.flatten.map do |dot| 
+        [%(<circle #{tag_options(dot, whitelist)} />),
+         tag.text(dot[:label], x: dot[:cx] + OFFSET, y: dot[:cy] - OFFSET, class: label_classes)]
+      end
+    end
+
+    def dots_specs
+      collection.map.with_index do |row, row_index|
+        row.map.with_index do |cell, col_index|
+          dot_spec(cell, row_index, col_index)
+        end
+      end
+    end
+    
+    private
+    
+    def process_options(options)
+      super
+      
+      @dot_labels = options[:rows] || []
+    end
+    
+    def dot_spec(cell, row_index, col_index)
+      { cx: dot_cx(cell.first), cy: dot_cy(cell.last), class: dot_classes(col_index), 
+        label: dot_labels[row_index] }
+    end
+    
+    def dot_cx(value)
+      Util.scaled_position(value, x_min, x_max, grid_width).round(6)
+    end
+    
+    def dot_cy(value)
+      grid_height - Util.scaled_position(value, y_min, y_max, grid_height).round(6)
+    end
+    
+    def dot_classes(col)
+      ['ac-scatter-plot-dot', 'ac-triggerable', series_class(col)].join(' ')
+    end
+  end
+end

data/lib/active_charts/util.rb

@@ -0,0 +1,121 @@
+module ActiveCharts
+  # @private
+  module Util
+    module_function
+    
+    def max_values(array_of_arrays)
+      return [] unless array_of_arrays?(array_of_arrays)
+      
+      maxes = initialize_maxes(array_of_arrays.first)
+      
+      array_of_arrays[1..-1].each do |row|
+        row.map { |cell| safe_to_dec(cell) }
+           .each_with_index do |val, index|
+             maxes[index] = val if index > maxes.count - 1 || val > maxes[index]
+           end
+      end
+      
+      maxes
+    end
+    
+    def array_of_arrays?(item)
+      item.is_a?(Array) && !item.empty? && item.all? { |row| row.is_a?(Array) }
+    end
+    
+    def initialize_maxes(row)
+      row.map do |cell| 
+        safe_to_dec(cell) <= 0 ? 1 : safe_to_dec(cell) 
+      end # solves floating 0 labels bug
+    end
+    
+    def multiplier(data_value, pixels, precision = 6)
+      (pixels / safe_to_dec(data_value)).round(precision)
+    end
+    
+    def safe_to_dec(item)
+      item = Date.new(item.year, item.month, item.day) if date_like?(item)
+      item = item.jd if item.respond_to?(:jd)
+      
+      item.to_d
+    rescue
+      0.0
+    end
+    
+    def date_like?(item)
+      return false if item.respond_to?(:jd)
+      
+      %i[year month day].all? do |method| 
+        item.respond_to?(method) &&
+          item.send(method).class.eql?(Integer) 
+      end
+    end
+    
+    def date_label(val)
+      val = Date.jd(val) if val.class.superclass.eql?(Numeric)
+
+      val.respond_to?(:strftime) ? val.strftime('%F') : val.to_s
+    end
+    
+    def grid_index(width, x, y)
+      width * y + x
+    end
+    
+    def scaled_position(n, a, b, scale_length)
+      multiplier = scale_length.to_d / (b - a)
+      
+      (n - a) * multiplier
+    end
+    
+    def scale(min, max)
+      return [0, 1, 1] unless valid_max_min?(min, max)
+      
+      step = scale_interval(min, max)
+      
+      a = scale_a(min, step)
+      b = scale_b(max, step)
+      
+      [a, b, step]
+    end
+    
+    def scale_a(min, step)
+      return 0 if min.zero? 
+      
+      unscaled_a = (min.to_d / step).to_i
+      unscaled_a -= 1 if min.negative? || (min == unscaled_a * step)
+      
+      unscaled_a * step
+    end
+    
+    def scale_b(max, step)
+      return 0 if max.zero? 
+      
+      unscaled_b = (max.to_d / step).to_i
+      unscaled_b += 1 if max.positive? || (max == unscaled_b * step)
+      
+      unscaled_b * step
+    end
+    
+    def scale_interval(min, max)
+      diff = (max - min).abs
+      
+      case diff
+      when 0..2
+        0.5
+      when 3..10
+        1
+      else
+        10**Math.log(diff, 10).to_i
+      end
+    end
+    
+    def valid_max_min?(min, max)
+      [min, max].all? { |n| n.class.superclass.eql?(Numeric) } && max > min
+    end
+    
+    def valid_collection?(item)
+      item.respond_to?(:first) && item.first.class.superclass.eql?(ApplicationRecord)
+    end
+  end
+  
+  private_constant :Util
+end

data/lib/active_charts/version.rb

@@ -0,0 +1,3 @@
+module ActiveCharts
+  VERSION = '1.0.1'.freeze
+end

data/lib/active_charts/xy_chart.rb

@@ -0,0 +1,91 @@
+module ActiveCharts
+  class XYChart < RectangularChart
+    OFFSET = 6
+    
+    def initialize(collection, options = {})
+      super
+      
+      section_calcs
+      tick_calcs
+    end
+    
+    attr_reader :x_labels, :y_labels, :x_min, :x_max, :y_min, :y_max,
+                :x_label_y, :y_label_x, :x_ticks, :y_ticks, :section_width, :section_height
+    
+    def side_label_text_tags
+      y_labels.map.with_index do |label, index| 
+        label = formatted_val(label, data_formatters[1])
+        
+        tag.text(label, x: y_label_x, y: y_tick_y(index), class: 'ac-y-label')
+      end.join
+    end
+
+    def bottom_label_text_tags
+      x_labels.map.with_index do |label, index| 
+        label = formatted_val(label, data_formatters[0])
+        classes = 'ac-x-label'
+        classes += ' anchor_start' if index.zero?
+      
+        tag.text(label, x: x_tick_x(index), y: x_label_y, class: classes)
+      end.join
+    end
+
+    private
+    
+    def prereq_calcs
+      @collection = collection.map do |row| 
+        row.map { |x, y| [Util.safe_to_dec(x), Util.safe_to_dec(y)] } 
+      end
+    end
+    
+    def values_calcs
+      @collection.flatten(1)
+    end
+      
+    def width_calcs(values)
+      @grid_width = svg_width - MARGIN * 4
+      @x_min, @x_max, x_step = Util.scale(values.min, values.max)
+      @x_labels = (x_min..x_max).step(x_step)
+    end
+    
+    def height_calcs(values)
+      @grid_height = svg_height - label_height * 2
+      @y_min, @y_max, y_step = Util.scale(values.min, values.max)
+      @y_labels = (y_min..y_max).step(y_step)
+    end
+    
+    def section_calcs
+      @section_width = grid_width.to_d / (x_labels.count - 1)
+      @section_height = grid_height.to_d / (y_labels.count - 1)
+    end
+    
+    def tick_calcs
+      @x_label_y = x_axis_y
+      @y_label_x = y_axis_x
+      @x_ticks = (1..x_labels.size - 2).map { |i| x_tick_x(i) }
+      @y_ticks = (1..y_labels.size - 2).map { |i| y_tick_y(i) }
+    end
+    
+    def x_axis_y
+      grid_height + label_height * 1.5
+    end
+    
+    def y_axis_x
+      grid_width + OFFSET
+    end
+      
+    def x_tick_x(index)
+      section_width * index
+    end
+    
+    def y_tick_y(index)
+      return label_height + TOP_LEFT_OFFSET if index.eql?(y_labels.count - 1)
+      
+      (section_height * (y_labels.count - 1 - index)).round(6)
+    end
+    
+    def label_classes
+      [css_class + '-label', 'ac-toggleable'].join(' ')
+    end
+  end
+end