RubyGems - rubypivot - Versions diffs - 0.0.1 → 0.0.2 - Mend

rubypivot 0.0.1 → 0.0.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

checksums.yaml +4 -4
data/README.md +35 -2
data/examples/html_table.html +61 -0
data/examples/html_tag.rb +15 -0
data/examples/simple.rb +11 -7
data/examples/spread_table.png +0 -0
data/examples/spread_table.rb +75 -0
data/lib/rubypivot.rb +3 -2
data/lib/rubypivot/html_tag.rb +81 -0
data/lib/rubypivot/pivot.rb +42 -20
data/lib/rubypivot/pivot_row.rb +0 -5
data/lib/rubypivot/spread_table.rb +334 -0
data/lib/rubypivot/table.rb +95 -0
data/lib/rubypivot/version.rb +1 -1
metadata +9 -2

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2976ecf2bef2b1fcc45d0044cbf553ab7b07e0ee8ecd48aca334f13836399016
-  data.tar.gz: 92c6cf0c117a8dbbff68b55a72c760bae6bc62992b1ca7744e9bfe35ebc731eb
+  metadata.gz: 9a08da64e0fde946fe250518330143484176d4aae03f14d01d8c0597ec1b9631
+  data.tar.gz: 920c3745a938d8529a56acd051801ac18b9ec76d00ca62bb498e3043d080f446
 SHA512:
-  metadata.gz: 9575159c5670c6831c9777e98bede1a93e19347f3b9ae6d3f9a848450d78029dc3810323857de554d98d0fa5a72edfd5930173fc049c73b8ee0b28a00b9c4e7c
-  data.tar.gz: a9a32709eec385451e3bd1398e412cc874e7020daf02ad25ca85ed4905606c15ee300e4884dc8a9be906b0da8188d6ec5bb498cd2c3d180b6e90ad22cd5fd4f7
+  metadata.gz: 2b27cc0df34f5bdf1c08e44633f2f85204ebf78ee139bd56162841f7dba07f063976bdf1b31635a1f2315aab782f9d848fd710b7895c915516e2fc52460d475a
+  data.tar.gz: 904336637ab697e188b75165b56f32a318b5036aec8d141f8db8bd84d0648f1d169ecc990670f561af9b60c26c9102314780fc7a27dda51ddfdc24b958618c9c

data/README.md CHANGED

@@ -10,22 +10,55 @@ Suggestions and pull requests are welcome.
 ```
 gem install rubypivot
 ```
-Not yet ready, please clone the repository for the moment.
 ## Usage
+Pivot class transform database record type array into pivot table Hash or Array
 ```ruby
 require "rubypivot"
 pivot = Rubypivot::Pivot.new(source_data, :month, :name, :value, data_type: :integer)
-pivot.build.each do |line|
+pivot_array = pivot.build
+pivot_array.each do |line|
   p line
 end
 ```
+SpreadTable class makes a Hash table from pivot hash, which makes it easy to build HTML table with totals, layouts, colors.
+```ruby
+require "rubypivot"
+pivot = Rubypivot::Pivot.new(source_data, :month, :name, :value, data_type: :integer)
+pivot_hash = pivot.build_hash
+spread = Rubypivot::SpreadTable.new(pivot_hash, data_type: :integer)
+spread.rows.each do |row|
+  puts row.to_s
+end
+```
+```ruby
+require "rubypivot"
+spread = Rubypivot::SpreadTable.new(DATA_SOURCE, data_type: :integer)
+puts spread.to_html(class: "table table-striped", line_end: :cr)
+```
+![SpreadTable](./examples/spread_table.png)
 See sample scripts in examples folder.
 Supported data aggregation is only SUM for numeric values.
 Total calculation supported.
+## To do-s
+- Bootstrap Grid output
+## History
+- Ver. 0.0.2 : 2021-01-01 New class SpreadTable supports to_s, to_html (HTML table), to_grid (Bootstrap grid)
+- Ver. 0.0.1 : 2020-12-28 First release. Making pivot array
 ## License
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/examples/html_table.html ADDED

