chartnado 0.0.1

data/lib/chartnado/series.rb

@@ -0,0 +1,186 @@
+require 'active_support/core_ext'
+
+module Chartnado
+  module Series
+    # @api public
+    # @example
+    #   series_product(2.0, {0 => 1}) => {0 => 2.0}
+    #   series_product({0 => 1}, 2.0) => {0 => 2.0}
+    #
+    # @return [Series/Multiple-Series]
+    def series_product(val, series, precision: 2)
+      if dimensions(val) > dimensions(series)
+        return series_product(series, val)
+      end
+
+      return with_precision(precision, val.to_f * series.to_f) unless series.respond_to?(:length)
+      return series unless series.length > 0
+
+      if is_an_array_of_named_series?(series) || series.is_a?(Array) && series.first.is_a?(Array)
+        series.map { |(name, data)| [name, series_product(val, data)] }
+      elsif series.is_a?(Hash)
+        series.to_a.reduce({}) do |hash, (key, value)|
+          if val.is_a?(Hash)
+            if key.is_a?(Array)
+              scalar = val[key.second]
+            else
+              scalar = val[key]
+            end
+          else
+            scalar = val
+          end
+          scalar ||= 0
+          hash[key] = scalar * value
+          hash
+        end
+      else
+        series.map do |value|
+          val * value
+        end
+      end
+    end
+
+    # @api public
+    # @example
+    #   series_ratio({0 => 1}, 2.0) => {0 => 0.5}
+    #
+    # @return [Series/Multiple-Series]
+    def series_ratio(top_series, bottom_series, multiplier: 1.0, precision: 2)
+      if bottom_series.is_a?(Numeric)
+        return series_product(1.0 * multiplier / bottom_series, top_series, precision: precision)
+      end
+      if has_multiple_series?(top_series) && !has_multiple_series?(bottom_series)
+        top_series_by_name = data_by_name(top_series)
+        if is_an_array_of_named_series?(top_series)
+          top_series_by_name.map do |name, top_values|
+            [
+              name,
+              series_ratio(top_values, bottom_series, multiplier: multiplier, precision: precision)
+            ]
+          end
+        else
+          bottom_series.reduce({}) do |hash, (key, value)|
+            top_series_by_name.keys.each do |name|
+              top_key = [name, *key]
+              top_value = top_series_by_name[name][top_key]
+              if top_value
+                hash[top_key] = series_ratio(top_value, value, multiplier: multiplier, precision: precision)
+              end
+            end
+            hash
+          end
+        end
+      elsif is_an_array_of_named_series?(bottom_series)
+        top_series_by_name = data_by_name(top_series)
+        bottom_series.map do |(name, data)|
+          [
+            name,
+            series_ratio(top_series_by_name[name], data, multiplier: multiplier, precision: precision)
+          ]
+        end
+      elsif bottom_series.respond_to?(:reduce)
+        bottom_series.reduce({}) do |hash, (key, value)|
+          hash[key] = series_ratio(top_series[key] || 0, value, multiplier: multiplier, precision: precision)
+          hash
+        end
+      else
+        with_precision(precision, top_series.to_f * multiplier.to_f / bottom_series.to_f)
+      end
+    end
+
+    # @api public
+    # @example
+    #   series_sum({0 => 1}, 2.0) => {0 => 3.0}
+    #   series_sum({0 => 1}, {0 => 1}) => {0 => 2}
+    #   series_sum({0 => 1}, 2.0, 3.0) => {0 => 6.0}
+    #   series_sum(1, 2) => 3
+    #   series_sum() => []
+    #
+    # @return [Series/Multiple-Series/Scalar]
+    def series_sum(*series, scalar_sum: 0.0)
+      return [] unless series.length > 0
+
+      (series, scalars) = series.partition { |s| s.respond_to?(:map) }
+      scalar_sum += scalars.reduce(:+) || 0.0
+
+      if series.first.is_a?(Hash)
+        keys = series.map(&:keys).flatten(1).uniq
+        keys.reduce({}) do |hash, key|
+          hash[key] = (series.map { |s| s[key] }.compact.reduce(:+) || 0) + scalar_sum
+          hash
+        end
+      elsif is_an_array_of_named_series?(series.first)
+        series.flatten(1).group_by(&:first).map do |name, values|
+          data = values.map(&:second).reduce(Hash.new(scalar_sum)) do |hash, values|
+            values.each do |key, value|
+              hash[key] += value
+            end
+            hash
+          end
+          [
+            name, data
+          ]
+        end
+      elsif series.first.is_a?(Array)
+        series.map { |s| s.reduce(:+) + scalar_sum }
+      else
+        scalar_sum
+      end
+    end
+
+    # @api public
+    # @example
+    #   median([0,1]) => {0.5}
+    #   median([0,1,1,2,2]) => {1}
+    #
+    # @return Value
+    def median(array)
+      sorted = array.sort
+      len = sorted.length
+      (sorted[(len - 1) / 2] + sorted[len / 2]) / 2.0
+    end
+
+    private
+
+    def data_by_name(series)
+      if is_an_array_of_named_series?(series)
+        series.reduce({}) do |hash, value|
+          hash[value.first] = value.second
+          hash
+        end
+      else
+        series.reduce({}) do |hash, (key, value)|
+          new_key = Array.wrap(key.first).first
+          hash[new_key] = {key => value }
+          hash
+        end
+      end
+    end
+
+    def series_names(series)
+      series.map { |key| key.first }.uniq
+    end
+
+    def has_multiple_series?(series)
+      is_an_array_of_named_series?(series) || series.is_a?(Hash) && series.first && series.first[0].is_a?(Array) && series.first[0].length > 1
+    end
+
+    def is_an_array_of_named_series?(series)
+      series.is_a?(Array) && series.first.second.is_a?(Hash)
+    end
+
+    def dimensions(series)
+      return 1 unless series.respond_to?(:length)
+      if series.first && series.first.is_a?(Array)
+        3
+      else
+        2
+      end
+    end
+
+    def with_precision(precision, value)
+      value = value.round(precision) if precision
+      value
+    end
+  end
+end

