flot-rails-plus 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6beb3f80216b026feef3facd5fb2d284cf54f385
+  data.tar.gz: e13dc2a7b1564f80b4ae7a8e658a3545b6cfa8d9
+SHA512:
+  metadata.gz: 4f8468735b6a609b2d7640015225710d78d9bd3d3a2e460793bc4712c283076ea1d61456cb31f28aa0856c19c98691e98a6eefd48d1bfd78bbba8e75da0419a3
+  data.tar.gz: 03aff01d461428bbf830a9a4d81c69382c11a9f6d579aa7a013be9196afc3f9a1718f683ff66fbd1e95133e5309dc5b4d026a5bd2f0cb99dfb6aee82fb785ac3

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 
+
+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/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'FlotRailsPlus'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascript/flot_helpers.js

@@ -0,0 +1,45 @@
+// Stuff added to customise flot for our use
+
+var updateLegendTimeout = null;
+
+function updateLegend(this_plot, plot_legends, pos) {
+  updateLegendTimeout = null;
+  
+  var axes = this_plot.getAxes();
+  if (pos.x < axes.xaxis.min || pos.x > axes.xaxis.max ||
+    pos.y < axes.yaxis.min || pos.y > axes.yaxis.max)
+  return;
+  
+  var i, j, dataset = this_plot.getData();
+  for (i = 0; i < dataset.length; ++i) {
+    var series = dataset[i];
+    
+    // find the first point after pos, x-wise
+    for (j = 0; j < series.data.length; ++j)
+      if (series.data[j][0] > pos.x)
+      break;
+    
+    // use the previous value if not exact
+    var y, y_text, p1 = series.data[j - 1], p2 = series.data[j];
+    if (p1 == null)
+      y = p2[1];
+    else
+      y = p1[1];
+
+    if (y == null)
+      y_text = "____";
+    else
+      y_text = y.toFixed(1);
+    plot_legends.eq(i).text(series.label.replace(/=.*/, "= " + y_text));
+  }
+}
+
+function fix_legends( div ) {
+  var legends = $("#" + div + " .legendLabel");
+  legends.each(function () {
+      // fix the widths so they don't jump around
+      $(this).css('width', $(this).width());
+  });
+  return legends;
+}
+

data/app/assets/javascript/flot_page_refresh.coffee

@@ -0,0 +1,126 @@
+
+refresh_timeout_timer = null
+
+# default options in case user has not provided them
+options = {
+    series: { 
+        lines: { show: true, lineWidth: 2 }, # for some reason shadowSize here does not work, had to put in line options
+        points: {
+            radius: 1,
+            show: false
+        }
+    }
+    xaxis: {}
+    yaxis: {min: -10, max: 30},
+    legend: {"backgroundOpacity":0.0,"position":"sw"},
+    grid: {"autoHighlight":false,"hoverable":true},
+    crosshair: {"mode":"x"}    
+};
+
+$(document).ready () ->
+  if gon? &&  gon.chart_sets
+    # merge our default options into the chart options
+    mergeOptions()
+    # draw the charts the first time if sample data has been provided
+    doRefreshChart(gon.chart_sets)
+    # run ajax update loop if requested
+    refreshChart()
+  
+mergeOptions =->
+  # merges default options into gon.charts, with priority for those in gon.charts
+  for chart_set in gon.chart_sets
+    for chart in chart_set['charts']
+      # make a deep clone of the options
+      cloned_options = jQuery.extend( true, {}, options )
+      #alert cloned_options['xaxis']
+      # merge in gon.charts options in
+      jQuery.extend( true, cloned_options, chart['options'] )
+      # and set the chart options to that
+      chart['options'] = cloned_options
+
+refreshChart = ->
+  if gon.url?
+    # a json url has been supplied get plot data via ajax
+    url = gon.url
+    $.ajax url,
+      type : 'GET',
+      dataType : 'json',
+      success : (data) ->
+        chart_sets = data["chart_sets"]
+        # merge in chart configuration from gon
+        for chart_set, index in chart_sets
+          chart_set["charts"] = gon.chart_sets[index]["charts"]
+        doRefreshChart(chart_sets)
+      error : (XMLHttpRequest, textStatus, errorThrown) ->
+        #alert( "Ajax error" )
+      complete : () ->
+        # if auto refresh was requested then set the timer 
+        if gon.refresh  &&  gon.refresh > 0
+          # clear the timer before restarting 
+          clearTimeout( refresh_timeout_timer )
+          refresh_timeout_timer = setTimeout(refreshChart, gon.refresh * 1000)
+      
+doRefreshChart = (chart_sets) ->
+  for chart_set in chart_sets
+    # nothing to do if no samples provided
+    if chart_set['samples']
+      # setup array containing div and channel name for each line and array for data
+      linerefs = []
+      xaxismethod = chart_set['xaxis']['method']
+      xaxismode = chart_set['xaxis']['mode']
+      for chart, index in chart_set['charts']
+        div = chart['div']
+        # merge timerange from json data into the chart options
+        for k,v of chart_set['xaxis']
+          chart['options']['xaxis'][k] = v 
+        for line in chart['lines']
+          lineref = {div: div, chart_index: index, tag: "#{line['tag']}=_____", \
+            value_method: line['value_method'], color: line['color'], options: line['options'], datapoints: []}
+          linerefs.push lineref
+      # extract datapoints for each line
+      for sample in chart_set['samples']
+        x = sample[xaxismethod]
+        if xaxismode == 'time'
+          x = new Date(x).getTime()
+        for ref in linerefs
+          #alert "x #{x} v #{sample[ref['value_method']]}"
+          ref['datapoints'].push( [x, sample[ref['value_method']]] )
+  
+      # setup datasets for each div
+      datasets = {}
+      for lineref in linerefs
+        thisset = {label: lineref['tag'], color: lineref['color'], shadowSize: 0, data: lineref['datapoints']}
+        # deep merge in the line options
+        jQuery.extend true, thisset, lineref['options']
+        (datasets[lineref['chart_index']] = datasets[lineref['chart_index']] || []).push( thisset )
+      plots = []
+      legends = []
+      divs = []
+      for chart_index,dataset of datasets
+        chart = chart_set['charts'][chart_index]
+        div = chart["div"]
+        # plot the chart
+        plot = jQuery.plot($("##{div}"), dataset, chart["options"])
+        #if this is the first draw of this div then setup the update function
+        div_id = document.getElementById(div)
+        if !div_id.plot
+          # first time through so plot the chart 
+          # and save the plot object and legends in a custom property of the div
+          div_id.plot = jQuery.plot($("##{div}"), dataset, chart["options"])
+          div_id.legends = fix_legends( div )
+          # and bind to the hover event
+          $("##{div}").bind "plothover", (event, pos, item) =>
+            hoverHandler event, pos, item
+        else
+          # not first time so just update the data
+          div_id.plot.setData dataset
+          div_id.plot.draw()
+          # and refresh the legends object
+          div_id.legends = fix_legends( div )
+
+hoverHandler = (event, pos, item) ->
+  if (!updateLegendTimeout)
+    updateLegendTimeout = setTimeout (=> timeoutFn(event, pos, item) ), 50
+    
+timeoutFn = (event, pos, item) ->
+  updateLegend(event.target.plot, event.target.legends, pos)

