chartnado 0.0.1

data/lib/assets/javascripts/jquery.ajax.queue-concurrent.coffee

@@ -0,0 +1,76 @@
+# from https://gist.github.com/dontfidget/1ad9ab33971b64fe6fef
+# derived from https://gist.github.com/maccman/5790509
+
+$ = jQuery
+
+queues  = {}
+
+queue = (name) ->
+  name = 'default' if name is true
+  queues[name] or= {entries: [], running: 0}
+
+next = (name, done) ->
+  list = queue(name)
+
+  if done
+    queue(name).running--
+
+  unless list.entries.length
+    return
+
+  [options, deferred] = list.entries[0]
+
+  if list.running >= (options.queueMaxConcurrency || 1)
+    return
+
+  list.entries.shift()
+
+  queue(name).running++
+
+  $.ajax(options)
+  .always(-> next(name, true))
+  .done(-> deferred.resolve(arguments...))
+  .fail(-> deferred.reject(arguments...))
+
+push = (name, options) ->
+  list = queue(name)
+  deferred = $.Deferred()
+
+  while options && list.entries.length >= options.queueMaxDepth
+    [overflowOptions, overflowDeferred] = list.entries.shift()
+    overflowDeferred.reject null, "queue overflow"
+
+  list.entries.push([options, deferred])
+
+  next(name)
+  deferred.promise()
+
+remove = (name, options) ->
+  list = queue(name)
+
+  for [value, _], i in list.entries when value is options
+    list.entries.splice(i, 1)
+    break
+
+$.ajaxTransport '+*', (options) ->
+  if options.queue
+    queuedOptions = $.extend({}, options)
+    queuedOptions.queue = false
+    queuedOptions.processData = false
+
+    send: (headers, complete) ->
+      push(options.queue, queuedOptions)
+      .done (data, textStatus, jqXHR) ->
+        complete(jqXHR.status,
+          jqXHR.statusText,
+          text: jqXHR.responseText,
+          jqXHR.getAllResponseHeaders())
+
+      .fail (jqXHR, textStatus, errorThrown) ->
+        complete(jqXHR.status,
+          jqXHR.statusText,
+          text: jqXHR.responseText,
+          jqXHR.getAllResponseHeaders())
+
+    abort: ->
+      remove(options.queue, queuedOptions)

data/lib/chartnado.rb

@@ -0,0 +1,39 @@
+require 'chartnado/version'
+require 'chartnado/series'
+require 'chartnado/group_by'
+require 'chartnado/evaluator'
+require 'chartnado/helpers/chart_helper'
+require 'chartnado/helpers/series_helper'
+require 'chartnado/hash'
+require 'chartkick/remote'
+require 'chartnado/engine' if defined?(Rails)
+
+module Chartnado
+  extend ActiveSupport::Concern
+  attr_accessor :chartnado_options
+
+  included do
+    include Chartkick::Remote
+
+    helper Chartnado::Helpers::Chart
+  end
+
+  module ClassMethods
+    def chartnado_wrapper(wrapper_symbol = nil, **options, &block)
+      unless block
+        helper_method wrapper_symbol
+        block = -> (*args, **options) do
+          render_block = args.pop
+          send(wrapper_symbol, *args, **options, &render_block)
+        end
+      end
+
+      action_filter_options = options.extract!(:only, :except)
+
+      before_filter action_filter_options do
+        self.chartnado_options ||= {}
+        self.chartnado_options[:wrapper_proc] = block
+      end
+    end
+  end
+end

data/lib/chartnado/engine.rb

@@ -0,0 +1,10 @@
+module Chartnado
+  class Engine < ::Rails::Engine
+
+    initializer "precompile", :group => :all do |app|
+      # use a proc instead of a string
+      app.config.assets.precompile << Proc.new{|path| path == "chartkick-chartnado.js" }
+    end
+
+  end
+end

data/lib/chartnado/evaluator.rb

