daru-view 0.1.0

data/Rakefile

@@ -0,0 +1,22 @@
+require "bundler/gem_tasks"
+
+require 'bundler/setup'
+require 'rubygems/tasks'
+Gem::Tasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+desc 'Default: run unit specs.'
+task :default => %w[spec rubocop]
+
+
+import 'lib/tasks/high_charts.rake'
+import 'lib/tasks/nyaplot.rake'
+import 'lib/tasks/google_charts.rake'
+
+# TODO: add Nyaplot
+task :update_all => ["googlecharts:update", "highcharts:update"]

data/_config.yml

@@ -0,0 +1 @@
+theme: jekyll-theme-hacker

data/daru-view.gemspec

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'daru/view/version'
+
+Daru::View::DESCRIPTION = <<MSG
+  Daru (Data Analysis in RUby) is a library for analysis, manipulation and
+  visualization of data. Daru-view is for easy and interactive plotting in web
+  application & IRuby notebook. It can work in frameworks e.g. Rails, Sinatra,
+   Nanoc and hopefully in others too.
+MSG
+
+Gem::Specification.new do |spec|
+  spec.name          = 'daru-view'
+  spec.version       = Daru::View::VERSION
+  spec.authors       = ['Shekhar Prasad Rajak']
+  spec.email         = ['shekharrajak@live.com']
+
+  spec.summary       = 'Plugin gem to Data Analysis in RUby(Daru) for visualisation of data'
+  spec.description   = Daru::View::DESCRIPTION
+  spec.homepage      = 'https://github.com/Shekharrajak/daru-view'
+  spec.license       = 'MIT'
+  spec.require_paths = ['lib']
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'pry'
+
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rubocop'
+
+  # fetching latest gem from the Gemfile
+  spec.add_runtime_dependency 'google_visualr'
+  spec.add_runtime_dependency 'lazy_high_charts'
+  spec.add_runtime_dependency 'daru'
+  spec.add_runtime_dependency 'nyaplot'
+  spec.add_runtime_dependency 'daru-data_tables'
+
+  # lazy_high_charts dependency
+  spec.add_runtime_dependency 'actionview'
+
+  # build gem and release it on rubygems
+  spec.add_development_dependency 'rubygems-tasks'
+end
+

data/lib/daru/view.rb

@@ -0,0 +1,127 @@
+require 'daru/view/version'
+require 'daru/view/plot'
+require 'daru/view/adapters/highcharts/display'
+require 'daru/view/adapters/nyaplot/display'
+require 'daru/view/adapters/googlecharts/display'
+require 'daru/view/table'
+
+# needed in load_lib_in_iruby method
+require 'daru/view/adapters/highcharts/iruby_notebook'
+require 'daru/view/adapters/nyaplot/iruby_notebook'
+require 'daru/view/adapters/googlecharts/iruby_notebook'
+
+# Rails Helper
+require 'daru/view/app/rails/railtie.rb' if defined?(Rails)
+
+module Daru
+  module View
+    # default Nyaplot library is used.
+    @plotting_library = :nyaplot
+    Daru::View::Plot.adapter = @plotting_library
+
+    class << self
+      attr_reader :plotting_library, :table_library
+
+      # New plotting library is set. Same time Daru::View::Plot.adapter is set.
+      def plotting_library=(lib)
+        case lib
+        when :nyaplot, :highcharts
+          # plot charts
+          @plotting_library = lib
+          Daru::View::Plot.adapter = lib
+        when :googlecharts
+          # plot chart and table drawing
+          @plotting_library = lib
+          Daru::View::Plot.adapter = lib
+          Daru::View::Table.adapter = lib
+        else
+          raise ArgumentError, "Unsupported library #{lib}"
+        end
+
+        # When code is running in console/terminal then IRuby NameError.
+        # Since IRuby methods can't work in console.
+        begin
+          load_lib_in_iruby lib.to_s if defined? IRuby
+        rescue NameError # rubocop:disable Lint/HandleExceptions
+        end
+      end
+
+      # New table library is set. Same time Daru::View::Table.adapter is set.
+      def table_library=(lib)
+        case lib
+        when :googlecharts
+          # plot chart and table drawing
+          @plotting_library = lib
+          Daru::View::Plot.adapter = lib
+          Daru::View::Table.adapter = lib
+        when :datatables
+          # only for table drawing
+          Daru::View::Table.adapter = lib
+        else
+          raise ArgumentError, "Unsupported library #{lib}"
+        end
+
+        # When code is running in console/terminal then IRuby NameError.
+        # Since IRuby methods can't work in console.
+        begin
+          load_lib_in_iruby lib.to_s if defined? IRuby
+        rescue NameError # rubocop:disable Lint/HandleExceptions
+        end
+      end
+
+      # Load the dependent JS files in IRuby notebook. Those JS will help in
+      # plotting the charts in IRuby cell.
+      #
+      # @example
+      #
+      # To load the dependent JS file for Nyaplot library
+      # plotting system (Nyaplot.js, d3.js):
+      #
+      # Daru::View.load_lib_in_iruby('nyaplot')
+      #
+      # To load the HighCharts dependent JS
+      # files (highcharts.js, highcharts-3d.js, highstock.js):
+      #
+      # Daru::View.load_lib_in_iruby('highcharts')
+      #
+      def load_lib_in_iruby(library)
+        if library.match('highcharts')
+          library = 'LazyHighCharts'
+          Object.const_get(library).init_iruby
+        elsif library.match('googlecharts')
+          library = 'GoogleVisualr'
+          Object.const_get(library).init_iruby
+        elsif library.match('datatables')
+          library = 'DataTables'
+          Object.const_get(library).init_iruby
+        else
+          Object.const_get(library.capitalize).init_iruby
+        end
+      end
+
+      # dependent script for the library. It must be added in the head tag
+      # of the web application.
+      #
+      # @example
+      #
+      # dep_js = Daru::View.dependent_script(:highcharts)
+      #
+      # use in Rails app : <%=raw dep_js %>
+      #
+      def dependent_script(lib=:nyaplot)
+        case lib
+        when :nyaplot
+          Nyaplot.init_script
+        when :highcharts
+          LazyHighCharts.init_script
+        when :googlecharts
+          GoogleVisualr.init_script
+        when :datatables
+          DataTables.init_script
+        else
+          raise ArgumentError, "Unsupported library #{lib}"
+        end
+      end
+    end
+  end # view end
+end

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

