ar_to_chart 0.0.1 → 0.0.2

data/.gitignore

@@ -1,3 +1,4 @@
 pkg/*
 *.gem
 .bundle
+*.DS_Store

data/CHANGELOG

@@ -0,0 +1,3 @@
+2010/11/1 ar_to_chart v0.0.1
+
+*	Initial conversion from plugin

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Kip Cole
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.textile

@@ -0,0 +1,36 @@
+h1. Description
+
+p. ar_to_chart generates Highcharts-based charts from an ActiveRecord result set. For example:
+
+bc. Product.all.to_chart(:price, :product)
+
+p. Will generate HTML for a chart container and javascript to render the chart in the browser.
+
+h2. Dependencies
+
+ar_to_chart depends on:
+
+*	jQuery (jquery.com)
+*	Highcharts (www.highcharts.com)
+*	arToChart javascript object (found in the files directory of the gem). This is the javascript interface between ar_to_chart and the Highcharts library
+*	ar_to_chart.css (found in the files directory of the gem).  This css defines the attributes used by the ar_to_chart javascript.
+
+h2. Examples
+
+p. Coming soon
+
+h2. Options
+
+p. Also coming soon
+
+h1. License
+
+(The MIT License)
+
+Copyright © 2010 Kip Cole
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the ‘Software’), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED ‘AS IS’, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/ar_to_chart.gemspec

@@ -12,9 +12,8 @@ Gem::Specification.new do |s|
   s.summary     = %q{Render an ActiveRecord result set as a chart}
   s.description = <<-EOF
     Defines Array#to_chart that will accept ActiveRecord result sets
-    and render them as a chart.  Currently assumes OpenFlashChart as the
-    only supported charting engine.  Protovis based charting coming
-    soon.
+    and render them as a chart.  Currently assumes Highcharts (highcharts.com)
+    as the charting engine.
   EOF
 
   s.rubyforge_project = "ar_to_chart"

data/files/ar_to_chart.css

@@ -0,0 +1,33 @@
+/* 
+For Highcharts
+These are sort of proxy classes.  They are here just so we can access the
+attributes in JS and apply them to charts.  
+*/
+
+/* Chart background */
+#highcharts				{ background-color: #ddd; }
+
+/* Used for axis text */
+#highcharts-text { 
+	color: 				black;
+	font-size: 			90%;
+	font-weight: 		normal;
+}
+
+/* Area graph color for the area */
+#highcharts-area { 
+	color: 				rgb(25,135,213); 
+	color: 				rgba(25,135,213, 0.3);
+}
+
+/* Chart line color */
+#highcharts-line 		{ color: rgb(25,135,213); }
+
+/* Gridlines color */
+#highcharts-gridlines	{ color: white;}
+
+/* Axis line color */
+#highcharts-axis		{ color: #777; }
+
+/* X-Axis plotbands color */
+#highcharts-xbands		{ color: #ccc }

data/files/ar_to_chart.js