@@ -0,0 +1,82 @@
+module Chartnado
+  class Evaluator < SimpleDelegator
+    module Operators
+      def self.included(base)
+        %i{+ * - /}.each do |method|
+          define_method method do |*args, &block|
+            if Thread.current[:in_chartnado_block]
+              OperatorEvaluator.new(self).send(method, *args)
+            elsif defined?(super)
+              super(*args, &block)
+            else
+              raise NoMethodError, "#{method} is not defined"
+            end
+          end
+        end
+
+        def coerce(other)
+          return super unless Thread.current[:in_chartnado_block]
+          if other.is_a?(Numeric)
+            [self, other]
+          else
+            super
+          end
+        end
+      end
+    end
+
+    class OperatorEvaluator
+      include Series
+      extend Forwardable
+
+      def initialize(object)
+        @object = object
+      end
+
+      def *(value)
+        without_operators do
+          series_product(@object, value)
+        end
+      end
+
+      def +(value)
+        without_operators do
+          series_sum(value, @object)
+        end
+      end
+
+      def -(value)
+        self + -1.0 * value
+      end
+
+      def /(value)
+        without_operators do
+          series_ratio(@object, value)
+        end
+      end
+
+      def_delegator Chartnado::Evaluator, :without_operators
+    end
+
+    def self.without_operators
+      in_chartnado_block = Thread.current[:in_chartnado_block]
+      Thread.current[:in_chartnado_block] = nil
+      yield
+    ensure
+      Thread.current[:in_chartnado_block] = in_chartnado_block
+    end
+
+    def self.with_operators(&block)
+      original_value = Thread.current[:in_chartnado_block]
+      binding = eval 'self', block.binding
+      Thread.current[:in_chartnado_block] = true
+      Evaluator.new(binding).instance_eval(&block)
+    ensure
+      Thread.current[:in_chartnado_block] = original_value
+    end
+  end
+
+  def self.with_chartnado_dsl(&block)
+    Evaluator.with_operators(&block)
+  end
+end

data/lib/chartnado/group_by.rb

@@ -0,0 +1,92 @@
+require 'chartnado/series'
+
+module Chartnado::GroupBy
+  include Chartnado::Series
+
+  # @api public
+  # @example
+  #   group_by('tasks.user_id', Task.all) { count('DISTINCT project_id') }
+  #
+  # @return [Multiple-Series]
+  def group_by(group_name, scope, label_block = nil, &eval_block)
+    group_values = [group_name] + scope.group_values
+    series = scope.except(:group).group(group_values).
+      instance_eval(&eval_block)
+
+    if label_block
+      update_key_from_block = lambda do |(key, data)|
+        if key.is_a?(Array)
+          group_key = key.first
+          sub_key = key[1..-1]
+          sub_key = sub_key.first if sub_key.length == 1
+          data = {sub_key => data}
+        else
+          group_key = key
+        end
+        (new_key, data) = label_block.call(group_key, data)
+        if key.is_a?(Array)
+          {[new_key, *Array.wrap(sub_key)] => data.values.first}
+        else
+          {new_key => data}
+        end
+      end
+
+      if series.length > 0
+        series_sum *series.map(&update_key_from_block)
+      else
+        {}
+      end
+    else
+      series
+    end
+  end
+
+
+  # @api public
+  # @example
+  #   mean([0,1]) => {0.5}
+  #
+  # @return Value
+  def mean(array)
+    array.reduce(:+) / array.length
+  end
+
+  # @api public
+  # @return Value
+  def harmonic_mean(array)
+    array = array.reject(&:zero?)
+    return nil unless array.present?
+    array.size / (array.reduce(0) { |mean, value| mean + 1.0 / value })
+  end
+
+  # @api public
+  # @return Value
+  def geometric_mean(array)
+    array.reduce(:*) ** (1.0 / array.length)
+  rescue Math::DomainError
+    nil
+  end
+
+  # @api public
+  # @return Value
+  def grouped_median(series)
+    series.group_by(&:first).reduce({}) do |hash, (key, values)|
+      hash[key] = median(values.map(&:second))
+      hash
+    end
+  end
+
+  # @api public
+  # @return Value
+  def grouped_mean_and_median(series)
+    series.group_by(&:first).reduce({}) do |hash, (key, values)|
+      values = values.map(&:second).compact
+      next hash unless values.present?
+      hash[['median', key]] = median(values)
+      hash[['mean', key]] = mean(values)
+      hash[['geometric', key]] = geometric_mean(values)
+      hash[['harmonic', key]] = harmonic_mean(values)
+      hash
+    end
+  end
+end

