daru-view 0.1.0

data/lib/daru/view/adapters/googlecharts/data_table_iruby.rb

@@ -0,0 +1,86 @@
+require 'securerandom'
+require 'google_visualr'
+
+module GoogleVisualr
+  class DataTable
+    # options will enable us to give some styling for table.
+    # E.g. pagination, row numbers, etc
+    attr_accessor :options
+
+    # included to use `js_parameters` method
+    include GoogleVisualr::ParamHelpers
+
+    # overiding the current initialze method (of the google_visualr).
+    # This might be not a good idea. But right now I need these lines in it :
+    # ` unless options[:cols].nil?` , `unless options[:rows].nil?` and
+    # `@options = options`
+    # Few lines is changed, to fix rubocop error.
+    def initialize(options={})
+      @cols = []
+      @rows = []
+      @options = options
+      return if options.empty?
+
+      new_columns(options[:cols]) unless options[:cols].nil?
+
+      return if options[:rows].nil?
+      rows = options[:rows]
+      rows.each do |row|
+        add_row(row[:c])
+      end
+    end
+
+    # Generates JavaScript and renders the Google Chart DataTable in the
+    # final HTML output.
+    #
+    # Parameters:
+    #  *div_id            [Required] The ID of the DIV element that the Google Chart DataTable should be rendered in.
+    def to_js_full_script(element_id=SecureRandom.uuid)
+      js =  ''
+      js << '\n<script type=\'text/javascript\'>'
+      js << load_js(element_id)
+      js << draw_js(element_id)
+      js << '\n</script>'
+      js
+    end
+
+    def chart_function_name(element_id)
+      "draw_#{element_id.tr('-', '_')}"
+    end
+
+    def google_table_version
+      '1.0'.freeze
+    end
+
+    def package_name
+      'table'
+    end
+
+    # Generates JavaScript for loading the appropriate Google Visualization package, with callback to render chart.
+    #
+    # Parameters:
+    #  *div_id            [Required] The ID of the DIV element that the Google Chart should be rendered in.
+    def load_js(element_id)
+      js = ''
+      js << "\n  google.load('visualization', #{google_table_version}, "
+      js << "\n {packages: ['#{package_name}'], callback:"
+      js << "\n #{chart_function_name(element_id)}});"
+      js
+    end
+
+    # Generates JavaScript function for rendering the chart.
+    #
+    # Parameters:
+    #  *div_id            [Required] The ID of the DIV element that the Google Chart should be rendered in.
+    def draw_js(element_id)
+      js = ''
+      js << "\n  function #{chart_function_name(element_id)}() {"
+      js << "\n    #{to_js}"
+      js << "\n    var table = new google.visualization.Table("
+      js << "\n    document.getElementById('#{element_id}'));"
+      js << "\n    table.draw(data_table, #{js_parameters(@options)}); "
+      js << "\n  };"
+      js
+    end
+  end # class Datatable end
+end

data/lib/daru/view/adapters/googlecharts/display.rb

@@ -0,0 +1,54 @@
+require 'securerandom'
+require 'erb'
+require_relative 'data_table_iruby'
+
+module GoogleVisualr
+  def self.init_script(
+    dependent_js=['google_visualr.js', 'loader.js']
+  )
+    js =  ''
+    js << "\n<script type='text/javascript'>"
+    js << GoogleVisualr.generate_init_code(dependent_js)
+    js << "\n</script>"
+    js
+  end
+
+  module Display
+    def show_script(dom=SecureRandom.uuid, options={})
+      script_tag = options.fetch(:script_tag) { true }
+      if script_tag
+        # if it is data table
+        if is_a?(GoogleVisualr::DataTable)
+          to_js_full_script(dom)
+        else
+          to_js(dom)
+        end
+      else
+        html = ''
+        html << load_js(dom)
+        html << draw_js(dom)
+        html
+      end
+    end
+
+    def to_html(id=nil, options={})
+      path = File.expand_path('../../../templates/googlecharts/chart_div.erb', __FILE__)
+      template = File.read(path)
+      id ||= SecureRandom.uuid
+      chart_script = show_script(id, script_tag: false)
+      ERB.new(template).result(binding)
+    end
+
+    def show_in_iruby(dom=SecureRandom.uuid)
+      IRuby.html(to_html(dom))
+    end
+  end
+
+  class DataTable
+    include Display
+  end
+
+  class BaseChart
+    include Display
+  end
+end

data/lib/daru/view/adapters/googlecharts/iruby_notebook.rb

@@ -0,0 +1,15 @@
+module GoogleVisualr
+  # generate initializing code
+  def self.generate_init_code(dependent_js)
+    js_dir = File.expand_path('../../js/googlecharts_js', __FILE__)
+    path = File.expand_path('../../../templates/googlecharts/init.inline.js.erb', __FILE__)
+    template = File.read(path)
+    ERB.new(template).result(binding)
+  end
+
+  # Enable to show plots on IRuby notebook
+  def self.init_iruby(dependent_js=['google_visualr.js', 'loader.js'])
+    js = generate_init_code(dependent_js)
+    IRuby.display(IRuby.javascript(js))
+  end
+end