@@ -0,0 +1,238 @@
+function arToChart() {
+   // Set up the various colours we want to use here
+	var self = this;
+
+   	// Add some hidden structure that we can then use to get color and style information from
+   	var template = "<div style='display:none;width=1em'><p id=highcharts>&nbsp</p>" + 
+				  "<p id=highcharts-text>&npsb</p><p id=highcharts-area>&npsb</p>" +
+				  "<p id=highcharts-line>&npsb</p><p id=highcharts-gridlines>&npsb</p>" + 
+				  "<p id=highcharts-axis>&npsb</p><p id=highcharts-xbands>&npsb</p></div>";
+   	$('body').append(template);
+   
+	this.font = {
+		size:   $('#highcharts-text').css('font-size'),
+		family: $('#highcharts-text').css('font-family'),
+		weight: $('#highcharts-text').css('font-weight'),
+		color:  $('#highcharts-text').css('color')
+   	}
+
+   	this.lineWeight = {
+		grid:   1,
+		axis:   1
+   	}
+
+   	this.colors = {
+		background:  $('#highcharts').css('background-color'), 
+	  	areaFill:    $('#highcharts-area').css('color'),
+		areaOpacity: $('#highcharts-area').css('opacity'),
+		gridLines:   $('#highcharts-gridlines').css('color'),
+		lineColor:   $('#highcharts-line').css('color'),
+		xAxisLine:   $('#highcharts-axis').css('color'),
+		yAxisLine: 	 $('#highcharts-axis').css('color'),
+		plotBands: 	 $('#highcharts-xbands').css('color')  
+   	};
+
+	function will_print() {
+		return window.location.href.match(/print=/) || pdf_export();
+	}
+	
+	function pdf_export() {
+		return $('meta[name=pdf-output]').length > 0;
+	}
+	
+	function getLineWidth(series) {
+		if (pdf_export) {
+			return 1; 
+		} else {
+			return (series.length > 50) ? 1 : self.lineWeight.axis;
+		}
+	}
+
+	// Render an Area chart with one or more data series
+   	this.area = function(container, categories, series_data, options) {
+
+		/* Put colors into plotbands */
+		if (options.x_plot_bands) {
+			$(options.x_plot_bands).each(function(index, item) {
+				item.color = self.colors.plotBands;
+			});
+		};
+
+		return chart = new Highcharts.Chart({
+			chart: {
+				credits: 			{ 
+					enabled: false
+				},
+				borderWidth: 		0,
+				borderColor: 		self.colors.background,
+	         	renderTo: 			container, 
+	         	defaultSeriesType: 'area',
+			 	backgroundColor: 	self.colors.background,
+			 	marginTop: 			15,
+			 	zoomType: 		    'x'
+	      	},
+		    navigation: {
+		        buttonOptions: {
+		            backgroundColor: self.colors.background
+		        }
+			},
+			exporting: {
+				enabled: !will_print()
+		    },
+	      	title: {
+	        	text: options.title || ''
+	      	},
+	      	subtitle: {
+	        	text: options.subtitle || ''
+	      	},
+	      	xAxis: {
+			 	type: 				(categories ? 'linear' : 'datetime'),
+			 	categories:    		categories,
+			 	gridLineColor: 		self.colors.gridLines,
+			 	gridLineWidth: 		(series_data[0].data.length > 50) ? 0 : self.lineWeight.grid,
+			 	lineColor:     		self.colors.xAxisLine,
+			 	lineWidth:     		getLineWidth(series_data[0].data),
+			 	title: {
+					text: options.x_axis || ''
+			 	},
+				labels: {
+					step: 			options.x_step || 1,
+					staggerLines: 	options.staggerLines || 1, 
+					style: {
+						fontSize: 	self.font.size,
+						fontFamily: self.font.family,
+						fontWeight: self.font.weight,
+						color:      self.font.color
+					},
+	            	formatter: function() {
+						return this.value; 
+	            	}
+	         	},
+	            plotBands: options.x_plot_bands
+	      	},
+	      	yAxis: {
+				gridLineColor: self.colors.gridLines,
+			 	gridLineWidth: self.lineWeight.grid,
+			 	lineColor:     self.colors.yAxisLine,
+			 	lineWidth:     self.lineWeight.axis,
+	         	title: {
+	            	text: options.y_axis || ''
+	         	},
+	         	labels: {
+					style: {
+						fontSize:   self.font.size,
+						fontFamily: self.font.family,
+						fontWeight: self.font.weight,
+						color:      self.font.color
+					},
+	            	formatter: function() {
+	               		return this.value;
+	            	}
+	         	}
+	      	},
+	      	tooltip: {
+	        	formatter: function() {
+					if (this.series.type == 'pie') {
+						return this.series.name + ':<br>' + this.point.name + ": " + Highcharts.numberFormat(this.y, 0)
+					} else {
+	            		return 'On: ' + this.x + "<br>" + this.series.name +': ' + Highcharts.numberFormat(this.y, 0)
+					}
+	         	}
+	      	},
+		  	legend: {
+				enabled: (series_data.size > 1)
+		  	},
+	      	plotOptions: {
+				series: {
+					enableMouseTracking: !will_print(), 
+					shadow: 			 false, 
+					animation: 			 !will_print()
+				},
+	        	area: {
+			    	fillColor: self.colors.areaFill,
+			    	color: 	   self.colors.lineColor,
+					lineWidth: 3,
+					marker: {
+	               		enabled: false,
+	               		symbol: 'circle',
+	               		radius: 2,
+	               		states: {
+	                  		hover: {
+	                     		enabled: true
+	                  		}
+	               		}
+	            	}
+	        	},
+				pie: {
+				    allowPointSelect: true,
+		            cursor: 'pointer',
+		            dataLabels: {
+		               enabled: true,
+		               formatter: function() {
+		                  if (this.y > 0) return this.point.name + ": " + Highcharts.numberFormat(this.percentage, 1) +'%';
+		               },
+		               color: self.font.color
+		            }
+		        }
+	      	},
+	      	series: series_data
+	   	});
+	};
+	
+	// Render a Pie chart
+	this.pie = function(container, categories, series_data, options) {
+		this.area(container, categories, series_data, options);
+	}
+	
+	// Render Funnel chart
+   	this.funnel = function(container, categories, series_data, options) {
+		return chart = new Highcharts.Chart({
+			chart: {
+				backgroundColor: 	self.colors.background,
+				borderWidth: 		0,
+				borderColor: 		self.colors.background,
+				renderTo: 			container,
+				defaultSeriesType: 	'funnel',
+				margin: 			[20, 100, 40, 180]
+			},
+			navigation: {
+		        buttonOptions: {
+		            backgroundColor: self.colors.background
+		        }
+		    },
+			title: {
+				text: options.title || ''
+			},
+			subtitle: {
+	        	text: options.subtitle || ''
+	      	},
+			plotArea: {
+				shadow: 			null,
+				borderWidth: 		null,
+				backgroundColor: 	null
+			},
+			tooltip: {
+				formatter: function() {
+					return '<b>'+ this.point.name +'</b>: '+ Highcharts.numberFormat(this.y, 0);
+				}
+			},
+			plotOptions: {
+				series: {
+					dataLabels: {
+						align: 		'left',
+						x: 			-300,
+						enabled: 	true,
+						color: 		self.font.color,
+						formatter: function() {
+							return '<b>'+ this.point.name +'</b> ('+ Highcharts.numberFormat(this.point.y, 0) +')';
+						}
+					}
+				}
+			},
+			legend: {
+				enabled: false
+			},
+		    series: series_data
+		});
+	};
+};