data/lib/chartnado/hash.rb

@@ -0,0 +1,3 @@
+class Hash
+  include Chartnado::Evaluator::Operators
+end

data/lib/chartnado/helper.rb

@@ -0,0 +1,7 @@
+require 'active_support/core_ext'
+
+module Chartnado::Helper
+  def chartnado_eval(&block)
+    Chartnado.with_chartnado_dsl(&block)
+  end
+end

data/lib/chartnado/helpers/chart_helper.rb

@@ -0,0 +1,60 @@
+require 'chartnado/renderer'
+require 'chartkick'
+require 'chartkick/remote/helper'
+
+# These helpers can be included in your view using `helper Chartnado::Helpers::Chart`.
+# They override the default chartkick chart rendering methods with ones that support chartnado DSL.
+module Chartnado::Helpers
+  module Chart
+    include Chartkick::Helper
+    include Chartkick::Remote::Helper
+
+    def stacked_area_chart(*args, **options, &block)
+      Chartnado::Renderer.new(self, block) do |chartkick_options, json_options, data_block|
+        new_options = chartkick_options.reverse_merge(
+          stacked: true,
+          library: {
+            focusTarget: 'category',
+            series: {
+              0 => {
+                lineWidth: 0,
+                pointSize: 0,
+                visibleInLegend: false
+              }
+            }
+          }
+        )
+        area_chart_without_chartnado(**new_options) do
+          data_block.call(json_options.reverse_merge(show_total: true, reverse_sort: true))
+        end
+      end.render(*args, **options)
+    end
+
+    def line_chart_with_chartnado(*args, **options, &block)
+      Chartnado::Renderer.new(self, block) do |chartkick_options, json_options, data_block|
+        new_options = chartkick_options.reverse_merge(
+          library: {
+            curveType: "none",
+            pointSize: 2,
+            focusTarget: 'category'
+          })
+        line_chart_without_chartnado(**new_options) do
+          data_block.call(**json_options)
+        end
+      end.render(*args, **options)
+    end
+
+    alias_method_chain :line_chart, :chartnado
+
+    %i{geo_chart pie_chart column_chart bar_chart area_chart}.each do |chart_type|
+      define_method(:"#{chart_type}_with_chartnado") do |*args, **options, &block|
+        Chartnado::Renderer.new(self, block) do |chartkick_options, json_options, data_block|
+          send(:"#{chart_type}_without_chartnado", **chartkick_options) do
+            data_block.call(**json_options)
+          end
+        end.render(*args, **options)
+      end
+      alias_method_chain chart_type, :chartnado
+    end
+  end
+end

data/lib/chartnado/helpers/series_helper.rb

@@ -0,0 +1,35 @@
+module Chartnado::Helpers
+  module Series
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def define_series(name, &block)
+        define_method(name) do
+          Chartnado.with_chartnado_dsl do
+            self.instance_exec(&block)
+          end
+        end
+
+        memoized_name = :"@_memoized_#{name}"
+        define_method(:"#{name}_with_memoized") do |suffix: nil|
+          current_value = instance_variable_get(memoized_name)
+          if !current_value
+            series = send(:"#{name}_without_memoized")
+            instance_variable_set(memoized_name, series)
+          else
+            series = current_value
+          end
+          series = add_suffix_to_series_name(series, suffix) if suffix
+          series
+        end
+        alias_method_chain name, :memoized
+      end
+
+      def define_multiple_series(series)
+        series.each do |name, proc|
+          define_series(name, &proc)
+        end
+      end
+    end
+  end
+end