data/app/assets/javascript/flot_rails_plus.js

@@ -0,0 +1,5 @@
+//= require jquery.flot.js
+//= require jquery.flot.crosshair
+//= require jquery.flot.time
+//= require flot_page_refresh
+//= require flot_helpers

data/app/models/chart.rb

@@ -0,0 +1,24 @@
+# class to encapsulate the definition of a chart in browser
+class Chart
+  attr_reader :lines, :div, :options
+  
+  # constructor taking a div id and an array of Lines
+  # options should contain :xaxis with :method
+  # :xaxis may also contain :min and :max
+  def initialize( div, lines, options = {} )
+    @div = div
+    @lines = lines
+    @options = options
+  end
+      
+  # returns the values that are to be passed to the client browser, as a hash, inluding the lines
+  def as_hash
+    {:div => @div, :lines => @lines.map { |l| l.as_hash }, :options => @options }
+  end
+
+  # class method, given an array of Charts, returns an array of unique value methods for the lines
+  def self.value_methods( charts )
+    charts.map { |c| ChartLine.value_methods( c.lines ) }.flatten.uniq
+  end
+  
+end

data/app/models/chart_line.rb

@@ -0,0 +1,24 @@
+# Class to handle line definition on a Chart
+class ChartLine
+  attr_reader :tag, :color, :value_method, :options
+  
+  # constructor taking tag string, line colour and a getter method of Sample to get the value
+  def initialize( tag, color, value_method, options={} )
+    @tag = tag
+    @color = color
+    @value_method = value_method
+    @options = options
+  end
+  
+  # returns the values that are to be passed to the client browser, as a hash
+  def as_hash
+    {:tag => @tag, :color => @color, :value_method => @value_method, :options => @options}
+  end
+  
+    # class method given an array of lines returns an array of value_methods (not necessarily unique)
+  def self.value_methods( lines )
+    lines.map { |l| l.value_method }
+  end
+  
+end
+

data/app/models/chart_set.rb

