htot_conv 0.3.2 → 1.0.0

data/lib/htot_conv/generator/xlsx_type3.rb

@@ -1,85 +1,99 @@
-# frozen_string_literal: true
-require 'axlsx'
-
-require 'htot_conv/generator/base'
-
-module HTOTConv
-  module Generator
-    class XlsxType3 < XlsxBase
-      def self.option_help
-        {
-          :integrate_cells => {
-            :default => nil,
-            :pat => [:colspan, :rowspan, :both],
-            :desc => "integrate key cells (specify 'colspan', 'rowspan' or 'both')",
-          },
-        }
-      end
-
-      def output_to_worksheet(ws)
-        max_level = @data.max_level
-        max_value_length = @data.max_value_length
-
-        ws.add_row([
-          @data.key_header[0],
-          *(HTOTConv::Util.pad_array([@data.value_header[0]], max_level)),
-          *(HTOTConv::Util.pad_array(
-            (@data.value_header.length <= 1)? [] : @data.value_header.last(@data.value_header.length - 1),
-            [max_value_length - 1, 0].max)),
-        ], :style => Axlsx::STYLE_THIN_BORDER)
-        1.upto(max_level) do |col_idx|
-          edges = [:top, :bottom]
-          edges << :left if (col_idx <= 1)
-          edges << :right if (col_idx >= max_level)
-          ws.rows.last.cells[col_idx].style = ws.styles.add_style(
-            :border => { :style => :thin, :color => "00", :edges => edges })
-        end
-
-        @data.item.each_with_index do |item, item_index|
-          key_value_cell = Array.new(max_level + 1, nil)
-          key_value_cell[item.level - 1] = item.key
-          key_value_cell[item.level    ] = item.value[0]
-          rest_value_cell = HTOTConv::Util.pad_array(
-            (item.value.length <= 1)? [] : item.value.last(item.value.length - 1),
-            [max_value_length - 1, 0].max)
-
-          ws.add_row(key_value_cell.concat(rest_value_cell),
-                     :style => Axlsx::STYLE_THIN_BORDER)
-
-          0.upto(max_level) do |col_idx|
-            edges = []
-
-            edges << :left if (col_idx <= item.level)
-            edges << :right if ((col_idx < item.level) || (col_idx >= max_level))
-            edges << :top if ((col_idx > (item.level - 2)) || (item_index == 0))
-            edges << :bottom if ((col_idx > (item.level - 1)) || (item_index == @data.item.length - 1))
-            ws.rows.last.cells[col_idx].style = ws.styles.add_style(
-              :border => { :style => :thin, :color => "00", :edges => edges })
-          end
-        end
-
-        if [:colspan, :both].include?(@option[:integrate_cells])
-          if max_level > 1
-            ws.merge_cells(ws.rows[0].cells[1..(max_level)])
-          end
-          @data.item.each_with_index do |item, item_index|
-            if item.level < max_level
-              ws.merge_cells(ws.rows[item_index + 1].cells[(item.level..max_level)])
-            end
-          end
-        end
-        if [:rowspan, :both].include?(@option[:integrate_cells])
-          @data.item.each_with_index do |item, item_index|
-            cells = [ws.rows[item_index + 1].cells[item.level - 1]]
-            ((item_index + 1)..(@data.item.length - 1)).each do |i|
-              break if @data.item[i].level <= item.level
-              cells << ws.rows[i + 1].cells[item.level - 1]
-            end
-
-            ws.merge_cells(cells) if cells.length > 1
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'htot_conv/generator/base'
+
+module HTOTConv
+  module Generator
+    class XlsxType3 < XlsxBase
+      def self.option_help
+        {
+          :integrate_cells => {
+            :default => nil,
+            :pat => [:colspan, :rowspan, :both],
+            :desc => "integrate key cells (specify 'colspan', 'rowspan' or 'both')",
+          },
+        }
+      end
+
+      def output_to_worksheet(ws)
+        max_level = @data.max_level
+        max_value_length = @data.max_value_length
+        row_index = 0
+
+        [
+          @data.key_header[0],
+          *(HTOTConv::Util.pad_array([@data.value_header[0]], max_level)),
+          *(HTOTConv::Util.pad_array(
+            (@data.value_header.length <= 1)? [] : @data.value_header.last(@data.value_header.length - 1),
+            [max_value_length - 1, 0].max)),
+        ].each_with_index do |v, col_index|
+          ws.add_cell(row_index, col_index, v)
+          [:top, :bottom, :left, :right].each do |edge|
+            ws[row_index][col_index].change_border(edge, "thin")
+          end
+        end
+        1.upto(max_level) do |col_index|
+          edges = []
+          edges << :left unless (col_index <= 1)
+          edges << :right unless (col_index >= max_level)
+          edges.each do |edge|
+            ws[row_index][col_index].change_border(edge, nil)
+          end
+        end
+        row_index = row_index.succ
+
+        @data.item.each_with_index do |item, item_index|
+          key_value_cell = Array.new(max_level + 1, nil)
+          key_value_cell[item.level - 1] = item.key
+          key_value_cell[item.level    ] = item.value[0]
+          rest_value_cell = HTOTConv::Util.pad_array(
+            (item.value.length <= 1)? [] : item.value.last(item.value.length - 1),
+            [max_value_length - 1, 0].max)
+
+          key_value_cell.concat(rest_value_cell).each_with_index do |v, col_index|
+            ws.add_cell(row_index, col_index, v)
+            [:top, :bottom, :left, :right].each do |edge|
+              ws[row_index][col_index].change_border(edge, "thin")
+            end
+          end
+          0.upto(max_level) do |col_index|
+            edges = []
+            edges << :left unless (col_index <= item.level)
+            edges << :right unless ((col_index < item.level) || (col_index >= max_level))
+            edges << :top unless ((col_index > (item.level - 2)) || (item_index == 0))
+            edges << :bottom unless ((col_index > (item.level - 1)) || (item_index == @data.item.length - 1))
+            edges.each do |edge|
+              ws[row_index][col_index].change_border(edge, nil)
+            end
+          end
+          row_index = row_index.succ
+        end
+
+        if [:colspan, :both].include?(@option[:integrate_cells])
+          if max_level > 1
+            ws.merge_cells(0, 1, 0, max_level)
+          end
+          @data.item.each_with_index do |item, item_index|
+            if item.level < max_level
+              ws.merge_cells(item_index + 1, item.level, item_index + 1, max_level)
+            end
+          end
+        end
+        if [:rowspan, :both].include?(@option[:integrate_cells])
+          @data.item.each_with_index do |item, item_index|
+            min_row_index = item_index + 1
+            max_row_index = min_row_index
+            ((item_index + 1)..(@data.item.length - 1)).each do |i|
+              break if @data.item[i].level <= item.level
+              max_row_index = i + 1
+            end
+
+            unless min_row_index == max_row_index
+              ws.merge_cells(min_row_index, item.level - 1, max_row_index, item.level - 1)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/htot_conv/generator/xlsx_type4.rb

