chartnado 0.0.2 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d20a622c24b68dc7509075f867353d33152c65e1
-  data.tar.gz: decb376a8d05741a798f5c7f1453e42dabb4a22c
+  metadata.gz: b20127157066903c9837361a882f6ed75b614895
+  data.tar.gz: 40ad1dcaeea450bddfefe6c345999b5122fa6c10
 SHA512:
-  metadata.gz: f6dfd3ab61414c73b224eb0cb2284878366fc98869ca803fd91907528bc4ec0ab9849759183022d77064a299f1d42b42cc24f71aab4030b3687302509970b70b
-  data.tar.gz: 89bdfe18afa1e640d104e9a2fb10dbb51faf9926496f7c4211ca0d79b07fcdd0d919e3b17284bc6278561930fa1b80dbff71bdffc61b388c50bb750acb09520c
+  metadata.gz: 70848f7173ba8bc4c6b2e7d754b978e767ec0b8e09a1aa8d7891609fa49c09a515a6329a7b0787f644d4c4b1c12a5ae08885f8dcd1df49f107dc141818b1f474
+  data.tar.gz: 2a898be78fe58e7530e3985b181f2d61f5ef315e982e8cdd921b8680661d03e037f7605fd44ce96ca657a07a31a4a095f84adba09ec2ac966e290c6d94986343

data/README.md