@@ -0,0 +1,56 @@
+class ChartSet
+  # class which is a set of charts to be shown on a page where the chars draw their data from 
+  # the same dataset and are shown with the same recordset
+  attr_reader :charts, :xaxis, :samples, :options
+
+  # constructor taking an array of Charts, an array of samples (which may be nil) 
+  # and a hash specifying the xaxis options
+  # xaxis should specify at least :method
+  # the samples may be nil if ajax will be used to fetch the data
+  def initialize( charts, samples, xaxis )
+    @charts = charts
+    @samples = samples
+    @xaxis = xaxis
+    begin
+      method = @xaxis[:method]
+    rescue
+      raise "Flot-rails-plus error: xaxis is not a hash"
+    end
+    if method == nil
+      raise "Flot-rails-plus error: xaxis[:method] is nil"
+    end
+  end
+  
+  # returns the values that are to be passed to the client browser, as a hash
+  # if with_charts is passed false then only samples and xaxis are included
+  def as_hash( options = {:with_charts => true} )
+    samples_mapped = nil
+    if @samples
+      samples_mapped = @samples.map do |r|
+        Hash[(Chart.value_methods(@charts) << @xaxis[:method]).map { |v| [v, r.send(v)] }]
+      end
+    end
+    # fill in xaxis range if not supplied
+    xaxis = @xaxis
+    xaxis_method = xaxis[:method]
+    if @samples && @samples.length > 0
+      if xaxis[:mode] == "time"    # may be nil if none provided
+        # if min and max have been provided by chart they must be scaled accordingly
+        xaxis[:min] ||= @samples.first.send(xaxis_method)
+        xaxis[:min] = xaxis[:min].to_i*1000
+        xaxis[:max] ||= @samples.last.send(xaxis_method)
+        xaxis[:max] = xaxis[:max].to_i*1000
+      else
+        xaxis[:min] ||= @samples.first.send(xaxis_method)
+        xaxis[:max] ||= @samples.last.send(xaxis_method)
+      end
+    end
+    hash = {:samples => samples_mapped, :xaxis => xaxis }
+    if options[:with_charts] != false
+      # add the chart definitions if required
+      hash[:charts] = @charts.map {|c| c.as_hash }
+    end
+    hash
+  end
+  
+end

data/lib/flot/rails/plus.rb

@@ -0,0 +1,14 @@
+require "flot/rails/plus/version"
+
+module Flot
+  module Rails
+    module Plus
+      class Engine < ::Rails::Engine
+      end
+    end
+  end
+end
+
+require 'flot/rails/plus/flot_view_helpers'
+require 'gon'   # ensure the gon and flot-rails gems are loaded
+require 'flot-rails'

data/lib/flot/rails/plus/flot_view_helpers.rb

@@ -0,0 +1,34 @@
+module FlotViewHelpers
+  # called by application to setup the view for display or the json for callback data
+  # for html leave options blank, for json pass the json object from the view builder 
+  # as :json => json
+  # to enable that also pass :url as the full url to use for json callback in the initial
+  # call from the view, in which case samples may be nil as they will be picked up via 
+  # json call after initial view has been rendered.
+  def setup_flot_view( chart_sets, options = {} )
+    if options[:json]
+      build_json chart_sets, options
+    else
+      build_gon chart_sets, options
+    end
+  end
+  
+  def build_gon( chart_sets, options = {} )
+    gon.url = options[:url]
+    gon.refresh = options[:refresh]
+    gon.chart_sets = chart_sets.map { |c| c.as_hash }
+    
+    # generate gon data that will appear in the view
+    include_gon
+  end    
+  
+  def build_json( chart_sets, options )
+    json = options[:json]
+    json.chart_sets chart_sets.map{ |c| c.as_hash(:with_charts => false) } 
+  end
+    
+end
+
+ActionView::Base.send :include, FlotViewHelpers
+  # allow access to gon methods from view helpers
+ActionController::Base.send :helper_method, :gon

data/lib/flot/rails/plus/test_helper.rb

@@ -0,0 +1,61 @@
+class ActiveSupport::TestCase  
+  
+  # call after requesting a page to extract gon.chart_sets as an array of ChartSets
+  # where each ChartSet is a hash
+  def fetch_flot_chart_sets
+    chart_sets = nil
+    assert_select "script", /gon\.chart_sets=/ do |element|
+      # get the tag as a string
+      string = element.to_s
+      # select the gon.chart_sets string as $1
+      string =~ /gon\.chart_sets=(.*\}\]);/
+      # parse it as json
+      chart_sets = JSON.parse $1
+      # this should be an array of chart set hashes
+    end
+    chart_sets
+  end
+  
+  # returns all charts from all sets
+  def fetch_flot_charts
+    chart_sets = fetch_flot_chart_sets
+    charts = []
+    chart_sets.each {|s| charts += s["charts"]}
+    charts
+  end
+  
+  # call after requesting a page to extract the chart for a given div
+  # nil if not found
+  def fetch_flot_chart_by_div( div )
+    charts = fetch_flot_charts  # fetch all charts from all sets
+    charts_for_div = charts.select { |c| c["div"] == div }
+    charts_for_div.empty?  ?  nil  :  charts_for_div[0]
+  end
+    
+  # call after requesting a readings page to extract gon.url
+  def fetch_flot_callback_url
+    url = nil
+    assert_select "script", /gon\.url=/ do |element|
+      # get the tag as a string
+      string = element.to_s
+      # select the gon.url string as $1
+      string =~ /gon\.url=\"(.*?)\"/
+      url = $1
+    end
+    url
+  end
+    
+  # call after requesting a readings page to extract gon.refresh
+  def fetch_flot_refresh
+    refresh = nil
+    assert_select "script", /gon\.refresh=/ do |element|
+      # get the tag as a string
+      string = element.to_s
+      # select the gon.refresh string as $1
+      string =~ /gon\.refresh=(.*?);/
+      refresh = $1
+    end
+    refresh
+  end
+  
+end