@@ -1,84 +1,109 @@
-# frozen_string_literal: true
-require 'axlsx'
-
-require 'htot_conv/generator/base'
-
-module HTOTConv
-  module Generator
-    class XlsxType4 < XlsxBase
-      def self.option_help
-        {
-          :integrate_cells => {
-            :default => nil,
-            :pat => [:colspan, :rowspan, :both],
-            :desc => "integrate key cells (specify 'colspan', 'rowspan' or 'both')",
-          },
-        }
-      end
-
-      def output_to_worksheet(ws)
-        max_level = @data.max_level
-        max_value_length = @data.max_value_length
-
-        ws.add_row(((1..max_level).map {|l| @data.key_header[l - 1] || nil }).concat(
-          HTOTConv::Util.pad_array(@data.value_header, max_value_length)),
-        :style => Axlsx::STYLE_THIN_BORDER)
-
-        rowspan_cells = Array.new(max_level) { [] }
-        @data.to_tree.descendants.each do |node|
-          if node.leaf?
-            item = node.item
-
-            key_cell = Array.new(max_level, nil)
-            [node].concat(node.ancestors.to_a).each do |c_node|
-              key_cell[c_node.item.level - 1] = c_node.item.key if c_node.item
-              break if c_node.prev
-            end
-
-            value_cell = HTOTConv::Util.pad_array(item.value, max_value_length)
-
-            ws.add_row(key_cell.concat(value_cell),
-                       :style => Axlsx::STYLE_THIN_BORDER)
-
-            node.ancestors.each_with_object([node]) do |c_node, descendants|
-              if (c_node.item && c_node.item.level)
-                edges = [:left, :right]
-                edges << :top unless (descendants.any? { |v| v.prev })
-                edges << :bottom unless (descendants.any? { |v| v.next })
-                ws.rows.last.cells[c_node.item.level - 1].style = ws.styles.add_style(
-                  :border => { :style => :thin, :color => "00", :edges => edges })
-              end
-              descendants.unshift(c_node)
-            end
-            (item.level..max_level).each do |level|
-              edges = [:top, :bottom]
-              edges << :left if (level == item.level)
-              edges << :right if (level == max_level)
-              ws.rows.last.cells[level - 1].style = ws.styles.add_style(
-                :border => { :style => :thin, :color => "00", :edges => edges })
-            end
-
-            if [:colspan, :both].include?(@option[:integrate_cells])
-              if item.level < max_level
-                ws.merge_cells(ws.rows.last.cells[((item.level - 1)..(max_level - 1))])
-              end
-            end
-
-            node.ancestors.each_with_object([node]) do |c_node, descendants|
-              rowspan_cells[c_node.item.level - 1] << ws.rows.last.cells[c_node.item.level - 1]
-              unless (descendants.any? { |v| v.next })
-                if [:rowspan, :both].include?(@option[:integrate_cells])
-                  if rowspan_cells[c_node.item.level - 1].length > 1
-                    ws.merge_cells(rowspan_cells[c_node.item.level - 1])
-                  end
-                end
-                rowspan_cells[c_node.item.level - 1].clear
-              end
-              descendants.unshift(c_node)
-            end
-          end
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'htot_conv/generator/base'
+
+module HTOTConv
+  module Generator
+    class XlsxType4 < XlsxBase
+      def self.option_help
+        {
+          :integrate_cells => {
+            :default => nil,
+            :pat => [:colspan, :rowspan, :both],
+            :desc => "integrate key cells (specify 'colspan', 'rowspan' or 'both')",
+          },
+        }
+      end
+
+      def output_to_worksheet(ws)
+        max_level = @data.max_level
+        max_value_length = @data.max_value_length
+        row_index = 0
+
+        ((1..max_level).map {|l| @data.key_header[l - 1] || nil }).concat(
+          HTOTConv::Util.pad_array(@data.value_header, max_value_length)
+        ).each_with_index do |v, col_index|
+          ws.add_cell(row_index, col_index, v)
+          [:top, :bottom, :left, :right].each do |edge|
+            ws[row_index][col_index].change_border(edge, "thin")
+          end
+        end
+        row_index = row_index.succ
+
+        rowspan_cells = Array.new(max_level) { [] }
+        @data.to_tree.descendants.each do |node|
+          if node.leaf?
+            item = node.item
+
+            key_cell = Array.new(max_level, nil)
+            [node].concat(node.ancestors.to_a).each do |c_node|
+              key_cell[c_node.item.level - 1] = c_node.item.key if c_node.item
+              break if c_node.prev
+            end
+
+            value_cell = HTOTConv::Util.pad_array(item.value, max_value_length)
+
+            key_cell.concat(value_cell).each_with_index do |v, col_index|
+              ws.add_cell(row_index, col_index, v)
+              [:top, :bottom, :left, :right].each do |edge|
+                ws[row_index][col_index].change_border(edge, "thin")
+              end
+            end
+
+            node.ancestors.each_with_object([node]) do |c_node, descendants|
+              if (c_node.item && c_node.item.level)
+                edges = []
+                edges << :top if (descendants.any? { |v| v.prev })
+                edges << :bottom if (descendants.any? { |v| v.next })
+                edges.each do |edge|
+                  ws[row_index][c_node.item.level - 1].change_border(edge, nil)
+                end
+              end
+              descendants.unshift(c_node)
+            end
+            (item.level..max_level).each do |level|
+              edges = []
+              edges << :left unless (level == item.level)
+              edges << :right unless (level == max_level)
+              edges.each do |edge|
+                ws[row_index][level - 1].change_border(edge, nil)
+              end
+            end
+
+            if [:colspan, :both].include?(@option[:integrate_cells])
+              if item.level < max_level
+                ws.merge_cells(row_index, item.level - 1, row_index, max_level - 1)
+              end
+            end
+
+            node.ancestors.each_with_object([node]) do |c_node, descendants|
+              rowspan_cells[c_node.item.level - 1] << [row_index, c_node.item.level - 1]
+              unless (descendants.any? { |v| v.next })
+                if [:rowspan, :both].include?(@option[:integrate_cells])
+                  if rowspan_cells[c_node.item.level - 1].length > 1
+                    ws.merge_cells(
+                      rowspan_cells[c_node.item.level - 1].map(&:first).min,
+                      rowspan_cells[c_node.item.level - 1].map(&:last).min,
+                      rowspan_cells[c_node.item.level - 1].map(&:first).max,
+                      rowspan_cells[c_node.item.level - 1].map(&:last).max,
+                    )
+                  end
+                end
+                rowspan_cells[c_node.item.level - 1].clear
+              end
+              descendants.unshift(c_node)
+            end
+
+            (max_level..(max_level + max_value_length - 1)).each do |col_index|
+              [:top, :bottom, :left, :right].each do |edge|
+                ws[row_index][col_index].change_border(edge, "thin")
+              end
+            end
+
+            row_index = row_index.succ
+          end
+        end
+      end
+    end
+  end
+end