data/lib/chartnado/version.rb

@@ -0,0 +1,3 @@
+module Chartnado
+  VERSION = "0.0.1"
+end

data/spec/controllers/controller_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'rails_helper'
+
+describe "Controller Methods", type: :controller do
+  render_views
+
+  routes do
+    ActionDispatch::Routing::RouteSet.new.tap do |routes|
+      routes.draw { get "show" => "anonymous#show" }
+    end
+  end
+
+  controller do
+    include Chartnado
+
+    chartkick_remote remote: false
+
+    define_method :_routes do
+      ActionDispatch::Routing::RouteSet.new.tap do |routes|
+        routes.draw { get "show" => "anonymous#show" }
+      end
+    end
+
+    def show
+    end
+  end
+
+  describe ".chartnado_wrapper" do
+    describe "when the wrapper is referenced by symbol" do
+      before do
+        controller.singleton_class.class_eval do
+          chartnado_wrapper :wrap_chart
+
+          def show
+            render inline: "<% area_chart { {0 => 1} / 2.0 } %>"
+          end
+        end
+      end
+
+      it "calls the wrapper in the context of the helpers" do
+        routes.draw { get "show" => "anonymous#show" }
+        expect(controller).to receive(:wrap_chart)
+        get :show
+      end
+    end
+
+    describe "when the wrapper is desribed by a block" do
+      before do
+        controller.singleton_class.class_eval do
+          chartnado_wrapper do |*args, **options, &block|
+            throw :wrapper_was_called
+          end
+
+          def show
+            render inline: "<% area_chart { {0 => 1} / 2.0 } %>"
+          end
+        end
+      end
+
+      it "calls the wrapper in the context of the helpers" do
+        routes.draw { get "show" => "anonymous#show" }
+        expect {
+          get :show
+        }.to throw_symbol :wrapper_was_called
+      end
+    end
+  end
+end

data/spec/dsl_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Chartnado do
+  it "provides a dsl for vector operations" do
+    expect(Chartnado.with_chartnado_dsl { {a: 2} / 2 }).to eq({a: 1})
+  end
+end