data/lib/ar_to_chart.rb

@@ -1,3 +1,19 @@
+require File.dirname(__FILE__) + '/ar_to_chart/charting/highcharts.rb'
+require File.dirname(__FILE__) + '/ar_to_chart/charting/sparklines.rb'
+require File.dirname(__FILE__) + '/ar_to_chart/charting/period.rb'
+require File.dirname(__FILE__) + '/ar_to_chart/charting/highcharts/base'
+require File.dirname(__FILE__) + '/ar_to_chart/charting/highcharts/area'
+require File.dirname(__FILE__) + '/ar_to_chart/charting/highcharts/pie'
+require File.dirname(__FILE__) + '/ar_to_chart/charting/highcharts/funnel'
+
+require File.dirname(__FILE__) + '/ar_to_chart/active_record_array.rb'
+Array.send :include, Charting::ActiveRecordArray
+
+require File.dirname(__FILE__) + '/ar_to_chart/charting/transforms.rb'
+ActiveRecord::Base.send :include, Charting::Transforms
+
+I18n.load_path << Dir[ File.join(File.dirname(__FILE__), 'locale', '*.{rb,yml}') ]
+
 module ArToChart
   # Your code goes here...
 end

data/lib/ar_to_chart/active_record_array.rb

@@ -0,0 +1,74 @@
+# Adds method to Array to allow output of flash-based charts from
+# active record result sets
+module Charting
+  module ActiveRecordArray
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+      end
+    end
+  
+    module InstanceMethods
+      # Render a chart based upon an ActiveRecord result set.
+      # Requires jQuery.
+      #
+      # ====Parameters
+      #
+      #   columns:        column name (or array of names) representing the
+      #                   Y-Axis
+      #   label_column:   The category (X-Axis) column
+      #
+      # ====Options
+      #
+      #   See the options in Charting::Highcharts::Renderer
+      def to_chart(columns, label_column, options = {})
+        chart_object(columns, label_column, options).to_html
+      end
+     
+      # Returns the chart container (the <div>) and the javascript
+      # separately so you can put the container where you want and
+      # the javascript at the end of the document
+      def to_container_and_script(column, label_column, options = {})
+        chart = chart_object(column, label_column, options)
+        return chart.container, chart.script
+      end
+      
+      # Render a sparkline based upon an ActiveRecord result set.
+      # Requires jQuery and jQuery sparklines plugin.
+      #
+      # ====Parameters
+      #
+      #   column:         column name representing the
+      #                   Y-Axis
+      #   label_column:   The category (X-Axis) column
+      #
+      # ====Options
+      #
+      #   See the options in Charting::Sparklines::Renderer      
+      def to_sparkline(column, options = {})
+        sparkline_object(column, options).to_html
+      end
+      
+    private
+      # Eventually we'll do charting engine selection here.  For now 
+      # only Highcharts or Sparklines
+      def chart_object(label_column, columns, options)
+        Charting::Highcharts::Renderer.new(self, columns, label_column, merged_options(options))
+      end
+      
+      def sparkline_object(column, options)
+        Charting::Sparklines::Renderer.new(self, column, merged_options(options))    
+      end
+      
+      def merged_options(options)
+        {}.merge(options)
+      end
+      
+    end
+  
+    module ClassMethods
+
+    end
+  end
+end