@@ -0,0 +1,90 @@
+require 'daru/data_tables'
+require 'daru'
+require 'securerandom'
+
+module Daru
+  module View
+    module Adapter
+      module DatatablesAdapter
+        extend self # rubocop:disable Style/ModuleFunction
+
+        # Read : https://datatables.net/ to understand
+        # the datatables option concept.
+        #
+        # TODO : this docs must be improved
+        def init_table(data=[], options={})
+          # TODO : create data array from the df and vector data. So that
+          # we can directly use the array.(No need to create df or vector and
+          # generate the html table using to_html)
+          if data.is_a?(Array)
+            data_name = 'series_data'+ SecureRandom.uuid
+            data =
+              if data.all? { |e| e.class==Array }
+                Daru::DataFrame.rows(data, name: data_name)
+              else
+                Daru::Vector.new(data, name: data_name)
+              end
+          end
+          # options[:data] = data_in_array unless data_in_array.empty?
+          @table = Daru::DataTables::DataTable.new(options)
+          @data = data
+          @table
+        end
+
+        def init_script
+          Daru::DataTables.init_script
+        end
+
+        def generate_body(table)
+          table_opts = {
+            class: 'display',
+            cellspacing: '0',
+            width: '100%',
+            table_html: @data.to_html_thead + @data.to_html_tbody
+          }
+          html_options ={
+            table_options: table_opts
+          }
+          table.to_html(@data.name, html_options)
+        end
+
+        def export_html_file(table, path='./table.html')
+          # TODO
+        end
+
+        def show_in_iruby(table)
+          table.show_in_iruby
+        end
+
+        def generate_html(table)
+          # TODO
+        end
+
+        def init_iruby
+          Daru::DataTables.init_iruby
+        end
+
+        private
+
+        # DataTables accept the data as Array of array.
+        #
+        # TODO : I didn't find use case for multi index.
+        def to_data_array(data_set)
+          case
+          when data_set.is_a?(Daru::DataFrame)
+            return ArgumentError unless data_set.index.is_a?(Daru::Index)
+            data_set.access_row_tuples_by_indexs(*data_set.index.to_a)
+          when data_set.is_a?(Daru::Vector)
+            rows = []
+            data_set.to_a.each { |a| rows << [a] }
+            rows
+          when data_set.is_a?(Array)
+            data_set
+          else
+            raise ArgumentError # TODO: error msg
+          end
+        end
+      end # DatatablesAdapter end
+    end # Adapter end
+  end
+end

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