data/spec/helpers/chart_helper_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'rails_helper'
+
+describe Chartnado::Helpers::Chart, type: :helper do
+  def works?(&block)
+    expect {
+      block.call
+    }.not_to raise_exception
+  end
+
+  describe "#area_chart" do
+    it "supports the dsl" do
+      works? { helper.area_chart { {1 => 2} / 2.0 } }
+    end
+
+    describe "with a custom renderer" do
+      it "calls the custom renderer" do
+        wrapper_proc = proc { throw :wrapper_was_called }
+        expect {
+          expect(controller).to receive(:chartnado_options).and_return({wrapper_proc: wrapper_proc})
+          helper.area_chart { {1 => 2} / 2.0 }
+        }.to throw_symbol :wrapper_was_called
+      end
+    end
+  end
+
+  describe "#stacked_area_chart" do
+    it "supports the dsl" do
+      works? { helper.stacked_area_chart { {1 => 2} / 2.0 } }
+    end
+    describe "percentage option" do
+    end
+  end
+
+  describe "#pie_chart" do
+    it "supports the dsl" do
+      works? { helper.pie_chart { {1 => 2} / 2.0 } }
+    end
+  end
+
+  describe "#geo_chart" do
+    it "supports the dsl" do
+      works? { helper.geo_chart { {1 => 2} / 2.0 } }
+    end
+  end
+
+  describe "#line_chart" do
+    it "supports the dsl" do
+      works? { helper.line_chart { {1 => 2} / 2.0 } }
+    end
+    xit "includes total"
+    describe "percentage option" do
+    end
+  end
+end

data/spec/helpers/series_helper_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+require 'rails_helper'
+
+describe Chartnado::Helpers::Series, type: :helper do
+  let(:test_class) {
+    Class.new do
+      include Chartnado::Helpers::Series
+    end
+  }
+
+  describe ".define_series" do
+    it "lets the user define a series using the chartnado dsl" do
+      test_class.class_eval do
+        define_series :my_series do
+          {0 => 1} / 2
+        end
+      end
+      expect(test_class.new.my_series).to eq({0 => 0.5})
+    end
+  end
+  describe ".define_multiple_series" do
+    it "lets the user define multiple series using the chartnado dsl" do
+      test_class.class_eval do
+        define_multiple_series(
+          my_first_series: -> { {0 => 1} / 2 },
+          my_second_series: -> { {1 => 1} / 2 }
+        )
+      end
+      expect(test_class.new.my_first_series).to eq({0 => 0.5})
+      expect(test_class.new.my_second_series).to eq({1 => 0.5})
+    end
+  end
+end

data/spec/rails_helper.rb

@@ -0,0 +1,4 @@
+require 'action_controller'
+require 'action_view'
+
+require 'rspec/rails'

data/spec/renderer_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Chartnado::Renderer do
+  describe "#chart_json" do
+    def chart_json(*series, **options)
+      Chartnado::Renderer.new(nil, nil).chart_json(*series, **options)
+    end
+
+    describe "for data formatted as a hash" do
+      it "can generate chartkick compatible series" do
+        expect(chart_json({[:a, 1] => 10, [:b, 1] => 20})).
+          to eq [{name: :a, data: [[1, 10]]}, {name: :b, data: [[1,20]]}]
+      end
+      it "can add totals" do
+        expect(chart_json({[:a, 1] => 10, [:b, 1] => 20}, show_total: true)).
+          to eq [{name: 'Total', data: [[1, 0]], tooltip: [[1, 30.0]]},
+                 {name: :a, data: [[1, 10]]},
+                 {name: :b, data: [[1, 20]]}]
+      end
+      describe "with multiple scalar series" do
+        it "can handle scalars" do
+          expect(chart_json({:a => 10, :b => 20})).
+            to eq([[:a, 10], [:b, 20]])
+        end
+        it "can add totals" do
+          expect(chart_json({:a => 10, :b => 20}, show_total: true)).
+            to eq([[:a, 10], [:b, 20], ['Total', 30]])
+        end
+      end
+    end
+    describe "for data formatted as an array" do
+      it "can generate chartkick compatible series" do
+        expect(chart_json([[:a, {1 => 10}], [:b, {1 => 20}]])).
+          to eq [{name: :a, data: [[1, 10]]}, {name: :b, data: [[1,20]]}]
+      end
+      it "can add totals" do
+        expect(chart_json([[:a, {1 => 10}], [:b, {1 => 20}]], show_total: true)).
+          to eq [{name: 'Total', data: [[1, 0]], tooltip: [[1, 30.0]]},
+                 {name: :a, data: [[1, 10]]},
+                 {name: :b, data: [[1, 20]]}]
+      end
+    end
+    describe "for data that is just a scalar" do
+      it "shows the scalar as the total" do
+        expect(chart_json(10)).
+          to eq [['Total', 10]]
+      end
+    end
+  end
+end