data/lib/ar_to_chart/charting/highcharts.rb

@@ -0,0 +1,113 @@
+module Charting
+  module Highcharts
+    class Renderer
+      DEFAULT_OPTIONS = {
+        :container_height      => '200px',
+        :type                  => :area,
+      }
+      DEFAULT_CHARTING_OBJECT = 'arToChart'
+    
+      attr_accessor :categories, :series, :options, :chart
+      cattr_accessor :charting_object
+      
+      # Generate Highchart based charts.  CSS is used
+      # for the colouring.  See the file ar_to_chart.css included
+      # in the files directory of the gem.
+      #
+      # ====Parameters
+      #
+      #   data_source:        The active record result set
+      #   category_column:    The column used for the x-axis
+      #   data_columns:       one column name or an array of column names to be charted or a hash
+      #                       with pairs of :column_names => :series_type
+      #   options:            options hash 
+      #
+      # ====Options
+      #
+      #   :type               Chart type to render. Defauly is :area.  Other options
+      #                       are :pie and :funnel.  Subclass Base to create other
+      #                       chart types available in Highcharts. The name of the subclass
+      #                       becomes the chart type.
+      #   :container          DOM id of the container to render to.  Default is to
+      #                       generate a name.
+      #   :container_height   Requested height of the container.  Defaults to 200px
+      #   :charting_object    The javascript object that is instantiated as the 
+      #                       browser renderer. Defaults to arToChar (supplied in 
+      #                       the files directory of the gem)
+      #
+      def initialize(data_source, category_column, data_columns, options = {})
+        @options = DEFAULT_OPTIONS.merge(options)
+        @options[:container] ||= generate_container_name
+        @options[:charting_object] ||= self.class.charting_object || DEFAULT_CHARTING_OBJECT
+        @data_columns = data_columns.respond_to?(:each) ? data_columns : [data_columns]
+        @chart = chart_class.new(data_source, category_column, @data_columns, @options)
+      end
+      
+      # Returns the <div> into which the chart will be rendered.
+      def container
+        <<-EOF
+          <div id='#{container_id}' #{styles}"></div>
+        EOF
+      end
+      
+      # Returns the javscript (without <script> tag) that is sent
+      # to the browser to render the chart.  Note that there is a 
+      # dependency on the ar_to_chart.js javascript library being
+      # loaded in the <head> of the document.
+      #
+      # See the ar_to_chart.js file included in the files directory
+      # of the gem.
+      def script
+        <<-EOF
+          $(document).ready(function() {
+            chart = new #{charting_object};
+            #{chart.to_js}
+          });     
+        EOF
+      end
+      
+      # Return the HTML of the container <div> and the 
+      # script to render the chart.
+      def to_html
+        <<-EOF
+          #{container}
+          <script type="text/javascript">
+            #{script}
+          </script>
+        EOF
+      end
+      
+      # Set configuration options.  Currently no options
+      # are available.
+      def self.configure
+        yield self
+      end
+      
+    private
+      def chart_class
+        @chart_class ||= "Charting::Highcharts::#{options[:type].to_s.titleize}".constantize
+      end
+
+      def container_id
+        @container_id ||= options[:container]
+      end
+      
+      def styles
+        container_height ? "style='height:#{container_height}'" : ''
+      end
+      
+      def container_height
+        options[:container_height]
+      end
+      
+      def charting_object
+        options[:charting_object]
+      end
+      
+      def generate_container_name
+        "chart_" + ActiveSupport::SecureRandom.hex(3)
+      end
+      
+    end
+  end
+end

data/lib/ar_to_chart/charting/highcharts/area.rb

@@ -0,0 +1,25 @@
+module Charting
+  module Highcharts
+    class Area < Charting::Highcharts::Base
+    
+      # Generate categories from ActiveRecord data
+      def categories
+        data_source.inject([]) do |categories, row|
+          categories << row.format_column(category_column).try(:strip_tags).try(:strip)
+        end
+      end
+    
+      # Generate data series array (for each data column)
+      def series
+        data_columns.inject([]) do |series, column|
+          series_data = data_source.inject([]) do |series_data, row|
+            series_data << row[column].to_i
+          end
+          series << {:name => series_name(column), :data => series_data}
+        end
+      end
+
+    end
+  end
+end
+      

