highcharts-js-rails 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+## v0.0.1 (2011-10-13) ##
+
+* First release

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in highcharts-rails.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,7 @@
+Copyright (C) 2011 Alex Robbin
+
+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.md

@@ -0,0 +1,85 @@
+Highcharts JS Rails
+===================
+
+Easily configure a Highcharts JS chart for use in a Rails application.
+
+Currently you are able to do the following:
+
+* Configure multiple axes and series on a single chart
+* Set a specific graph type for each individual series of data (available options include area, areaspline, bar, column, line, pie, scatter or spline) - default is line
+* Customize the tooltip for the graph
+* Configure the location and design of the legend
+* Set the tick interval for a specific axis
+
+Options
+-------
+
+To instantiate a new chart:
+
+`chart = Highcharts::Chart.new`
+
+The Highcharts::Chart class can receive a hash of the following options:
+
+* container: string (required)
+* title: string (required)
+* subtitle: string
+* xAxes: hash or array of hashes (required)
+* yAxes: hash or array of hashes (required)
+* legend: hash
+* series: hash or array of hashes (required)
+* tooltip: string
+
+Both the `xAxes` and `yAxes` options can be either a single hash (meaning there is only one axis) or an array of hashes (for multiple-axis charts). Each hash can include the following options:
+
+* title: string
+* categories: array
+* tickInterval: integer
+* min: integer
+* max: integer
+* labels: hash
+* opposite: boolean
+
+The `categories` option's array of values will be automatically formatted based on its class.
+The `tickInterval` option is only necessary if you want to override automatic tickInterval creation. If the option is not passed, the tickInterval will be calculated based on the amount of data passed to the attached `series`.
+The `labels` option can receive a set of options that includes `prepend` and `append`.
+
+The `legend` option for the Highcharts::Chart class can receive a hash of the following options:
+
+* layout: string (possible values can be horizontal or vertical - default is horizontal)
+* align: string
+* verticalAlign: string
+* x: integer
+* y: integer
+* borderWidth: integer
+
+The `series` option for the Highcharts::Chart class can receive a hash of the following options:
+
+* name: string
+* type: string (possible values can be area, areaspline, bar, column, line, pie, scatter or spline - default is line)
+* xAxis: integer (the index of the xAxis this series should be attached to)
+* yAxis: integer (the index of the yAxis this series should be attached to)
+* data: array
+
+The `data` option's array of values will be automatically formatted as a float, if necessary. 
+
+Example
+--------
+
+Ruby:
+
+```
+chart = Highcharts::Chart.new(
+  :container => 'graph',
+  :title => "Highcharts Example",
+  :xAxes => {:categories => ['October 12', 'October 13', 'October 14']},
+  :yAxes => [{:title => 'Impressions', :min => 0}],
+  :series => [{:name => 'Impressions', :yAxis => 0, :type => 'line', :data => [100000, 122000, 127000]}],
+  :legend => {:layout => 'vertical', :align => 'right', :verticalAlign => 'top', :x => -10, :y => 100, :borderWidth => 0},
+  :tooltip => "'<b>' + this.series.name + '</b><br/>' + this.x + ': ' + this.y"
+)
+<%= chart %>
+```
+
+HTML/ERB:
+
+`<div id="graph" style="width: 400px; height: 200px;"></div>`

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/highcharts-js-rails.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'highcharts/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'highcharts-js-rails'
+  s.version     = Highcharts::VERSION
+  s.authors     = ['Alex Robbin']
+  s.email       = ['agrobbin@gmail.com']
+  s.homepage    = 'http://github.com/agrobbin/highcharts-js-rails'
+  s.summary     = %q{Easily configure a Highcharts JS chart for use in a Rails application}
+  s.description = s.summary
+
+  s.rubyforge_project = 'highcharts-js-rails'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+  s.add_dependency 'actionpack', '~> 3.0'
+end

data/lib/highcharts.rb

@@ -0,0 +1,8 @@
+require 'highcharts/axis'
+require 'highcharts/base'
+require 'highcharts/chart'
+require 'highcharts/legend'
+require 'highcharts/plot_options'
+require 'highcharts/rails'
+require 'highcharts/series'
+require 'highcharts/version'

data/lib/highcharts/axis.rb