data/spec/series_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe Chartnado::Series do
+  before do
+    class << self
+      include Chartnado::Series
+    end
+  end
+
+  describe "#series_product" do
+    describe "multiplying a hash by a scalar" do
+      it "returns the product of a scalar and a hash" do
+        expect(series_product(2, {0 => 3})).to eq ({0 => 6})
+      end
+    end
+    describe "multiplying an array by a scalar" do
+      it "returns the product of a scalar and a hash" do
+        expect(series_product(2, [3, 7])).to eq [6, 14]
+      end
+    end
+    describe "multiplying an scalar by a scalar" do
+      it "returns the product of a scalar and a hash" do
+        expect(series_product(2, 3)).to eq 6
+      end
+    end
+    describe "multiplying an hash of named series by a scalar" do
+      it "returns the product of a scalar and each named_series" do
+        expect(
+          series_product(
+            2,
+            {[:series_a, 0] => 3,
+             [:series_b, 1] => 4}
+          )).to eq ({[:series_a, 0] => 6, [:series_b, 1] => 8})
+      end
+    end
+    describe "multiplying an array of named series by a scalar" do
+      it "returns the product of a scalar and each named_series" do
+        expect(
+          series_product(
+            2,
+            [[:series_a, {0 => 3}],
+             [:series_b, {1 => 4}]]
+          )).to eq [[:series_a, {0 => 6}], [:series_b, {1 => 8}]]
+      end
+    end
+  end
+
+  describe "#series_sum" do
+    describe "adding two scalars" do
+      it "returns the sum of the scalars" do
+        expect(series_sum(2,3)).to eq 5
+      end
+    end
+    describe "adding a scalar to an array" do
+      it "returns each item of the array with a scalar added" do
+        expect(series_sum(2,[3])).to eq [5]
+      end
+    end
+    describe "adding a scalar to a hash" do
+      it "returns each item of the array with a scalar added" do
+        expect(series_sum(2,{0 => 3})).to eq ({0 => 5})
+      end
+    end
+    describe "adding a scalar to an array of named series" do
+      it "returns each item of the array with a scalar added" do
+        expect(series_sum(2,[[:a, {0 => 3}]])).to eq ([[:a, {0 => 5}]])
+      end
+    end
+    describe "adding two hashes" do
+      it "returns each item of the array with a scalar added" do
+        expect(series_sum({0 => 1},{0 => 2})).to eq ({0 => 3})
+      end
+    end
+    describe "adding two hashes and a scalar" do
+      it "returns each item of the array with a scalar added" do
+        expect(series_sum({0 => 1},{0 => 2}, 5)).to eq ({0 => 8})
+      end
+    end
+  end
+
+  describe "#series_ratio" do
+    describe "ratio of two scalars" do
+      it "returns the ratio" do
+        expect(series_ratio(1, 2)).to eq 0.5
+      end
+    end
+    describe "ratio of two hashes" do
+      it "returns the ratio" do
+        expect(series_ratio({0 => 1}, {0 => 2})).to eq ({0 => 0.5})
+      end
+    end
+    describe "ratio of a named series to another named series" do
+      it "returns the ratio" do
+        expect(series_ratio({[:series_a, 0] => 1},
+                            {[:series_a, 0] => 2})).to eq ({[:series_a, 0] => 0.5})
+      end
+    end
+    describe "ratio of an array of named series to another array of named series" do
+      it "returns the ratio" do
+        expect(series_ratio([[:series_a, {0 => 1}]],
+                            [[:series_a, {0 => 2}]])).to eq [[:series_a, {0 => 0.5}]]
+      end
+    end
+    describe "ratio of a named series to a non-named series" do
+      it "returns the ratio" do
+        expect(series_ratio({[:series_a, 0] => 1},
+                            {0 => 2})).to eq ({[:series_a, 0] => 0.5})
+      end
+    end
+    describe "ratio of an array of named series to a non-named series" do
+      it "returns the ratio" do
+        expect(series_ratio([[:series_a, {0 => 1}]],
+                            {0 => 2})).to eq [[:series_a, {0 => 0.5}]]
+      end
+    end
+    describe "ratio of a series to a scalar" do
+      xit "returns the ratio" do
+        expect(series_ratio({0 => 1}, 2)).to eq ({0 => 0.5})
+      end
+    end
+
+    describe "including a multiplier" do
+      describe "for ratio of two scalars" do
+        it "returns the ratio times the multiplier" do
+          expect(series_ratio(1, 2, multiplier: 100)).to eq 50
+        end
+      end
+    end
+
+    describe "specifying the precision" do
+      describe "for ratio of two scalars" do
+        it "returns the ratio rounded to the specified precision" do
+          expect(series_ratio(1, 3, precision: 1)).to eq 0.3
+        end
+      end
+    end
+  end
+end