@@ -0,0 +1,61 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="utf-8">
+  <meta http-equiv="X-UA-Compatible" content="IE=edge">
+  <meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
+  <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.0.0-beta1/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-giJF6kkoqNQ00vy+HMDP7azOuL0xtbfIcaT9wjKHr8RbDVddVHyTfAAsrekwKmP1" crossorigin="anonymous">
+  <title>RubyPivot Example</title>
+  <style>
+  .container {
+    max-width: 960px;
+  }
+  .title-header {
+    max-width: 700px;
+  }
+  tr.header {
+    background-color: #eeeeff;
+    text-align: right;
+    font-weight: bold;
+  }
+  tr.data-row {
+    text-align: right;
+  }
+  tr.data-girl {
+    background-color: #ffeeee;
+    text-align: right;
+  }
+  td.header-title {
+    text-align: left;
+  }
+  td.data-title {
+    background-color: #ffffee;
+    text-align: left;
+  }
+  td.data {
+    color:#3333aa;
+  }
+  td.zero {
+    color: #aaaaaa;
+  }
+  td.negative {
+    color:#aa3333;
+  }
+  </style>
+</head>
+<body>
+  <div class="container">
+  <div class="title_header" name="title-header" data-bs-target="target">HTML Table Creator for pivot array</div>
+  <table class="table table-striped">
+    <tr class="header"><td class="header-title"></td><td>A</td><td>B</td><td>C</td></tr>
+    <tr class="data-girl"><td class="data-title">Wendy</td><td>1</td><td>2</td><td class="negative">-3</td></tr>
+    <tr class="data-row"><td class="data-title">John</td><td>4</td><td class="zero">0</td><td>6</td></tr>
+    <tr class="data-row"><td class="data-title">David</td><td class="negative">-2</td><td>3</td><td class="zero">0</td></tr>
+    <tr class="header"><td class="header-title">Total</td><td>3</td><td>5</td><td>3</td></tr>
+    </table>
+  </div>
+</body>
+</html>

data/examples/html_tag.rb ADDED

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+#
+# Make HTML table from spread sheet array
+#
+APP_ROOT = File.dirname(__FILE__)
+$LOAD_PATH << "#{APP_ROOT}/../lib"
+require "rubypivot/html_tag"
+div = Rubypivot::HtmlTag.new('div', class: 'section section-info', name: 'title-header')
+div.add_key('data-bs-target', 'target')
+puts div.build { "HTML Tag generator" }
+puts div.build(body: "HTML Tag generator")
+tr = Rubypivot::HtmlTag.new('tr', class: 'header')

data/examples/simple.rb CHANGED