data/lib/htot_conv/generator/xlsx_type5.rb

@@ -1,62 +1,75 @@
-# frozen_string_literal: true
-require 'axlsx'
-
-require 'htot_conv/generator/base'
-
-module HTOTConv
-  module Generator
-    class XlsxType5 < XlsxBase
-      def self.option_help
-        {
-          :integrate_cells => {
-            :default => nil,
-            :pat => [:colspan],
-            :desc => "integrate key cells (specify 'colspan')",
-          },
-        }
-      end
-
-      def output_to_worksheet(ws)
-        max_level = @data.max_level
-        max_value_length = @data.max_value_length
-
-        ws.add_row(((1..max_level).map {|l| @data.key_header[l - 1] || nil }).concat(
-          HTOTConv::Util.pad_array(@data.value_header, max_value_length)),
-        :style => Axlsx::STYLE_THIN_BORDER)
-
-        @data.to_tree.descendants.each do |node|
-          if node.leaf?
-            item = node.item
-
-            key_cell = Array.new(max_level, nil)
-            key_cell[node.item.level - 1] = item.key
-            node.ancestors.each do |ancestor|
-              key_cell[ancestor.item.level - 1] = ancestor.item.key if ancestor.item
-            end
-
-            value_cell = HTOTConv::Util.pad_array(item.value, max_value_length)
-
-            ws.add_row(key_cell.concat(value_cell),
-                       :style => Axlsx::STYLE_THIN_BORDER)
-
-            (item.level..max_level).each do |level|
-              edges = [:top, :bottom]
-              edges << :left if (level == item.level)
-              edges << :right if (level == max_level)
-              ws.rows.last.cells[level - 1].style = ws.styles.add_style(
-                :border => { :style => :thin, :color => "00", :edges => edges })
-            end
-
-            if [:colspan].include?(@option[:integrate_cells])
-              if item.level < max_level
-                ws.merge_cells(ws.rows.last.cells[((item.level - 1)..(max_level - 1))])
-              end
-            end
-          end
-        end
-
-        ws.auto_filter = "A1:#{ws.rows.last.cells[max_level + max_value_length - 1].r}"
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'htot_conv/generator/base'
+
+module HTOTConv
+  module Generator
+    class XlsxType5 < XlsxBase
+      def self.option_help
+        {
+          :integrate_cells => {
+            :default => nil,
+            :pat => [:colspan],
+            :desc => "integrate key cells (specify 'colspan')",
+          },
+        }
+      end
+
+      def output_to_worksheet(ws)
+        max_level = @data.max_level
+        max_value_length = @data.max_value_length
+        row_index = 0
+
+        ((1..max_level).map {|l| @data.key_header[l - 1] || nil }).concat(
+          HTOTConv::Util.pad_array(@data.value_header, max_value_length)
+        ).each_with_index do |v, col_index|
+          ws.add_cell(row_index, col_index, v)
+          [:top, :bottom, :left, :right].each do |edge|
+            ws[row_index][col_index].change_border(edge, "thin")
+          end
+        end
+        row_index = row_index.succ
+
+        @data.to_tree.descendants.each do |node|
+          if node.leaf?
+            item = node.item
+
+            key_cell = Array.new(max_level, nil)
+            key_cell[node.item.level - 1] = item.key
+            node.ancestors.each do |ancestor|
+              key_cell[ancestor.item.level - 1] = ancestor.item.key if ancestor.item
+            end
+
+            value_cell = HTOTConv::Util.pad_array(item.value, max_value_length)
+
+            key_cell.concat(value_cell).each_with_index do |v, col_index|
+              ws.add_cell(row_index, col_index, v)
+              [:top, :bottom, :left, :right].each do |edge|
+                ws[row_index][col_index].change_border(edge, "thin")
+              end
+            end
+
+            (item.level..max_level).each do |level|
+              edges = []
+              edges << :left unless (level == item.level)
+              edges << :right unless (level == max_level)
+              edges.each do |edge|
+                ws[row_index][level - 1].change_border(edge, nil)
+              end
+            end
+
+            if [:colspan].include?(@option[:integrate_cells])
+              if item.level < max_level
+                ws.merge_cells(row_index, item.level - 1, row_index, max_level - 1)
+              end
+            end
+            row_index = row_index.succ
+          end
+        end
+
+        ws.auto_filter ||= RubyXL::AutoFilter.new
+        ws.auto_filter.ref = RubyXL::Reference.new(0, row_index - 1, 0, max_level + max_value_length -1)
+      end
+    end
+  end
+end