data/lib/chartnado/renderer.rb

@@ -0,0 +1,127 @@
+class Chartnado::Renderer
+  include Chartnado::Series
+
+  attr_accessor :context, :data_block, :render_block
+
+  def initialize(context, data_block, &render_block)
+    @context = context
+    @data_block = data_block
+    @render_block = render_block
+  end
+
+  delegate :controller, to: :context
+
+  def render(*args, **options)
+    json_options = {}
+    chartkick_options = options.dup
+
+    if args.length > 1
+      if args.last.is_a?(Hash)
+        json_options = chartkick_options
+        chartkick_options = args[1].dup
+      end
+      args.select { |arg| arg.is_a?(Symbol) }.each do |key|
+        json_options[key] = true unless json_options.has_key?(key)
+      end
+    end
+
+    if json_options[:percentage]
+      chartkick_options.reverse_merge!(max: 100.0)
+    end
+
+    options = controller.chartnado_options if controller.respond_to?(:chartnado_options)
+    options ||= {}
+
+    chart_json_proc = -> (*args) {
+      chart_json(Chartnado.with_chartnado_dsl(&data_block), *args)
+    }
+    renderer = -> {
+      context.instance_exec(chartkick_options, json_options, chart_json_proc, &render_block)
+    }
+
+    if options[:wrapper_proc]
+      context.instance_exec(*args, renderer, **options, &options[:wrapper_proc])
+    else
+      renderer.call
+    end
+  end
+
+  def chart_json(series, show_total: false, reverse_sort: false, percentage: false)
+    series = series_product(100.0, series) if percentage
+    if series.is_a?(Hash)
+      if (key = series.keys.first) and key.is_a?(Array) and key.size == 2
+        totals = Hash.new(0.0)
+        new_series = series.group_by{|k, v| k[0] }.sort_by { |k| k.to_s }
+        new_series = new_series.reverse if reverse_sort
+
+        new_series = new_series.map do |name, data|
+          {
+            name: name,
+            data: data.map do |k, v|
+              totals[k[1]] += v if show_total
+              [k[1], v]
+            end
+          }
+        end
+
+        if show_total
+          [{name: 'Total',
+            data: totals.map {|k,v| [k, 0] },
+            tooltip: totals.map {|k,v| [k, v] }
+           }] + new_series
+        else
+          new_series
+        end
+      else
+        new_series = series.sort_by { |key| key.to_s }
+        new_series = new_series.reverse if reverse_sort
+
+        if show_total
+          new_series << ['Total', new_series.map(&:second).reduce(0, :+)]
+        else
+          new_series
+        end
+      end
+    elsif series.is_a?(Array) && series.first.is_a?(Array)
+      if series.first.second.respond_to?(:map)
+        totals = Hash.new(0.0)
+        new_series = series.sort_by { |item| item.first.to_s }
+        new_series = new_series.reverse if reverse_sort
+
+        new_series = new_series.map do |name, data|
+          {
+            name: name,
+            data: data.map do |k, v|
+              totals[k] += v if show_total
+              [k, v]
+            end
+          }
+        end
+
+        if show_total
+          [{name: 'Total',
+            data: totals.map {|k,v| [k, 0] },
+            tooltip: totals.map {|k,v| [k, v] }
+           }] + new_series
+        else
+          new_series
+        end
+      else
+        new_series = series.sort_by { |item| item.first.to_s }
+        new_series = new_series.reverse if reverse_sort
+
+        if show_total
+          new_series << ['Total', new_series.map(&:second).reduce(0, :+)]
+        else
+          new_series
+        end
+      end
+    else
+      if series.respond_to?(:map)
+        series
+      else
+        [['Total', series]]
+      end
+    end
+  end
+end