data/lib/ar_to_chart/charting/highcharts/base.rb

@@ -0,0 +1,130 @@
+module Charting
+  module Highcharts
+    # Base class for chart renderers. Chart renderers should
+    # subclass rather than instantiate Base directly.
+    class Base
+      attr_reader :data_source, :category_column, :data_columns, :options
+      
+      WEEKEND         = [0,6]   # The days of the week that are the weekend (Sun, Sat)
+      AXIS_START_UNIT = 0.5     # Where highcharts starts its x-axis in axis units
+      MAX_X_LABELS    = 10      # Display no more than this number of category labels
+      DEFAULT_OPTIONS = {
+
+      }
+
+      # Initialize a new chart.
+      #
+      # ====Parameters
+      #
+      #   data_source:      Array of ActiveRecord objects for rendering as a chart
+      #   category_column:  The name of the column which is the category (X) axis
+      #   data_columns:     The name (or array of names) of the columns which are
+      #                     the data series.
+      #   options:          Options hash
+      #
+      # ====Options
+      #
+      #   title:            Chart title (default: none)
+      #   subtitle:         Subtitle (default: none)
+      #   x_axis_title:     X-Axis title (default: none)
+      #   y_axis_title:     Y-Axis title (defualt: none)
+      #   x_step:           X-Axis labels are printed every 'x' steps
+      #                     Requires Highcharts beta 2.1
+      #   x_plot_bands:     Plot bands in Ruby Hash format according to the
+      #                     Highcharts documented format
+      #   linearize:        Linearize the data to ensure continuous
+      #                     series on the X-Axis.
+      #   weekend_plot_bands:   Creates plot-bands for the weekends (Saturday/Sunday)
+      #   container:        DOM id for the container div.  Default is to generate one.
+              
+      def initialize(data_source, category_column, data_columns, options = {})
+        @options          = DEFAULT_OPTIONS.merge(options)
+        @category_column  = category_column
+        @data_columns     = data_columns
+        @data_source      = data_source
+        @data_source      = linearize if @options.delete(:linearize)       
+        @options[:x_step] ||= (@data_source.size.to_f / MAX_X_LABELS.to_f).round
+      end
+
+      def chart_options
+        {
+          :title        => options[:title],
+          :subtitle     => options[:subtitle],
+          :x_axis       => options[:x_axis_title], 
+          :y_axis       => options[:y_axis_title], 
+          :x_step       => options[:x_step],
+          :x_plot_bands => weekend_plot_bands
+        }
+      end
+
+      # Define in concrete subclass
+      def series
+        nil
+      end
+      
+      # Define in concrete subclass
+      def categories
+        nil
+      end
+      
+      # Returns a plotbands definition for the data source
+      # Only if the category column is a date or datetime
+      def weekend_plot_bands
+        return unless options[:weekend_plot_bands] && data_source.first[category_column].respond_to?(:to_date)
+        x_plot_bands = data_source.inject_with_index([]) do |plot_bands, row, index|
+          if WEEKEND.include?(row[category_column].to_date.wday)
+            plot_bands << {:from => (index + AXIS_START_UNIT - 1), :to => (index + AXIS_START_UNIT)}
+          end
+          plot_bands
+        end
+      end
+      
+      def series_name(column)
+        data_source.first.class.human_attribute_name(column)
+      end
+      
+      def chart_type
+        @chart_type ||= self.class.name.split('::').last.downcase
+      end
+
+      def container
+        options[:container]
+      end
+    
+      def to_js
+        <<-EOF
+          chart.#{chart_type}('#{container}', 
+            #{categories.to_json}, 
+            #{series.to_json},
+            #{chart_options.to_json}
+          );
+        EOF
+      end
+      
+      # When we retrieve datat from the data base it may have gaps where not
+      # results are available. For charting we want to have a linearized
+      # series of data so here we plug the gaps.
+      # 
+      # Punt that the categeory column tells us enough to know what the data
+      # should be.
+      def linearize
+        return data_source unless range = Charting::Period.range_from(options)
+        range = data_source.first[category_column]..range.last if range.first > data_source.first[category_column]
+        klass = data_source.first.class
+        index = 0
+        range.inject(Array.new) do |linear_data, data_point|
+          if data_source[index] && data_source[index][category_column] == data_point
+            linear_data << data_source[index]
+            index += 1
+          else
+            new_row = klass.new(category_column => data_point)
+            data_columns.each {|column| new_row[column] = 0 }
+            yield new_row if block_given?
+            linear_data << new_row
+          end
+          linear_data
+        end
+      end
+    end
+  end
+end

