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

rubypivot 0.0.1 → 0.0.2

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