@@ -0,0 +1,48 @@
+module Highcharts
+  class Axis < Base
+    
+    attr_accessor :title, :categories, :tickInterval, :min, :max, :labels, :opposite
+    
+    def to_s
+      "{" +
+        [render_title, render_categories, render_tickInterval, render_options(:objects => 'min max opposite'), render_labels].flatten.compact.join(',') +
+      "}"
+    end
+    
+    def render_title
+      title.present? ? "title: {text: '#{title}'}" : nil
+    end
+    
+    def render_categories
+      return nil unless categories.present?
+      "categories: [#{categories.collect {|c| "'#{format_category(c)}'"}.join(', ')}]" # need to encapsulate each category in quotes and format it before joining them with a comma
+    end
+    
+    def render_tickInterval
+      return tickInterval if tickInterval.present?
+      return nil unless categories.present?
+      "tickInterval: #{(Math.sqrt(categories.length) < 5 ? 1 : Math.sqrt(categories.length)).floor}"
+    end
+    
+    def format_category(category)
+      case category
+      when Date
+        category.strftime("%b. %d")
+      when Time
+        category.strftime("%H:%M")
+      when DateTime
+        category.strftime("%b. %d, %H:%M")
+      else
+        category.to_s
+      end
+    end
+    
+    def render_labels
+      return nil unless labels.present?
+      "labels: {" +
+        "formatter: function(){ return '#{labels[:prepend]}' + this.value + '#{labels[:append]}'; }" +
+      "}"
+    end
+    
+  end
+end

data/lib/highcharts/base.rb

@@ -0,0 +1,19 @@
+module Highcharts
+  class Base < ActionView::Base
+    
+    def initialize(*args)
+      args.extract_options!.each {|arg, value| self.send("#{arg}=", value)}
+    end
+    
+    def render_options(args)
+      attrs = []
+      args.each do |t, a|
+        a.split.each do |option|
+          attrs << "#{option}: #{t == :objects ? send(option) : "'#{send(option)}'"}" if send(option).present?
+        end
+      end
+      attrs
+    end
+    
+  end
+end

data/lib/highcharts/chart.rb

@@ -0,0 +1,80 @@
+module Highcharts
+  class Chart < Base
+    include ActionView::Helpers
+  
+    attr_accessor :container, :title, :subtitle, :plot_options, :xAxes, :yAxes, :legend, :series, :tooltip
+    
+    def to_s
+      check_required_fields
+      
+      javascript_tag do
+        safe_concat("$(function(){" +
+          "new Highcharts.Chart({" +
+            render_all +
+          "})" +
+        "});")
+      end
+    end
+    
+    def render_all
+      content = [render_container, render_titles, render_plot_options, render_axes, render_series, render_legend, render_tooltip].flatten.compact.join(",")
+      if Rails.env.production?
+        content
+      else
+        content.gsub(/(,|{|\[)/, "\\1\n").gsub(/(}|])/, "\n\\1")
+      end
+    end
+    
+    def check_required_fields
+      %w(container title series).each do |required_argument|
+        raise ArgumentError, ":#{required_argument} must be passed" if send(required_argument).blank? || (send(required_argument).is_a?(Array) && send(required_argument).length == 0)
+      end
+    end
+    
+    def render_container
+      "chart: {renderTo: '#{container}'}"
+    end
+    
+    def render_titles
+      %w(title subtitle).collect do |t|
+        "#{t}: {text: '#{send(t)}'}" if send(t).present?
+      end
+    end
+    
+    def render_plot_options
+      return nil unless plot_options.present?
+      "plotOptions: {" +
+        Array.wrap(plot_options).collect {|po| PlotOptions.new(po)}.join(',') +
+      "}"
+    end
+    
+    def render_axes
+      result = %w(x y).collect do |axis|
+        return nil unless send("#{axis}Axes").present?
+        "#{axis}Axis: [" +
+          Array.wrap(send("#{axis}Axes")).collect {|a| Axis.new(a)}.join(',') +
+        "]"
+      end
+      result.compact.join(",")
+    end
+    
+    def render_legend
+      return nil unless legend.present?
+      Legend.new(legend)
+    end
+    
+    def render_series
+      "series: [" +
+        Array.wrap(series).collect {|s| Series.new(s)}.join(',') +
+      "]"
+    end
+    
+    def render_tooltip
+      return nil unless tooltip.present?
+      "tooltip: {" +
+        "formatter: function(){ return #{tooltip}; }" +
+      "}"
+    end
+    
+  end
+end

data/lib/highcharts/legend.rb

@@ -0,0 +1,15 @@
+module Highcharts
+  class Legend < Base
+    
+    attr_accessor :layout, :align, :verticalAlign, :x, :y, :borderWidth
+    
+    def to_s
+      rendered_options = render_options(:strings => 'layout align verticalAlign', :objects => 'x y borderWidth')
+      return nil if rendered_options.length == 0
+      "legend: {" +
+        rendered_options.join(',') +
+      "}"
+    end
+    
+  end
+end

data/lib/highcharts/plot_options.rb

@@ -0,0 +1,23 @@
+module Highcharts
+  class PlotOptions < Base
+    
+    attr_accessor :type, :data_labels, :legend
+    
+    def to_s
+      "#{type}: {" +
+        [render_data_labels, render_legend].flatten.compact.join(',') +
+      "}"
+    end
+    
+    def render_data_labels
+      "dataLabels: {" +
+        "enabled: #{data_labels == false ? 'false' : 'true'}" +
+      "}"
+    end
+    
+    def render_legend
+      "showInLegend: #{legend ? 'true' : 'false'}"
+    end
+    
+  end
+end