data/lib/ar_to_chart/charting/highcharts/funnel.rb

@@ -0,0 +1,10 @@
+module Charting
+  module Highcharts
+    # Produces a Funnel graph.  Subclasses Highcharts::Pie
+    # since the data format is pretty much the same, only needs
+    # different name.
+    class Funnel < Charting::Highcharts::Pie
+      
+    end
+  end
+end

data/lib/ar_to_chart/charting/highcharts/pie.rb

@@ -0,0 +1,22 @@
+module Charting
+  module Highcharts
+    class Pie < Charting::Highcharts::Base
+
+      # Generate data series array (for each data column)
+      def series
+        data_columns.inject([]) do |series, column|
+          series_data = data_source.inject([]) do |series_data, row|
+            series_data << [row.format_column(category_column).strip_tags.strip, row[column].to_i]
+          end
+          series << {:type => chart_type, :name => series_name(column), :data => series_data}
+        end
+      end
+
+      # No categories for pie charts
+      def categories
+        nil
+      end
+
+    end
+  end
+end

data/lib/ar_to_chart/charting/period.rb

@@ -0,0 +1,157 @@
+# Parse parameters (usually from a request via ActionController) into
+# chain of named scopes
+#
+# Format of query parameters:
+# => by=dim1,dim2,dim3    dimensions
+# => metric=metric1       a metric (only one at this time)
+# => from=
+# => to=
+
+module Charting
+  class Period
+    def from_params(params = {})
+      default_from  = (today - 30.days).beginning_of_day
+      default_to    = today.end_of_day
+      if params[:period]
+        from, to = from_param(params[:period], default_from..default_to)
+      else
+        to = date_from_param(params[:to], default_to)
+        from = date_from_param(params[:from], default_from)
+      end       
+      from..to
+    end
+
+    def date_from_param(date, default)
+      return default unless date
+      return date.to_date if date.is_a?(Date) || date.is_a?(Time)
+      Time.parse(date) rescue default
+    end
+
+    def from_param(period, default)
+      return default.first, default.last unless period
+      period_range = case period.to_sym
+        when :today          then today.beginning_of_day..today.end_of_day
+        when :yesterday      then yesterday.beginning_of_day..yesterday.end_of_day
+        when :this_week      then first_day_of_this_week.beginning_of_day..last_day_of_this_week.end_of_day
+        when :this_month     then first_day_of_this_month.beginning_of_day..last_day_of_this_month.end_of_day
+        when :this_year      then first_day_of_this_year.beginning_of_day..last_day_of_this_year.end_of_day
+        when :last_week      then first_day_of_last_week.beginning_of_day..last_day_of_last_week.end_of_day
+        when :last_month     then first_day_of_last_month.beginning_of_day..last_day_of_last_month.end_of_day
+        when :last_year      then first_day_of_last_year.beginning_of_day..last_day_of_last_year.end_of_day
+        when :last_30_days   then (today - 30.days).beginning_of_day..today.end_of_day
+        when :last_12_months then (today - 12.months).beginning_of_day..today.end_of_day
+        when :lifetime       then beginning_of_epoch.beginning_of_day..today.end_of_day;
+        else default
+      end
+      return period_range.first, period_range.last
+    end
+  
+    def range_from(params)
+      period = self.from_params(params)
+      case params[:time_group]
+      when 'date'
+        period.first.to_date..period.last.to_date
+      when 'day_of_week'
+        0..6
+      when 'day_of_month'
+        1..31
+      when 'hour'
+        0..24
+      when 'month'
+        1..12
+      when 'year'
+        period.first.to_date.year..period.last.to_date.year
+      end
+    end
+  
+    # Basic markers
+    def today
+      Time.zone.now.to_date
+    end
+
+    def yesterday
+      today - 1.day
+    end
+
+    def tomorrow
+      today + 1.day
+    end
+
+    def beginning_of_epoch
+      today - 20.years
+    end
+
+    # This week
+    def first_day_of_this_week
+      today - today.wday.days
+    end
+
+    def last_day_of_this_week
+      first_day_of_this_week + 7.days
+    end
+
+    # This month
+    def first_day_of_this_month
+      Date.new(today.year, today.month, 1)
+    end
+
+    def last_day_of_this_month
+      first_day_of_this_month + 1.month - 1.day
+    end
+
+    # Last week
+    def first_day_of_last_week
+      first_day_of_this_week - 7.days
+    end
+
+    def last_day_of_last_week
+      first_day_of_last_week + 7.days
+    end
+
+    # Last month
+    def first_day_of_last_month
+      last_month = Date.today - 1.month
+      Date.new(last_month.year, last_month.month, 1)
+    end
+
+    def last_day_of_last_month
+      first_day_of_last_month + 1.month - 1.day
+    end
+
+    # This year
+    def first_day_of_this_year
+      Date.new(today.year, 1, 1)
+    end
+
+    def last_day_of_this_year
+      Date.new(today.year, 12, 31)
+    end
+  
+    # Last year
+    def first_day_of_last_year
+      Date.new(today.year - 1, 1, 1)
+    end
+
+    def last_day_of_last_year
+      Date.new(first_day_of_last_year.year, 12, 31)
+    end
+  
+    # Clear the saved instance which we should do at the start
+    # of each Rails request
+    def self.clear
+      Thread.current[:period2] = nil
+    end
+  
+    # Called when we're configured as a before_filter which we need to
+    # ensure our thread data is ours and no left over from somebody else
+    def self.filter(controller)
+      clear
+    end
+
+    # Arrange for instance methods to be called as if class methods.  Make threadsafe.
+    def self.method_missing(method, *args)
+      Thread.current[:period2] = new unless Thread.current[:period2]
+      self.instance_methods.include?(method.to_s) ? Thread.current[:period2].send(method, *args) : super
+    end
+  end
+end