data/lib/daru/view/adapters/highcharts.rb

@@ -0,0 +1,114 @@
+require 'lazy_high_charts'
+require_relative 'highcharts/iruby_notebook'
+require_relative 'highcharts/display'
+require_relative 'highcharts/core_ext/string'
+require 'daru'
+
+module Daru
+  module View
+    module Adapter
+      module HighchartsAdapter
+        extend self # rubocop:disable Style/ModuleFunction
+
+        # Read : https://www.highcharts.com/docs/chart-concepts to understand
+        # the highcharts option concept.
+        #
+        # TODO : this docs must be improved
+        #
+        # @param [Hash] options the options to create a chart with.
+        # @option opts [String] :title The chart title
+        # @option opts [String] :subtitle The chart subtitle
+        # @option opts [String/Symbol] :type The chart type
+        # @option opts [Daru::Vector / Array] :x X Axis data
+        # @option opts [Daru::Vector / Array] :y Y Axis data
+        # @option opts [Hash] :chart The chart options(there are many
+        # options in chart Hash, same as LazyHighCahrts or HighCharts)
+        # @option opts [Hash] :plotOptions The plot options, how the plot
+        # type is configured
+        #
+        # @param [Array/Daru::DataFrame/Daru::Vector] data
+        #
+        def init(data=[], options={})
+          data_new = guess_data(data)
+          # TODO : for multiple series need some modification
+          # Alternate way is using `add_series` method.
+          #
+          # There are many options present in Highcharts so it is better to use
+          # directly all the options. That means Daru::View::Plot will
+          # behave same as LazyHighCharts when `data` is an Array and
+          # `options` are passed.
+          #
+          @chart = LazyHighCharts::HighChart.new do |f|
+            # all the options present in `options` and about the
+            # series (means name, type, data) used in f.series(..)
+            f.options = options.empty? ? LazyHighCharts::HighChart.new.defaults_options : options
+
+            series_type = options[:type] unless options[:type].nil?
+            series_name = options[:name] unless options[:name].nil?
+            f.series(type: series_type, name: series_name, data: data_new)
+          end
+          @chart
+        end
+
+        def init_script
+          LazyHighCharts.init_script
+        end
+
+        def generate_body(plot)
+          plot.to_html
+        end
+
+        def export_html_file(plot, path='./plot.html')
+          path = File.expand_path(path, Dir.pwd)
+          str = generate_html(plot)
+          File.write(path, str)
+        end
+
+        def show_in_iruby(plot)
+          plot.show_in_iruby
+        end
+
+        def generate_html(plot)
+          path = File.expand_path('../../templates/highcharts/static_html.erb', __FILE__)
+          template = File.read(path)
+          initial_script = init_script
+          chart_div = generate_body(plots)
+          ERB.new(template).result(binding)
+        end
+
+        def init_iruby
+          LazyHighCharts.init_iruby
+        end
+
+        # Generally, in opts Hash, :name, :type, :data , :center=> [X, Y],
+        # :size=> Integer, :showInLegend=> Bool, etc may present.
+        def add_series(plot, opts={})
+          plot.series(opts)
+          plot
+        end
+
+        private
+
+        def guess_data(data_set)
+          case
+          when data_set.is_a?(Daru::DataFrame)
+            # TODO : Currently I didn't find use case for multi index.
+            return ArgumentError unless data_set.index.is_a?(Daru::Index)
+            index_val = data_set.index.to_a
+            data_set.access_row_tuples_by_indexs(*index_val)
+          when data_set.is_a?(Daru::Vector)
+            data_set.to_a
+          when data_set.is_a?(Array)
+            data_set
+          when data_set.is_a?(String)
+            # it can be `id` of html table
+            data_set
+          else
+            # TODO: error msg
+            raise ArgumentError
+          end
+        end
+      end # HighchartsAdapter end
+    end # Adapter end
+  end
+end

data/lib/daru/view/adapters/highcharts/core_ext/string.rb

@@ -0,0 +1,10 @@
+class String
+  def js_code(true_or_false=true)
+    @_lazy_high_charts_js_code = true_or_false
+    self
+  end
+
+  def js_code?
+    @_lazy_high_charts_js_code || false
+  end
+end

data/lib/daru/view/adapters/highcharts/display.rb