data/lib/highcharts/rails.rb

@@ -0,0 +1,6 @@
+module Highcharts
+  module Rails
+    class Engine < ::Rails::Engine
+    end
+  end
+end

data/lib/highcharts/series.rb

@@ -0,0 +1,19 @@
+module Highcharts
+  class Series < Base
+    
+    attr_accessor :name, :type, :xAxis, :yAxis, :data
+    
+    def to_s
+      rendered_options = render_options(:strings => 'name type', :objects => 'xAxis yAxis')
+      return nil if rendered_options.length == 0
+      "{" +
+        [rendered_options, render_data].flatten.compact.join(',') +
+      "}"
+    end
+    
+    def render_data
+      "data: #{data.first.is_a?(Array) ? data : data.collect(&:to_f)}"
+    end
+    
+  end
+end

data/lib/highcharts/version.rb

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

data/vendor/assets/javascripts/adapters/mootools.js

@@ -0,0 +1,298 @@
+/**
+ * @license Highcharts JS v2.2.0 (2012-02-16)
+ * MooTools adapter
+ *
+ * (c) 2010-2011 Torstein Hønsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+// JSLint options:
+/*global Fx, $, $extend, $each, $merge, Events, Event, DOMEvent */
+
+(function () {
+
+var win = window,
+	doc = document,
+	mooVersion = win.MooTools.version.substring(0, 3), // Get the first three characters of the version number
+	legacy = mooVersion === '1.2' || mooVersion === '1.1', // 1.1 && 1.2 considered legacy, 1.3 is not.
+	legacyEvent = legacy || mooVersion === '1.3', // In versions 1.1 - 1.3 the event class is named Event, in newer versions it is named DOMEvent.
+	$extend = win.$extend || function () {
+		return Object.append.apply(Object, arguments);
+	};
+
+win.HighchartsAdapter = {
+	/**
+	 * Initialize the adapter. This is run once as Highcharts is first run.
+	 * @param {Object} pathAnim The helper object to do animations across adapters.
+	 */
+	init: function (pathAnim) {
+		var fxProto = Fx.prototype,
+			fxStart = fxProto.start,
+			morphProto = Fx.Morph.prototype,
+			morphCompute = morphProto.compute;
+
+		// override Fx.start to allow animation of SVG element wrappers
+		/*jslint unparam: true*//* allow unused parameters in fx functions */
+		fxProto.start = function (from, to) {
+			var fx = this,
+				elem = fx.element;
+
+			// special for animating paths
+			if (from.d) {
+				//this.fromD = this.element.d.split(' ');
+				fx.paths = pathAnim.init(
+					elem,
+					elem.d,
+					fx.toD
+				);
+			}
+			fxStart.apply(fx, arguments);
+
+			return this; // chainable
+		};
+
+		// override Fx.step to allow animation of SVG element wrappers
+		morphProto.compute = function (from, to, delta) {
+			var fx = this,
+				paths = fx.paths;
+
+			if (paths) {
+				fx.element.attr(
+					'd',
+					pathAnim.step(paths[0], paths[1], delta, fx.toD)
+				);
+			} else {
+				return morphCompute.apply(fx, arguments);
+			}
+		};
+		/*jslint unparam: false*/
+	},
+
+	/**
+	 * Downloads a script and executes a callback when done.
+	 * @param {String} scriptLocation
+	 * @param {Function} callback
+	 */
+	getScript: function (scriptLocation, callback) {
+		// We cannot assume that Assets class from mootools-more is available so instead insert a script tag to download script.
+		var head = doc.getElementsByTagName('head')[0];
+		var script = doc.createElement('script');
+
+		script.type = 'text/javascript';
+		script.src = scriptLocation;
+		script.onload = callback;
+
+		head.appendChild(script);
+	},
+
+	/**
+	 * Animate a HTML element or SVG element wrapper
+	 * @param {Object} el
+	 * @param {Object} params
+	 * @param {Object} options jQuery-like animation options: duration, easing, callback
+	 */
+	animate: function (el, params, options) {
+		var isSVGElement = el.attr,
+			effect,
+			complete = options && options.complete;
+
+		if (isSVGElement && !el.setStyle) {
+			// add setStyle and getStyle methods for internal use in Moo
+			el.getStyle = el.attr;
+			el.setStyle = function () { // property value is given as array in Moo - break it down
+				var args = arguments;
+				el.attr.call(el, args[0], args[1][0]);
+			};
+			// dirty hack to trick Moo into handling el as an element wrapper
+			el.$family = function () { return true; };
+		}
+
+		// stop running animations
+		win.HighchartsAdapter.stop(el);
+
+		// define and run the effect
+		effect = new Fx.Morph(
+			isSVGElement ? el : $(el),
+			$extend({
+				transition: Fx.Transitions.Quad.easeInOut
+			}, options)
+		);
+
+		// Make sure that the element reference is set when animating svg elements
+		if (isSVGElement) {
+			effect.element = el;
+		}
+
+		// special treatment for paths
+		if (params.d) {
+			effect.toD = params.d;
+		}
+
+		// jQuery-like events
+		if (complete) {
+			effect.addEvent('complete', complete);
+		}
+
+		// run
+		effect.start(params);
+
+		// record for use in stop method
+		el.fx = effect;
+	},
+
+	/**
+	 * MooTool's each function
+	 *
+	 */
+	each: function (arr, fn) {
+		return legacy ?
+			$each(arr, fn) :
+			Array.each(arr, fn);
+	},
+
+	/**
+	 * Map an array
+	 * @param {Array} arr
+	 * @param {Function} fn
+	 */
+	map: function (arr, fn) {
+		return arr.map(fn);
+	},
+
+	/**
+	 * Grep or filter an array
+	 * @param {Array} arr
+	 * @param {Function} fn
+	 */
+	grep: function (arr, fn) {
+		return arr.filter(fn);
+	},
+
+	/**
+	 * Deep merge two objects and return a third
+	 */
+	merge: function () {
+		var args = arguments,
+			args13 = [{}], // MooTools 1.3+
+			i = args.length,
+			ret;
+
+		if (legacy) {
+			ret = $merge.apply(null, args);
+		} else {
+			while (i--) {
+				// Boolean argumens should not be merged.
+				// JQuery explicitly skips this, so we do it here as well.
+				if (typeof args[i] !== 'boolean') {
+					args13[i + 1] = args[i];
+				}
+			}
+			ret = Object.merge.apply(Object, args13);
+		}
+
+		return ret;
+	},
+
+	/**
+	 * Get the offset of an element relative to the top left corner of the web page
+	 */
+	offset: function (el) {
+		var offsets = $(el).getOffsets();
+		return {
+			left: offsets.x,
+			top: offsets.y
+		};
+	},
+
+	/**
+	 * Extends an object with Events, if its not done
+	 */
+	extendWithEvents: function (el) {
+		// if the addEvent method is not defined, el is a custom Highcharts object
+		// like series or point
+		if (!el.addEvent) {
+			if (el.nodeName) {
+				el = $(el); // a dynamically generated node
+			} else {
+				$extend(el, new Events()); // a custom object
+			}
+		}
+	},
+
+	/**
+	 * Add an event listener
+	 * @param {Object} el HTML element or custom object
+	 * @param {String} type Event type
+	 * @param {Function} fn Event handler
+	 */
+	addEvent: function (el, type, fn) {
+		if (typeof type === 'string') { // chart broke due to el being string, type function
+
+			if (type === 'unload') { // Moo self destructs before custom unload events
+				type = 'beforeunload';
+			}
+
+			win.HighchartsAdapter.extendWithEvents(el);
+
+			el.addEvent(type, fn);
+		}
+	},
+
+	removeEvent: function (el, type, fn) {
+		if (typeof el === 'string') {
+			// el.removeEvents below apperantly calls this method again. Do not quite understand why, so for now just bail out.
+			return;
+		}
+		win.HighchartsAdapter.extendWithEvents(el);
+		if (type) {
+			if (type === 'unload') { // Moo self destructs before custom unload events
+				type = 'beforeunload';
+			}
+
+			if (fn) {
+				el.removeEvent(type, fn);
+			} else {
+				el.removeEvents(type);
+			}
+		} else {
+			el.removeEvents();
+		}
+	},
+
+	fireEvent: function (el, event, eventArguments, defaultFunction) {
+		var eventArgs = {
+			type: event,
+			target: el
+		};
+		// create an event object that keeps all functions
+		event = legacyEvent ? new Event(eventArgs) : new DOMEvent(eventArgs);
+		event = $extend(event, eventArguments);
+		// override the preventDefault function to be able to use
+		// this for custom events
+		event.preventDefault = function () {
+			defaultFunction = null;
+		};
+		// if fireEvent is not available on the object, there hasn't been added
+		// any events to it above
+		if (el.fireEvent) {
+			el.fireEvent(event.type, event);
+		}
+
+		// fire the default if it is passed and it is not prevented above
+		if (defaultFunction) {
+			defaultFunction(event);
+		}
+	},
+
+	/**
+	 * Stop running animations on the object
+	 */
+	stop: function (el) {
+		if (el.fx) {
+			el.fx.cancel();
+		}
+	}
+};
+
+}());