@@ -0,0 +1,180 @@
+require 'google_visualr'
+require_relative 'googlecharts/iruby_notebook'
+require_relative 'googlecharts/display'
+require 'daru'
+require 'bigdecimal'
+
+module Daru
+  module View
+    module Adapter
+      module GooglechartsAdapter
+        extend self # rubocop:disable Style/ModuleFunction
+
+        # Read : https://developers.google.com/chart/ to understand
+        # the google charts option concept.
+        # and google_visualr : http://googlevisualr.herokuapp.com/
+        #
+        # TODO : this docs must be improved
+        def init(data=[], options={})
+          @table = GoogleVisualr::DataTable.new
+          @table =
+            if data.is_a?(Daru::View::Table) && data.table.is_a?(GoogleVisualr::DataTable)
+              data.table
+            elsif data.is_a?(GoogleVisualr::DataTable)
+              data
+            else
+              add_data_in_table(data)
+            end
+          chart_type = extract_chart_type(options)
+          @chart = GoogleVisualr::Interactive.const_get(
+            chart_type
+          ).new(@table, options)
+          @chart
+        end
+
+        def init_table(data=[], options={})
+          # if `options` is something like this :
+          # {
+          #   cols: [{id: 'task', label: 'Employee Name', type: 'string'},
+          #          {id: 'startDate', label: 'Start Date', type: 'date'}],
+          #   rows: [{c:[{v: 'Mike'}, {v: new Date(2008, 1, 28), f:'February 28, 2008'}]},
+          #          {c:[{v: 'Bob'}, {v: new Date(2007, 5, 1)}]},
+          #          {c:[{v: 'Alice'}, {v: new Date(2006, 7, 16)}]},
+          #          {c:[{v: 'Frank'}, {v: new Date(2007, 11, 28)}]},
+          #          {c:[{v: 'Floyd'}, {v: new Date(2005, 3, 13)}]},
+          #          {c:[{v: 'Fritz'}, {v: new Date(2011, 6, 1)}]}
+          #         ]
+          # }
+          # then directly DatTable is created using options. Use data=[] or nil
+          @table = GoogleVisualr::DataTable.new(options)
+          add_data_in_table(data)
+          @table
+        end
+
+        def init_script
+          GoogleVisualr.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)
+          # TODO: modify code
+          path = File.expand_path('../../templates/googlecharts/chart_div.erb', __FILE__)
+          template = File.read(path)
+          initial_script = init_script
+          chart_script = generate_body(plots)
+          ERB.new(template).result(binding)
+        end
+
+        def init_iruby
+          GoogleVisualr.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 extract_chart_type(options)
+          # TODO: Imprvoe this method.
+          chart_type = options[:type].nil? ? 'Line' : options.delete(:type)
+          chart_type = chart_type.to_s.capitalize
+          chart_type = 'SteppedArea' if chart_type == 'Steppedarea'
+          chart_type = 'TreeMap' if chart_type == 'Treemap'
+          direct_name = %w[Map Histogram TreeMap Timeline Gauge]
+          direct_name.include?(chart_type) ? chart_type : chart_type + 'Chart'
+        end
+
+        # For google table, column is needed.
+        #
+        # note :  1st line must be colmns name and then all others
+        # data rows
+        #
+        # TODO : Currently I didn't find use case for multi index.
+        def add_data_in_table(data_set) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize, Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity, Metrics/LineLength
+          case
+          when data_set.is_a?(Daru::DataFrame)
+            return ArgumentError unless data_set.index.is_a?(Daru::Index)
+            rows = data_set.access_row_tuples_by_indexs(*data_set.index.to_a)
+            data_set.vectors.to_a.each do |vec|
+              @table.new_column(converted_type_to_js(vec, data_set), vec)
+            end
+          when data_set.is_a?(Daru::Vector)
+            vec_name = data_set.name.nil? ? 'Series' : data_set.name
+            @table.new_column(return_js_type(data_set[0]), vec_name)
+            rows = []
+            data_set.to_a.each { |a| rows << [a] }
+          when data_set.is_a?(Array)
+            return GoogleVisualr::DataTable.new if data_set.empty?
+
+            data_set[0].each_with_index do |col, indx|
+              # TODO: below while loop must be improved. Similar thing for
+              # above 2 cases.
+              row_index = 1
+              type = return_js_type(data_set[row_index][indx])
+              while type.nil?
+                row_index += 1
+                type = return_js_type(data_set[row_index][indx])
+              end
+              @table.new_column(type, col)
+            end
+            data_set.shift # 1st row removed
+            rows = data_set
+          when data_set.is_a?(Hash)
+            @table = GoogleVisualr::DataTable.new(data_set)
+            return
+          else
+            raise ArgumentError # TODO: error msg
+          end
+          @table.add_rows(rows)
+          @table
+        end
+
+        def converted_type_to_js(vec_name, data_set)
+          # Assuming all the data type is same for all the column values.
+          case
+          when data_set.is_a?(Daru::DataFrame)
+            return_js_type(data_set[vec_name][0])
+          when data_set.is_a?(Daru::Vector)
+            return_js_type(data_set[0])
+          end
+        end
+
+        # TODO : fix Metrics/PerceivedComplexity rubocop error
+        def return_js_type(data) # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+          data = data.is_a?(Hash) ? data[:v] : data
+          case
+          when data.nil?
+            return
+          when data.is_a?(String)
+            return 'string'
+          when data.is_a?(Integer) || data.is_a?(Float) || data.is_a?(BigDecimal)
+            return 'number'
+          when data.is_a?(TrueClass) || data.is_a?(FalseClass)
+            return 'boolean'
+          when data.is_a?(DateTime)  || data.is_a?(Time)
+            return 'datetime'
+          when data.is_a?(Date)
+            return 'date'
+          end
+        end
+      end # GooglechartsAdapter end
+    end # Adapter end
+  end
+end