data/lib/ar_to_chart/charting/sparklines.rb

@@ -0,0 +1,65 @@
+module Charting
+  module Sparklines
+    class Renderer
+      DEFAULT_OPTIONS = {
+        :type                  => :line,
+      }
+
+      attr_accessor :series, :options, :chart
+      
+      # Generate jQuery sparkline based charts.
+      #
+      # Ensure jquery-sparkine library is loaded before use, for example:
+      #
+      #  <script src="/javascripts/jquery.sparkline.js" type="text/javascript"></script>
+      # 
+      # And that you invoke somethink like:
+      #
+      #   /* Initialize sparklines */
+      #   $(document).ready(function() {
+      #     $('.sparkline').sparkline();
+      #   });
+      #
+      # in your document script.
+      #
+      # Styling in CSS is required for the <span> container which
+      # has a class of 'sparkline'
+      #
+      # ====Parameters
+      #
+      #   data_source:      The active record result set
+      #   data_column:      one column name to be charted 
+      #   options:          options hash 
+      #
+      # ====Options
+      #
+      #   Currently no options for Sparklines.
+      def initialize(data_source, data_column, options = {})
+        @options = DEFAULT_OPTIONS.merge(options)
+        @options[:container] ||= generate_container_name
+        @data_column = data_column
+        @chart = chart_class.new(data_source, @data_column, @options)
+      end
+      
+      # Output the HTML representation of the chart
+      def to_html
+        @chart.to_html
+      end
+      
+      # Convenience method for configuring the chart.
+      def self.configure
+        yield self
+      end
+      
+    private
+      def chart_class
+        @chart_class ||= "Charting::Sparklines::#{options[:type].to_s.titleize}".constantize
+      end
+
+      def generate_container_name
+        "sparkline_" + ActiveSupport::SecureRandom.hex(3)
+      end
+
+    end
+  end
+end

data/lib/ar_to_chart/charting/sparklines/base.rb

@@ -0,0 +1,54 @@
+module Charting
+  module Sparklines
+    class Base
+      attr_reader :data_source, :data_column, :options
+      
+      DEFAULT_OPTIONS = {}
+
+      def initialize(data_source, data_column, options = {})
+        @data_source      = data_source
+        @data_column      = data_column
+        @options          = DEFAULT_OPTIONS.merge(options)
+      end
+    
+      # No options currently defined
+      def chart_options
+        {}
+      end
+    
+      # Define in concrete subclass
+      def series
+        []
+      end
+      
+      # The name of a data series
+      def series_name
+        data_source.first.class.human_attribute_name(data_column)
+      end
+      
+      # The chart type (derived from the class name)
+      def chart_type
+        @chart_type ||= self.class.name.split('::').last.downcase
+      end
+
+      # Render the chart HTML.  Requires jQuery and jQuery sparklines plugin
+      def to_html
+        <<-EOF
+          <span id="#{container_id}" class="#{chart_css_class}">
+            #{series.join(',')}
+          </span>
+        EOF
+      end
+      
+    private
+      def chart_css_class
+        "spark#{chart_type}"
+      end
+
+      def container_id
+        @container_id ||= options[:container]
+      end
+
+    end
+  end
+end