@@ -18,18 +18,22 @@ source_data = [
 pivot = Rubypivot::Pivot.new(source_data, :month, :name, :value, data_type: :integer)
 pivot.column_titles = ['Jan', 'Feb', 'Mar']
+pivot.options[:row_total] = 'Total'
 # pivot.options[:header] = true
 # pivot.options[:row_header] = false
-# pivot.column_titles.sort!
-# p pivot.column_titles
 # p pivot.row_titles
+# p pivot.header_row('')
+# p pivot.column_titles.sort! # sorting columns
+p pivot.column_titles
+puts "------------"
+pivot.build_data.sort.each do |title, line|
+  puts "#{title}: #{line.join(", ")}"
+end
+puts
+puts "------------"
 pivot.build.each do |line|
   p line
 end
 puts "------------"
 p pivot.total_row('Total')
-#["", "Jan", "Feb", "Mar"]
-#["David", 3, nil, nil]
-#["John", 123, 23, nil]
-#["Wendy", 33, 100, nil]

data/examples/spread_table.png ADDED

Binary file

data/examples/spread_table.rb ADDED

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+#
+# Create spread sheet array, having row (tr) and cell (td) attributes
+# to help HTML table
+#
+APP_ROOT = File.dirname(__FILE__)
+$LOAD_PATH << "#{APP_ROOT}/../lib"
+require "rubypivot"
+# require "pry"
+# binding.pry
+DATA_SOURCE = [
+  ["", "A", "B", "C"],
+  ["Wendy", 1, 2, -3],
+  ["John", 4, 0, 6],
+  ["David", -2, 3, 0],
+  ["Total", 3, 5, 3],
+]
+# Callback function to control cell class
+# data is cell data, line_data is an array of the line cells
+def cell_class_callback(data, line_title)
+  if data.to_i < 0
+    "negative"
+  elsif data.to_i == 0
+    "zero"
+  else
+    nil
+  end
+end
+def cell_callback(data, line_title)
+  if line_title == 'Total'
+    "<td class=\"my-total\">#{"%03d" % data}</td>"
+  else
+    "<td class=\"my-cell\">#{"%03d" % data}</td>"
+  end
+end
+# spread = DATA_SOURCE.to_spread(  # Alternate method to create new
+spread = Rubypivot::SpreadTable.new(DATA_SOURCE,
+  header: :first, # Consider the first row as header row
+  title: :first, # Consider the first column as row header
+  total: :last, # Consider the last row as total row
+  data_type: :integer, # or :float, :string, nil
+  header_line_class: 'header', # tr class for header and total row(s), grid size for Bootstrap
+  header_title_class: 'header-title', # td class for title of header row
+  data_line_class: 'data-row', # tr class for data row(s), grid size for Bootstrap
+  data_title_class: 'data-title', # td class for title of data row
+  data_format: '%02d', # format for data cells
+)
+# spread.each_header_line {|row| row.set_line_class("header") }
+spread.line(1).set_line_class("data-girl") # Set TR class
+spread.set_cell_class(method(:cell_class_callback))
+# spread.each_data_line {|line| line.set_cell_class(method(:cell_class_callback)) } # Same effects like above line
+# spread.set_cell_class('data-class')
+spread.get_row(:last).set_cell_callback(method(:cell_callback))
+# spread.set_cell_callback(method(:cell_callback))
+puts "--- Created array ------------"
+spread.rows.each do |row|
+  puts row.to_s
+end
+puts "--- Some calculated attrib ---"
+puts "Total width: #{spread.total_width}"
+puts "Total height: #{spread.total_height}"
+puts "Data width: #{spread.data_width}"
+puts "Data height: #{spread.data_height}"
+puts "--- HTML table ---------------"
+puts spread.to_html(class: "table table-striped", line_end: :cr)
+puts "--- Bootstrap grid -----------"
+spread.set_line_class("md")
+puts spread.to_grid(:bootstrap, [2, 1, 1, 1, 1])

data/lib/rubypivot.rb CHANGED

@@ -1,9 +1,10 @@
 # require "rubypivot/version"
+require "rubypivot/version"
 require "rubypivot/pivot"
 require "rubypivot/pivot_row"
+require "rubypivot/spread_table"
+require "rubypivot/html_tag"
 module Rubypivot
-  VERSION = "0.0.1" # Pre-release
   class PivotError < StandardError; end
 end

data/lib/rubypivot/html_tag.rb ADDED

@@ -0,0 +1,81 @@
+module Rubypivot
+  class HtmlTag
+    def initialize(tag_name, options = {})
+      @tag_name = tag_name
+      @options = options
+      @class_strings = []
+    end
+    def add_key(key, value)
+      @options[key] = value
+      self
+    end
+    def sanitize(value)
+      return nil unless value
+      array = value.split(/ +/)
+      array.uniq!
+      array.join(" ")
+    end
+    def add_class(class_string)
+      if class_string
+        class_string.to_s.split(/ +/).each do |str|
+          next if str.nil? || @class_strings.include?(str)
+          @class_strings << str
+        end
+      end
+      self
+    end
+    def build_class
+      return '' if @class_strings.empty?
+      " class=\"#{@class_strings.join(' ')}\""
+    end
+    def open
+      add_class(@options[:class])
+      res = "<#{@tag_name}"
+      res << build_class
+      @options.each do |key, value|
+        next if value.nil?
+        case key
+        when :class
+          # class was handled first
+        else
+          res << " #{key}=\"#{value}\""
+        end
+      end
+      res << ">"
+      res
+    end
+    def close
+      "</#{@tag_name}>"
+    end
+    def build(options = {})
+      res = open
+      # res << "\n" unless options[:compact]
+      if block_given?
+        res << yield.to_s
+        # res << "\n" unless options[:compact]
+        res << close
+        # res << "\n" unless options[:compact]
+      elsif options[:body]
+        res << options[:body]
+        # res << "\n" unless options[:compact]
+        res << close
+        # res << "\n" unless options[:compact]
+      end
+      res
+    end
+    alias :to_html :build
+    def self.to_html(tag_name, options = {})
+      instance = self.new(tag_name, body, options = {})
+      instance.build(body)
+    end
+  end
+end

data/lib/rubypivot/pivot.rb CHANGED

@@ -1,5 +1,8 @@
 module Rubypivot
+#
+# 2020-12-28 First
+# 2020-12-30 Build an hash instead array
+#
   class Pivot
     DEFAULT_OPTIONS = {
       data_type: :integer, # :integer, :float or :string
@@ -9,7 +12,7 @@ module Rubypivot
       row_header: true,
       # column_lookup: HashName
       # row_lookup: HashName
-      # :row_total: 'Title for total column'
+      # row_total: 'Title for total column, if nil row total not calculated'
     }.freeze
     attr_accessor :options
@@ -50,6 +53,10 @@ module Rubypivot
       @row_titles || make_row_list
     end
+    def column_head(row_title)
+      @options[:row_lookup] ? @options[:row_lookup][row_title] : row_title
+    end
     def make_column_list
       @column_titles = [] unless @column_titles
       @source_data.each do |each_line|
@@ -84,35 +91,50 @@ module Rubypivot
       self
     end
-    def column_header
-      res = []
-      res << '' if @options[:row_header]
-      if @options[:column_lookup]
-        @column_titles.each do |column|
-          res << @options[:column_lookup][column]
-        end
-      else
-        res += @column_titles
+    # return an pivot hash. data rows only
+    def build_data
+      parse_data unless @rows_parsed
+      res = {}
+      @row_titles.each do |row_title|
+        row = @rows_parsed.get_row(row_title)
+        title = column_head(row_title)
+        res[title] = row.to_a(column_titles)
       end
-      res << @options[:row_total] if @options[:row_total]
       res
     end
+    alias :build_hash :build_data
-    # return an pivot array
+    # return an pivot array with titles
     def build
       parse_data unless @rows_parsed
       res = []
-      res << column_header if @options[:header]
+      res << header_row if @options[:header]
       @row_titles.each do |row_title|
         row = @rows_parsed.get_row(row_title)
         data_array = []
-        data_array << @rows_parsed.header(row_title) if @options[:row_header]
+        data_array << column_head(row_title) if @options[:row_header]
         data_array += row.to_a(column_titles)
         data_array << row.total(column_titles) if @options[:row_total]
         res << data_array
       end
       res
     end
+    alias :build_array :build
+    # Make an array
+    def header_row(title = nil)
+      res = []
+      res << "#{title}" if @options[:row_header]
+      if @options[:column_lookup]
+        @column_titles.each do |column|
+          res << @options[:column_lookup][column]
+        end
+      else
+        res += @column_titles
+      end
+      res << @options[:row_total] if @options[:row_total]
+      res
+    end
     def total_row(title = nil)
       parse_data unless @rows_parsed
@@ -122,10 +144,6 @@ module Rubypivot
       res += @rows_parsed.total(@column_titles, @options[:row_total])
     end
-    def self.build(data, column_name, row_name, data_name, options = {})
-      obj = self.new(data, column_name, row_name, data_name, options)
-      obj.build
-    end
     # get column title or row title
     def self.get_title(name, line)
       if line.is_a?(Hash)
@@ -144,6 +162,10 @@ module Rubypivot
         line.send(name)
       end
     end
+    def self.build(data, column_name, row_name, data_name, options = {})
+      obj = self.new(data, column_name, row_name, data_name, options)
+      obj.build
+    end
   end
 end

data/lib/rubypivot/pivot_row.rb CHANGED

@@ -4,7 +4,6 @@ module Rubypivot
     def initialize(options = {})
       @options = options
       @data_type = options[:data_type]
-      @lookup = options[:row_lookup]
       @rows = {}
     end
@@ -13,10 +12,6 @@ module Rubypivot
     end
     alias :add_row :get_row
-    def header(row_title)
-      @lookup ? @lookup[row_title] : row_title
-    end
     def total(column_titles = [], show_grand_total = false)
       return ['Total', 'row', 'can', 'not', 'create', "type :#{@data_type}"] unless [:integer, :float].include?(@data_type)
       grand_total = @data_type == :float ? 0.0 : 0

data/lib/rubypivot/spread_table.rb ADDED

@@ -0,0 +1,334 @@
+# Create spread sheet array of row objects (SpreadTableLine) from array
+# having row (tr) and cell (td) attributes
+# to help HTML table
+#
+# 2020-12-31
+#
+class Array
+  def to_spread(options = {})
+    spread_array = SpreadTable.new(self, options)
+  end
+end
+module Rubypivot
+  class SpreadTableError < StandardError; end
+  class SpreadTableLine
+    LINE_TYPES = {
+      header: 'Header',
+      data:   'Data  ',
+      total:  'Total ',
+    }.freeze
+    attr_reader :line_type, :options
+    attr_accessor :line_data, :title, :attribut
+    def initialize(line_type, line_data = [], options = {})
+      @options = options
+      @attribute = {}
+      @attribs = []
+      set_line_type(line_type, @options)
+      # Desparate to have an array, convert it if not
+      if line_data.is_a?(Array)
+        @line_data = line_data
+      elsif line_data.is_a?(Hash)
+        @line_data = []
+        line_data.each do |key, value|
+          @line_data << value
+        end
+      elsif line_data.is_a?(String)
+        @line_data = line_data.split(/[ \t]+/)
+      else
+        @line_data = [line_data]
+      end
+      if options[:title]
+        if options[:title] == :first
+          @title = @line_data.shift
+        else
+          @title = options[:title].to_s
+        end
+      end
+    end
+    def set_line_type(line_type, options = {})
+      @line_type = line_type
+      @line_type = :data unless LINE_TYPES[@line_type] # at least vaid must be set
+      if @line_type == :data
+        @attribute[:line_class] = options[:data_line_class] if options[:data_line_class]
+        @attribute[:title_class] = options[:data_title_class] if options[:data_title_class]
+      else
+        @attribute[:line_class] = options[:header_line_class] if options[:header_line_class]
+        @attribute[:title_class] = options[:header_title_class] if options[:header_title_class]
+      end
+      if @line_type == :header
+        #
+      else
+        @attribute[:data_format] = options[:data_format] if options[:data_format]
+      end
+    end
+    def data_width
+      @line_data.size
+    end
+    def set_line_class(klass)
+      @attribute[:line_class] = klass
+    end
+    def set_td_class(klass)
+      @attribute[:cell_class] = klass
+    end
+    def set_title_class(klass)
+      @attribute[:cell_class] = klass
+    end
+    def set_cell_class(callback)
+      return unless callback
+      if callback.is_a?(Method)
+        @line_data.each_with_index do |cell_data, idx|
+          klass = callback.call(cell_data, @title)
+          @attribs[idx] = klass if klass
+        end
+      else
+        @line_data.each_with_index do |cell_data, idx|
+          @attribs[idx] = callback.to_s
+        end
+      end
+    end
+    def set_cell_callback(callback)
+      return if callback.nil? || !callback.is_a?(Method)
+      if @line_type == :header
+        @attribute[:cell_callback] = callback
+      else
+        @attribute[:cell_callback] = callback
+      end
+    end
+    def line_data_formatted
+      return @line_data if @line_type == :header || @attribute[:data_format].nil?
+      res = []
+      @line_data.each do |data|
+        res << @attribute[:data_format] % data
+      end
+      res
+    end
+    def to_s
+      res = ""
+      res << "#{LINE_TYPES[@line_type]}: "
+      res << "#{@title}: " if @title
+      res << line_data_formatted.join(', ')
+      res << " : Line Class: #{@attribute[:line_class]}"
+      res << " : Cell Class: #{@attribute[:cell_class]}"
+      res << " : Title Class: #{@attribute[:title_class]}"
+      res
+    end
+    def to_html(options = {})
+      tr = Rubypivot::HtmlTag.new('tr', class: @attribute[:line_class])
+      td_str = ""
+      if @title
+        td = Rubypivot::HtmlTag.new('td', class: @attribute[:title_class] || @attribute[:cell_class])
+        td_str << td.build{ @title }
+      end
+      line_data_formatted.each_with_index do |cell_data, idx|
+        if @attribute[:cell_callback]
+          td_str << @attribute[:cell_callback].call(cell_data, @title)
+        else
+          td = Rubypivot::HtmlTag.new('td', class: @attribs[idx])
+          td_str << td.build{ cell_data }
+        end
+      end
+      res = tr.build { td_str }
+      res << "\n" if options[:line_end] == :cr
+      res
+    end
+    def make_col_class(options = {})
+      klass = "col"
+      klass << "-#{@attribute[:line_class]}" if @attribute[:line_class]
+      klass << "-#{options[:width]}" if options[:width]
+      # klass << " #{options[:klass]}" if options[:klass]
+      klass
+    end
+    def to_grid(framework = :bootstrap, widths = [], options = {})
+      res = "<div class=\"row\">"
+      if @title
+        div = Rubypivot::HtmlTag.new('div', class: make_col_class(width: widths[0])) # klass: @attribute[:title_class]
+        res << div.build{ @title }
+      end
+      line_data_formatted.each_with_index do |cell_data, idx|
+        div = Rubypivot::HtmlTag.new('div', class: make_col_class(width: widths[idx + 1])) # klass: @attribute[:title_class]
+        res << div.build{ cell_data }
+      end
+      res << "</div>/n"
+      res
+    end
+  end
+  class SpreadTable
+    attr_reader :data_width, :data_height, :total_width
+    attr_accessor :options, :rows
+    def initialize(data_source, options = {})
+      @rows = []
+      @options = {}
+      @options_for_line = {}
+      options.each do |k, v|
+        if [:title, :data_line_class, :header_line_class, :data_title_class, :header_title_class, :data_format].include?(k)
+          @options_for_line[k] = v
+        else
+          @options[k] = v
+        end
+      end
+      @attribs = []
+      if data_source.is_a? Array
+        data_source.each do |line|
+          @rows << SpreadTableLine.new(:data, line, @options_for_line)
+        end
+      elsif data_source.is_a? Hash
+        data_source.each do |title, values|
+          @rows << SpreadTableLine.new(:data, values, title: title)
+        end
+      else
+        @rows << SpreadTableLine.new(:data, line, line_options)
+      end
+      set_line_type(:header, @options[:header], false)
+      set_line_type(:total, @options[:total], false)
+      calc_data_size
+    end
+    def set_line_type(line_type, position = nil, recalc = true)
+      return if line_type.nil? || position.nil?
+      return unless SpreadTableLine::LINE_TYPES[line_type]
+      case position
+      when :first, :top
+        @rows.first.set_line_type(line_type, @options_for_line)
+      when :last, :bottom
+        @rows.last.set_line_type(line_type, @options_for_line)
+      else
+        row = get_row(position)
+        if row
+          @rows[pos].set_line_type(line_type, @options_for_line)
+        end
+      end
+      calc_data_size if recalc
+    end
+    def add_line(line_type = :data, line = [], line_options = {})
+      @rows << SpreadTableLine.new(line_type, line, line_options)
+      calc_data_size
+    end
+    def get_row(position)
+      if position.is_a?(Symbol)
+        if position == :last
+          @rows.last
+        else
+          @rows.first
+        end
+      else
+        pos = position.to_i
+        @rows[pos] if pos >= 0 && pos < @rows.size - 1
+      end
+    end
+    alias :line :get_row
+    def total_height
+      @rows.size
+    end
+    def calc_data_size
+      @total_width = 0
+      @data_width = 0
+      @data_height = 0
+      @rows.each do |row|
+        w = row.data_width
+        @total_width = w if @total_width < w
+        next if row.line_type != :data
+        @data_width = w if @data_width < w
+        @data_height += 1
+      end
+      @total_width += 1 # Including title column
+      self
+    end
+    def set_cell_class(callback)
+      return unless callback
+      each_data_line do |line|
+        line.set_cell_class(callback)
+      end
+    end
+    def set_line_class(klass)
+      return unless klass
+      each do |line|
+        line.set_line_class(klass)
+      end
+    end
+    def set_cell_callback(callback)
+      return if callback.nil? || !callback.is_a?(Method)
+      each_non_header_line do |line|
+        line.set_cell_callback(callback)
+      end
+    end
+    def each
+      @rows.each do |row|
+        yield row
+      end
+    end
+    def each_data_line
+      @rows.each do |row|
+        next if row.line_type != :data
+        yield row
+      end
+    end
+    def each_header_line
+      @rows.each do |row|
+        next if row.line_type == :data
+        yield row
+      end
+    end
+    def each_non_header_line
+      @rows.each do |row|
+        next if row.line_type == :header
+        yield row
+      end
+    end
+    def to_s
+      @rows.each do |row|
+        puts row.to_s
+      end
+    end
+    def to_html(options = {})
+      line_end = options.delete(:line_end)
+      res = HtmlTag.new('table', options).open
+      res << "\n" if line_end == :cr
+      @rows.each do |row|
+        res << row.to_html(line_end: line_end)
+      end
+      res << "</table>\n"
+      res
+    end
+    # Bootstrap grid
+    def to_grid(framework = :bootstrap, widths = [], options = {})
+      res = ""
+      @rows.each do |row|
+        res << row.to_grid(framework, widths)
+      end
+      res
+    end
+  end
+end

data/lib/rubypivot/table.rb ADDED

@@ -0,0 +1,95 @@
+module Rubypivot
+# Create HTML table from array
+# having row (tr) and cell (td) attribute control
+# rubypivot main gem does not include this, maybe won't be using
+#
+class TableBuilder
+    attr_accessor :options
+    attr_reader :x_size, :y_size
+    def initialize(data_array, options = {})
+      raise StandardError, "Data source must be an two dimension array" if !data_array.is_a?(Array) || !data_array.first.is_a?(Array)
+      @options = options
+      @data_array = data_array
+      @attributes = []
+      @data_array.each do |line|
+        @attributes << [options[:tr_class]]
+      end
+      @x_size = @data_array.first.size
+      @y_size = @data_array.size
+    end
+    def build(options = {})
+      tr_classes(options[:tr_class]) if options[:tr_class]
+      res = open
+      @data_array.each_with_index do |line, y|
+        tr = HtmlTag.new("tr", class: @attributes[y][0])
+        res << tr.open
+        line.each_with_index do |td_data, x|
+          res << HtmlTag.new("td", class: @attributes[y][x + 1]).build{ td_data }
+        end
+        res << tr.close + "\n"
+      end
+      # res << "\n"
+      res << close
+      res
+    end
+    def open
+      res = HtmlTag.new('table', @options).open
+      res << "\n"
+      res
+    end
+    def close(options = {})
+      "</table>\n"
+    end
+    def range_check(y)
+      if y.is_a?(Symbol)
+        if y == :bottom
+          return @y_size - 1
+        else
+          return 0
+        end
+      end
+      raise StandardError, "Class set out of range: #{y} > #{@y_size}" if y > @y_size
+      y
+    end
+    def tr_class(klass, y)
+      return unless klass
+      y = range_check(y)
+      @attributes[y][0] = klass
+    end
+    def tr_classes(klass)
+      return unless klass
+      0.upto(@attributes.size - 1) do |y|
+        @attributes[y][0] = klass
+      end
+    end
+    def set_class(klass, y, x)
+      return unless klass
+      y = range_check(y)
+      raise StandardError, "Class set out of range: #{} > #{@x_size}" if x >= @x_size
+      @attributes[y][x + 1] = klass
+    end
+    def row_attributes(klass, y)
+      return unless klass
+      y = range_check(y)
+      1.upto(@x_size) do |pos|
+        @attributes[y][pos] = klass
+      end
+    end
+    def column_attributes(klass, x)
+      return unless klass
+      0.upto(@attributes.size - 1) do |y|
+        @attributes[y][x + 1] = klass
+      end
+    end
+  end
+end

data/lib/rubypivot/version.rb CHANGED

@@ -1,3 +1,3 @@
 module Rubypivot
-  VERSION = "0.0.1" # Pre-release
+  VERSION = "0.0.2"
 end

metadata CHANGED

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubypivot
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - hiro utsumi
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-28 00:00:00.000000000 Z
+date: 2021-01-01 00:00:00.000000000 Z
 dependencies: []
 description: Transforming a dataset or array of hashes into a spreadsheet-style array
 email:
@@ -26,12 +26,19 @@ files:
 - bin/console
 - bin/setup
 - examples/active_record_like.rb
+- examples/html_table.html
+- examples/html_tag.rb
 - examples/lookup.rb
 - examples/simple.rb
+- examples/spread_table.png
+- examples/spread_table.rb
 - lib/rubypivot.rb
+- lib/rubypivot/html_tag.rb
 - lib/rubypivot/pivot.rb
 - lib/rubypivot/pivot_column.rb
 - lib/rubypivot/pivot_row.rb
+- lib/rubypivot/spread_table.rb
+- lib/rubypivot/table.rb
 - lib/rubypivot/version.rb
 - rubypivot.gemspec
 homepage: https://github.com/gambldia/rubypivot