@@ -0,0 +1,58 @@
+require_relative 'layout_helper_iruby'
+require_relative 'iruby_notebook'
+
+module LazyHighCharts
+  def self.init_script(
+    dependent_js=['highstock.js', 'modules/exporting.js',
+                  'highcharts-3d.js', 'modules/data.js']
+  )
+    # Highstock is based on Highcharts, meaning it has all the core
+    # functionality of Highcharts, plus some additional features. So
+    # highstock.js contains highcharts.js .If highstock.js is removed then
+    # add highchart.js to make chart script work.
+    #
+    # Note: Don't reorder the dependent_js elements. It must be loaded in
+    # the same sequence. Otherwise some of the JS overlap and doesn't work.
+    js =  ''
+    js << "\n<script type='text/javascript'>"
+    js << LazyHighCharts.generate_init_code(dependent_js)
+    js << "\n</script>"
+    js
+  end
+
+  class HighChart
+    # @example
+    #
+    # To display the html code of the chart, use `to_html`. To see the same
+    # in IRuby notebook use `show_in_iruby`.
+    # User can also use :
+    # `IRuby.html chart.to_html` (or)
+    # `IRuby.html chart.to_html.to_s` (or)
+    # `IRuby.display chart.to_html, mime: 'text/html'`
+    # to get the same chart in IRuby notebook.
+    #
+    def to_html(placeholder=random_canvas_id)
+      chart_hash_must_be_present
+      high_chart(placeholder, self)
+    end
+
+    def show_in_iruby(placeholder=random_canvas_id)
+      # TODO : placeholder pass, in plot#div
+      chart_hash_must_be_present
+      IRuby.html high_chart_iruby(placeholder, self)
+    end
+
+    # This method is not needed if `to_html` generates the same code. Here
+    # `to_html` generates the code with `onload`, so there is need of
+    # `high_chart_iruby` which doesn't use `onload` in chart script.
+    def to_html_iruby(placeholder=random_canvas_id)
+      # TODO : placeholder pass, in plot#div
+      chart_hash_must_be_present
+      high_chart_iruby(placeholder, self)
+    end
+
+    def chart_hash_must_be_present
+      @options[:chart] ||= {}
+    end
+  end # class end
+end

data/lib/daru/view/adapters/highcharts/iruby_notebook.rb

@@ -0,0 +1,29 @@
+module LazyHighCharts
+  # generate initializing code
+  def self.generate_init_code(dependent_js)
+    js_dir = File.expand_path('../../js/highcharts_js', __FILE__)
+    path = File.expand_path('../../../templates/highcharts/init.inline.js.erb', __FILE__)
+    template = File.read(path)
+    ERB.new(template).result(binding)
+  end
+
+  # Enable to show plots on IRuby notebook
+  def self.init_iruby(
+    dependent_js=['highcharts.js', 'modules/exporting.js',
+                  'highcharts-3d.js', 'modules/data.js']
+  )
+    # TODO: include highstock.js for highstock and modules/*.js files for
+    # exporting and getting data from various source like csv files etc.
+    #
+    # Highstock.js includes the highcharts.js, so only one of them required.
+    # see: https://www.highcharts.com/errors/16
+    #
+    # , 'modules/exporting.js' : for the exporting button
+    # data.js for getting data as csv or html table.
+    # 'highcharts-more.js' : for arearange and some other chart type
+    # Note: Don't reorder the dependent_js elements. It must be loaded in
+    # the same sequence. Otherwise some of the JS overlap and doesn't work.
+    js = generate_init_code(dependent_js)
+    IRuby.display(IRuby.javascript(js))
+  end
+end

data/lib/daru/view/adapters/highcharts/layout_helper_iruby.rb

@@ -0,0 +1,76 @@
+module LazyHighCharts
+  module LayoutHelper
+    def high_chart_iruby(placeholder, object, &block)
+      object.html_options[:id] = placeholder
+      object.options[:chart][:renderTo] = placeholder
+      high_graph_iruby(placeholder, object, &block).concat(content_tag('div', '', object.html_options))
+    end
+
+    def high_graph_iruby(placeholder, object, &block)
+      build_html_output_iruby('Chart', placeholder, object, &block)
+    end
+
+    private
+
+    def build_html_output_iruby(type, placeholder, object, &block)
+      core_js =<<-EOJS
+        var options = #{options_collection_as_string(object)};
+        #{capture(&block) if block_given?}
+        window.chart_#{placeholder.underscore} = new Highcharts.#{type}(options);
+      EOJS
+
+      encapsulate_js_iruby core_js
+    end
+
+    # rubocop:disable Metrics/PerceivedComplexity, Metrics/MethodLength
+    def encapsulate_js_iruby(core_js)
+      js_output =
+        if request_is_xhr?
+          "#{js_start_iruby} #{core_js} #{js_end_iruby}"
+        # Turbolinks.version < 5
+        elsif defined?(Turbolinks)
+          if request_is_referrer?
+            <<-EOJS
+            #{js_start_iruby}
+              var f = function(){
+                document.removeEventListener('page:load', f, true);
+                #{core_js}
+              };
+              document.addEventListener('page:load', f, true);
+            #{js_end_iruby}
+            EOJS
+          elsif request_turbolinks_5_tureferrer?
+            <<-EOJS
+            #{js_start_iruby}
+              document.addEventListener("turbolinks:load", function() {
+                #{core_js}
+              });
+            #{js_end_iruby}
+            EOJS
+          end
+        else
+          <<-EOJS
+          #{js_start_iruby}
+            #{core_js}
+          #{js_end_iruby}
+          EOJS
+        end
+
+      defined?(raw) ? raw(js_output) : js_output
+    end
+
+    def js_start_iruby
+      <<-EOJS
+        <script type="text/javascript">
+        $(function() {
+      EOJS
+    end
+
+    def js_end_iruby
+      <<-EOJS
+        });
+        </script>
+      EOJS
+    end
+  end
+end