data/lib/ar_to_chart/charting/sparklines/line.rb

@@ -0,0 +1,12 @@
+module Charting
+  module Sparklines
+    class Line < Charting::Sparklines::Base
+      
+      def series
+        @chart_series ||= data_source.map{|row| row[data_column].to_i }
+      end
+
+    end
+  end
+end
+      

data/lib/ar_to_chart/charting/transforms.rb

@@ -0,0 +1,51 @@
+# Adds method to ActiveRecord to support some chart
+# transformations
+module Charting
+  module Transforms
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+        include InstanceMethods
+        const_set(:DEFAULT_PIVOT_COLUMNS, {
+          :attribute => :attribute, :value => :value
+        })
+      end
+    end
+  
+    module InstanceMethods
+      # Takes one row and returns an array of objects of the same class
+      # where columns are pivoted to become rows.  The new rows are of the 
+      # same class as the current instance.
+      #
+      # ====Arguments
+      #
+      #   The columns that become the row/column pairs in the result array.
+      #   An empty list means pivot all attributes.
+      #
+      # ====Options
+      #
+      #   Specify the optional column names for the result array.  The defaults
+      #   are: 
+      #   
+      #   :category => :category 
+      #   :value => value
+      def pivot(*args)
+        options = (args.last.is_a?(Hash) ? args.pop : {}).merge(self.class.const_get(:DEFAULT_PIVOT_COLUMNS))
+        args.flatten!
+        attributes = args.size > 0 ? args : self.attributes.map(&:first)
+        klass = self.class
+        return attributes.inject([]) do |rows, arg|
+          row = klass.new
+          row[options[:attribute]]  = arg.to_s
+          row[options[:value]]      = self[arg].to_i
+          rows << row
+          rows
+        end
+      end
+    end
+  
+    module ClassMethods
+
+    end
+  end
+end

data/lib/ar_to_chart/version.rb

@@ -1,3 +1,3 @@
 module ArToChart
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/locale/to_chart-en.yml

@@ -0,0 +1,3 @@
+en:    
+    charts:
+        not_set:                Not Set

data/lib/tasks/at_to_chart_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :ar_to_chart do
+#   # Task goes here
+# end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ar_to_chart
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: false
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Kip Cole
@@ -15,11 +15,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-14 00:00:00 +08:00
+date: 2010-11-02 00:00:00 +08:00
 default_executable: 
 dependencies: []
 
-description: "    Defines Array#to_chart that will accept ActiveRecord result sets\n    and render them as a chart.  Currently assumes OpenFlashChart as the\n    only supported charting engine.  Protovis based charting coming\n    soon.\n"
+description: "    Defines Array#to_chart that will accept ActiveRecord result sets\n    and render them as a chart.  Currently assumes Highcharts (highcharts.com)\n    as the charting engine.\n"
 email: 
 - kipcole9@gmail.com
 executables: []
@@ -30,11 +30,30 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
+- CHANGELOG
 - Gemfile
+- MIT-LICENSE
+- README.textile
 - Rakefile
 - ar_to_chart.gemspec
+- files/ar_to_chart.css
+- files/ar_to_chart.js
 - lib/ar_to_chart.rb
+- lib/ar_to_chart/.DS_Store
+- lib/ar_to_chart/active_record_array.rb
+- lib/ar_to_chart/charting/highcharts.rb
+- lib/ar_to_chart/charting/highcharts/area.rb
+- lib/ar_to_chart/charting/highcharts/base.rb
+- lib/ar_to_chart/charting/highcharts/funnel.rb
+- lib/ar_to_chart/charting/highcharts/pie.rb
+- lib/ar_to_chart/charting/period.rb
+- lib/ar_to_chart/charting/sparklines.rb
+- lib/ar_to_chart/charting/sparklines/base.rb
+- lib/ar_to_chart/charting/sparklines/line.rb
+- lib/ar_to_chart/charting/transforms.rb
 - lib/ar_to_chart/version.rb
+- lib/locale/to_chart-en.yml
+- lib/tasks/at_to_chart_tasks.rake
 has_rdoc: true
 homepage: http://rubygems.org/gems/ar_to_chart
 licenses: []