@@ -10,12 +10,14 @@ In your controller, add the following to tell the controller to respond to json
 include Chartnado
 ```
 
-Then in your views, now in your views, you can write an expression to show the average tasks completed per today relative to total tasks:
+Then in your views, you can write an expression to show the average tasks completed per today relative to total tasks like this:
 
 ```ruby
 <%= line_chart { Task.group_by_day(:completed_at).count / Task.count } %>
 ```
 
+See the demo of chartkick-remote and Chartnado at http://chartkick-remote-demo.heroku.com.
+
 ## Totals
 
 By default chartnado adds totals to pie and stacked area charts using some hacky settings for google charts.  To get the total to appear, you need to use the chartnado version of the chartkick javascript called `chartkick-chartnado.js` instead of `chartkick.js`.  If you are including the javascript in sprockets manifest file, this:

data/chartnado.gemspec

@@ -21,8 +21,9 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "activesupport", '>= 3'
   spec.add_dependency "chartkick", '>= 1.0'
-  spec.add_dependency "chartkick-remote", '>= 1.2'
+  spec.add_dependency "chartkick-remote", '>= 1.3'
   spec.add_dependency "railties", ">= 3.1"
+  spec.add_development_dependency "responders", '~> 2.0'
   spec.add_development_dependency "bundler", '~> 1.3'
   spec.add_development_dependency "rake", '~> 10.3'
   spec.add_development_dependency "rspec", '~> 3.0'

data/lib/chartnado/helpers/chart_helper.rb

@@ -14,7 +14,12 @@ module Chartnado::Helpers
         new_options = chartkick_options.reverse_merge(
           stacked: true,
           library: {
-            focusTarget: 'category',
+            focusTarget: 'category'
+          }
+        )
+        new_json_options = json_options.reverse_merge(show_total: true, reverse_sort: true)
+        new_options.reverse_merge!(
+          library: {
             series: {
               0 => {
                 lineWidth: 0,
@@ -23,9 +28,29 @@ module Chartnado::Helpers
               }
             }
           }
-        )
+        ) if new_json_options[:show_total]
         area_chart_without_chartnado(**new_options) do
-          data_block.call(json_options.reverse_merge(show_total: true, reverse_sort: true))
+          data_block.call(new_json_options)
+        end
+      end.render(*args, **options)
+    end
+
+    def pie_chart_with_chartnado(*args, **options, &block)
+      Chartnado::Renderer.new(self, block) do |chartkick_options, json_options, data_block|
+        new_json_options = json_options.reverse_merge(show_total: true)
+        new_options = chartkick_options.reverse_merge!(
+          library: {
+            series: {
+              0 => {
+                lineWidth: 0,
+                pointSize: 0,
+                visibleInLegend: false
+              }
+            }
+          }
+        ) if new_json_options[:show_total]
+        pie_chart_without_chartnado(**new_options) do
+          data_block.call(new_json_options)
         end
       end.render(*args, **options)
     end

data/lib/chartnado/renderer.rb

@@ -11,7 +11,7 @@ class Chartnado::Renderer
 
   delegate :controller, to: :context
 
-  def render(*args, **options)
+  def render(*args, ** options)
     json_options = {}
     chartkick_options = options.dup
 
@@ -40,40 +40,42 @@ class Chartnado::Renderer
     }
 
     if options[:wrapper_proc]
-      context.instance_exec(*args, renderer, **options, &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
+    series = Chartnado::Series::Wrap[series]
+    series *= 100.0 if percentage
+    if series.has_separate_named_series?
+      series = series.to_a
+      if series.first.second.respond_to?(:map)
         totals = Hash.new(0.0)
-        new_series = series.group_by{|k, v| k[0] }.sort_by { |k| k.to_s }
+        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[1]] += v if show_total
-              [k[1], 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] }
+            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 = series.sort_by { |item| item.first.to_s }
         new_series = new_series.reverse if reverse_sort
 
         if show_total
@@ -82,32 +84,32 @@ class Chartnado::Renderer
           new_series
         end
       end
-    elsif series.is_a?(Array) && series.first.is_a?(Array)
-      if series.first.second.respond_to?(:map)
+    elsif series.hash?
+      if (key = series.keys.first) and key.is_a?(Array) and key.size == 2
         totals = Hash.new(0.0)
-        new_series = series.sort_by { |item| item.first.to_s }
+        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] += v if show_total
-              [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] }
+            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 = series.sort_by { |key| key.to_s }
         new_series = new_series.reverse if reverse_sort
 
         if show_total
@@ -116,12 +118,10 @@ class Chartnado::Renderer
           new_series
         end
       end
+    elsif series.respond_to?(:map)
+      series
     else
-      if series.respond_to?(:map)
-        series
-      else
-        [['Total', series]]
-      end
+      [['Total', series]]
     end
   end
 end

data/lib/chartnado/series.rb

@@ -1,4 +1,7 @@
+require 'active_support/dependencies/autoload'
+require 'active_support/deprecation'
 require 'active_support/core_ext'
+require 'chartnado/series/wrap'
 
 module Chartnado
   module Series
@@ -9,35 +12,7 @@ module Chartnado
     #
     # @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
+      Wrap[series].times(val, precision: precision)
     end
 
     # @api public
@@ -46,46 +21,8 @@ module Chartnado
     #
     # @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
+      Wrap[top_series].
+        over(bottom_series, multiplier: multiplier, precision: precision)
     end
 
     # @api public
@@ -98,34 +35,7 @@ module Chartnado
     #
     # @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
+      Wrap[series.shift].add(*series, scalar_sum: scalar_sum)
     end
 
     # @api public
@@ -139,48 +49,5 @@ module Chartnado
       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/series/wrap.rb

@@ -0,0 +1,201 @@
+module Chartnado
+  module Series
+    class Wrap < SimpleDelegator
+      def self.[](series)
+        series.class == self ? series : new(series)
+      end
+
+      def *(val)
+        times(val, precision: nil)
+      end
+
+      def times(factor, precision: 2)
+        factor = wrap(factor)
+
+        return factor.times(self, precision: precision) if factor.dimensions > dimensions
+        return with_precision(precision, factor.to_f * to_f) unless dimensions > 1
+        return self unless length > 0
+
+        if has_separate_named_series? || array? && first.is_a?(Array)
+          result = map { |(name, data)| [name, wrap(data) * factor] }
+        elsif hash?
+          result = to_a.reduce({}) do |hash, (key, value)|
+            if factor.hash?
+              if key.is_a?(Array)
+                scalar = factor[key.second]
+              else
+                scalar = factor[key]
+              end
+            else
+              scalar = factor
+            end
+            scalar ||= 0
+            hash[key] = scalar * value
+            hash
+          end
+        else
+          result = map do |value|
+            factor * value
+          end
+        end
+
+        wrap(result)
+      end
+
+      def add(*series, scalar_sum: 0.0)
+        (series, scalars) = [__getobj__, *series].partition { |s| s.respond_to?(:map) }
+        scalar_sum += scalars.reduce(:+) || 0.0
+        return wrap(scalar_sum) unless series.present?
+
+        if wrap(series.first).has_separate_named_series?
+          result = series.map(&:to_a).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?(Hash)
+          keys = series.flat_map(&:keys).uniq
+          result = keys.reduce({}) do |hash, key|
+            hash[key] = (series.map { |s| s[key] }.compact.reduce(:+) || 0) + scalar_sum
+            hash
+          end
+        elsif series.first.is_a?(Array)
+          result = series.map { |s| s.reduce(:+) + scalar_sum }
+        else
+          result = scalar_sum
+        end
+
+        wrap(result)
+      end
+
+      def over(bottom, multiplier: 1.0, precision: 2)
+        bottom = wrap(bottom)
+        return times(1.0 * multiplier / bottom, precision: precision) if bottom.dimensions == 1
+
+        if dimensions > bottom.dimensions
+          top_series_by_name = data_by_name
+          if has_separate_named_series?
+            data_by_name.map do |name, top_values|
+              [
+                name,
+                wrap(top_values).
+                  over(bottom, multiplier: multiplier, precision: precision)
+              ]
+            end
+          else
+            bottom.reduce({}) do |hash, (key, value)|
+              top_series_by_name.keys.each do |name|
+                top_key = [name, *Array.wrap(key)]
+                top_value = top_series_by_name[name][top_key]
+                if top_value
+                  hash[top_key] = wrap(top_value).
+                    over(value, multiplier: multiplier, precision: precision)
+                end
+              end
+              hash
+            end
+          end
+        elsif array_of_named_series?
+          top_series_by_name = data_by_name
+          bottom.map do |(name, data)|
+            [
+              name,
+              wrap(top_series_by_name[name]).
+                over(data, multiplier: multiplier, precision: precision)
+            ]
+          end
+        elsif bottom.respond_to?(:reduce)
+          bottom.reduce({}) do |hash, (key, value)|
+            hash[key] = wrap(self[key] || 0).
+              over(value, multiplier: multiplier, precision: precision)
+            hash
+          end
+        else
+          with_precision(precision, to_f * multiplier.to_f / bottom.to_f)
+        end
+      end
+
+      def has_multiple_series?
+        array_of_named_series? || is_a?(Hash) && begin
+          first_series = series.first
+          first_series[0].is_a?(Array) && first_series[0].length > 1 || first_series[1].respond_to?(:length)
+        end
+      end
+
+      def hash?
+        __getobj__.is_a?(Hash)
+      end
+
+      def array?
+        __getobj__.is_a?(Array)
+      end
+
+      def array_of_named_series?
+        array? && first.second.is_a?(Hash)
+      end
+
+      def hash_of_named_series?
+        hash? && values.first && values.first.is_a?(Hash)
+      end
+
+      def dimensions
+        return 1 unless respond_to?(:length)
+        if hash?
+          if keys.first && keys.first.is_a?(Array) || hash_of_named_series?
+            3
+          else
+            2
+          end
+        else
+          if first && first.is_a?(Array)
+            3
+          else
+            2
+          end
+        end
+      end
+
+      def has_separate_named_series?
+        hash_of_named_series? || array_of_named_series?
+      end
+
+      private
+
+      def data_by_name
+        return self if hash_of_named_series?
+        result = if array_of_named_series?
+          reduce({}) do |hash, (name, values)|
+            hash[name] = values
+            hash
+          end
+        else
+          hash = Hash.new { |hash, key| hash[key] = {} }
+          x = reduce(hash) do |hash, (key, value)|
+            p key.first
+            new_key = Array.wrap(key.first).first
+            hash[new_key][key] = value
+            hash
+          end
+          p x
+          x
+        end
+        wrap(result)
+      end
+
+      def with_precision(precision, value)
+        value = value.round(precision) if precision
+        value
+      end
+
+      def wrap(val)
+        self.class[val]
+      end
+    end
+  end
+end

data/lib/chartnado/version.rb

@@ -1,3 +1,3 @@
 module Chartnado
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/rails_helper.rb

@@ -1,3 +1,4 @@
+require 'responders'
 require 'action_controller'
 require 'action_view'
 

data/spec/renderer_spec.rb

@@ -17,6 +17,12 @@ describe Chartnado::Renderer do
                  {name: :a, data: [[1, 10]]},
                  {name: :b, data: [[1, 20]]}]
       end
+      it "can add multiply by 100 to create a percentage" do
+        expect(chart_json({[:a, 1] => 0.1, [:b, 1] => 0.2}, percentage: true, show_total: true)).
+          to eq [{name: 'Total', data: [[1, 0]], tooltip: [[1, 30.0]]},
+                 {name: :a, data: [[1, 10.0]]},
+                 {name: :b, data: [[1, 20.0]]}]
+      end
       describe "with multiple scalar series" do
         it "can handle scalars" do
           expect(chart_json({:a => 10, :b => 20})).
@@ -40,6 +46,18 @@ describe Chartnado::Renderer do
                  {name: :b, data: [[1, 20]]}]
       end
     end
+    describe "for multiple series organized 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
+    end
     describe "for data that is just a scalar" do
       it "shows the scalar as the total" do
         expect(chart_json(10)).

data/spec/series_spec.rb

@@ -66,6 +66,16 @@ describe Chartnado::Series do
         expect(series_sum(2,[[:a, {0 => 3}]])).to eq ([[:a, {0 => 5}]])
       end
     end
+    describe "adding a scalar to an hash 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 a scalar to a hash with 2 dimensional keys" do
+      it "returns each item of the array with a scalar added" do
+        expect(series_sum({['a', 0] => 3}, 1)).to eq ({['a', 0] => 4})
+      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})
@@ -76,6 +86,11 @@ describe Chartnado::Series do
         expect(series_sum({0 => 1},{0 => 2}, 5)).to eq ({0 => 8})
       end
     end
+    describe "adding nothing but a scalar sum" do
+      it "returns the scalar sum" do
+        expect(series_sum(scalar_sum: 2)).to eq 2
+      end
+    end
   end
 
   describe "#series_ratio" do
@@ -103,8 +118,16 @@ describe Chartnado::Series do
     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})
+        expect(series_ratio({[:series_a, 0] => 1, [:series_a, 1] => 3},
+                            {0 => 2, 1 => 4})).to eq ({[:series_a, 0] => 0.5, [:series_a, 1] => 0.75})
+      end
+      describe "when the keys are time values" do
+        let(:t1) { Time.parse('2014-09-15 07:00:00 UTC') }
+        let(:t2) { Time.parse('2014-09-22 07:00:00 UTC') }
+        it "still returns the ratio" do
+          expect(series_ratio({[:series_a, t1] => 1, [:series_a, t2] => 3},
+                              {t1 => 2, t2 => 4})).to eq ({[:series_a, t1] => 0.5, [:series_a, t2] => 0.75})
+        end
       end
     end
     describe "ratio of an array of named series to a non-named series" do
@@ -113,8 +136,15 @@ describe Chartnado::Series do
                             {0 => 2})).to eq [[:series_a, {0 => 0.5}]]
       end
     end
+    describe "ratio of a hash 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
+      it "returns the ratio" do
         expect(series_ratio({0 => 1}, 2)).to eq ({0 => 0.5})
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: chartnado
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
 platform: ruby
 authors:
 - Andrew S. Brown
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-08-25 00:00:00.000000000 Z
+date: 2015-03-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '1.2'
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: responders
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -220,6 +234,7 @@ files:
 - lib/chartnado/helpers/series_helper.rb
 - lib/chartnado/renderer.rb
 - lib/chartnado/series.rb
+- lib/chartnado/series/wrap.rb
 - lib/chartnado/version.rb
 - spec/controllers/controller_spec.rb
 - spec/dsl_spec.rb
@@ -249,7 +264,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: Chartkick charts with extras