htot_conv 0.3.2 → 1.0.0

data/lib/htot_conv/generator.rb

@@ -1,30 +1,30 @@
-# frozen_string_literal: true
-require 'htot_conv/generator/xlsx_type0.rb'
-require 'htot_conv/generator/xlsx_type1.rb'
-require 'htot_conv/generator/xlsx_type2.rb'
-require 'htot_conv/generator/xlsx_type3.rb'
-require 'htot_conv/generator/xlsx_type4.rb'
-require 'htot_conv/generator/xlsx_type5.rb'
-
-require 'rinne'
-
-module HTOTConv
-  module Generator
-    def create(type, *args)
-      klass = HTOTConv::Generator.const_get(Rinne.camelize(type.to_s))
-      klass.new(*args)
-    end
-    module_function :create
-
-    def types
-      HTOTConv::Generator.constants.reject { |klass|
-        klass =~ /Base$/
-      }.select { |klass|
-        HTOTConv::Generator.const_get(klass).kind_of?(Class)
-      }.map { |klass|
-        Rinne.to_snake(klass.to_s).to_sym
-      }
-    end
-    module_function :types
-  end
-end
+# frozen_string_literal: true
+require 'htot_conv/generator/xlsx_type0.rb'
+require 'htot_conv/generator/xlsx_type1.rb'
+require 'htot_conv/generator/xlsx_type2.rb'
+require 'htot_conv/generator/xlsx_type3.rb'
+require 'htot_conv/generator/xlsx_type4.rb'
+require 'htot_conv/generator/xlsx_type5.rb'
+
+require 'rinne'
+
+module HTOTConv
+  module Generator
+    def create(type, *args)
+      klass = HTOTConv::Generator.const_get(Rinne.camelize(type.to_s))
+      klass.new(*args)
+    end
+    module_function :create
+
+    def types
+      HTOTConv::Generator.constants.reject { |klass|
+        klass =~ /Base$/
+      }.select { |klass|
+        HTOTConv::Generator.const_get(klass).kind_of?(Class)
+      }.map { |klass|
+        Rinne.to_snake(klass.to_s).to_sym
+      }
+    end
+    module_function :types
+  end
+end

data/lib/htot_conv/generator/base.rb

@@ -1,35 +1,34 @@
-# frozen_string_literal: true
-module HTOTConv
-  module Generator
-    class Base
-      def initialize(data, option={})
-        data.validate
-        @data = data
-        @option = self.class.option_help.inject({}) { |h, pair| h[pair[0]] = pair[1][:default]; h}.merge(option)
-      end
-      def self.option_help
-        {}
-      end
-
-      def output(outputfile)
-        raise NotImplementedError.new("#{self.class.name}.#{__method__} is an abstract method.")
-      end
-    end
-
-    class XlsxBase < Base
-      def output_to_worksheet(ws)
-        raise NotImplementedError.new("#{self.class.name}.#{__method__} is an abstract method.")
-      end
-
-      def output(outputfile)
-        p = Axlsx::Package.new
-        p.workbook do |wb|
-          wb.add_worksheet do |ws|
-            output_to_worksheet(ws)
-          end
-        end
-        p.serialize(outputfile)
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'rubyXL'
+
+module HTOTConv
+  module Generator
+    class Base
+      def initialize(data, option={})
+        data.validate
+        @data = data
+        @option = self.class.option_help.inject({}) { |h, pair| h[pair[0]] = pair[1][:default]; h}.merge(option)
+      end
+      def self.option_help
+        {}
+      end
+
+      def output(outputfile)
+        raise NotImplementedError.new("#{self.class.name}.#{__method__} is an abstract method.")
+      end
+    end
+
+    class XlsxBase < Base
+      def output_to_worksheet(ws)
+        raise NotImplementedError.new("#{self.class.name}.#{__method__} is an abstract method.")
+      end
+
+      def output(outputfile)
+        wb = RubyXL::Workbook.new
+        output_to_worksheet(wb[0])
+        wb.write(outputfile)
+      end
+    end
+  end
+end

data/lib/htot_conv/generator/xlsx_type0.rb

@@ -1,24 +1,36 @@
-# frozen_string_literal: true
-require 'axlsx'
-
-require 'htot_conv/generator/base'
-
-module HTOTConv
-  module Generator
-    class XlsxType0 < XlsxBase
-      def output_to_worksheet(ws)
-        max_value_length = @data.max_value_length
-
-        ws.add_row([@data.key_header[0], 'Outline Level'].concat(
-          HTOTConv::Util.pad_array(@data.value_header, max_value_length)),
-        :style => Axlsx::STYLE_THIN_BORDER)
-
-        @data.item.each do |item|
-          ws.add_row([item.key, item.level.to_i].concat(
-            HTOTConv::Util.pad_array(item.value, max_value_length)),
-          :style => Axlsx::STYLE_THIN_BORDER)
-        end
-      end
-    end
-  end
-end
+# frozen_string_literal: true
+
+require 'htot_conv/generator/base'
+
+module HTOTConv
+  module Generator
+    class XlsxType0 < XlsxBase
+      def output_to_worksheet(ws)
+        row_index = 0
+        max_value_length = @data.max_value_length
+
+        [@data.key_header[0], 'Outline Level'].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.item.each do |item|
+          [item.key, item.level.to_i].concat(
+            HTOTConv::Util.pad_array(item.value, 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
+        end
+      end
+    end
+  end
+end

data/lib/htot_conv/generator/xlsx_type1.rb

@@ -1,69 +1,57 @@
-# frozen_string_literal: true
-
-require 'axlsx'
-
-require 'htot_conv/generator/base'
-
-module HTOTConv
-  module Generator
-    class XlsxType1 < XlsxBase
-      def self.option_help
-        {
-          :outline_rows => {
-            :default => false,
-            :pat => FalseClass,
-            :desc => "group rows (default: no)",
-          },
-        }
-      end
-
-      def output_to_worksheet(ws)
-        max_value_length = @data.max_value_length
-
-        ws.add_row([@data.key_header[0]].concat(
-          HTOTConv::Util.pad_array(@data.value_header, max_value_length)),
-        :style => Axlsx::STYLE_THIN_BORDER)
-
-        @data.item.each do |item|
-          ws.add_row([item.key].concat(
-            HTOTConv::Util.pad_array(item.value, max_value_length)),
-          :style => Axlsx::STYLE_THIN_BORDER)
-        end
-
-        if @option[:outline_rows]
-          max_level = @data.max_level
-          outline_begin = Array.new(max_level, nil)
-          dummy_end_item = HTOTConv::Outline::Item.new(nil, 1, nil)
-          @data.item.concat([dummy_end_item]).each_with_index do |item, item_index|
-            (item.level..max_level).each do |level|
-              if outline_begin[level - 1]
-                if outline_begin[level - 1] < item_index - 1
-                  ws.outline_level_rows((outline_begin[level - 1] + 1) + 1, (item_index - 1) + 1, level, false)
-                end
-                outline_begin[level - 1] = nil
-              end
-            end
-            outline_begin[item.level - 1] = item_index
-          end
-
-          # PR randym/axlsx#440 has been added to master branch
-          # https://github.com/randym/axlsx/commit/c80c8b9d9be5542471d66afcc2ce4ddd80cac1f7
-          # but latest release on rubygems does not contain this.
-          # So apply monkey patch to ws.sheet_pr.
-          if defined? ws.sheet_pr.outline_pr
-            ws.sheet_pr.outline_pr.summary_below = false
-          else
-            class << ws.sheet_pr # monkey patch
-              def to_xml_string(str="".dup)
-                tmp_str = "".dup
-                super(tmp_str)
-                str << tmp_str.sub('<pageSetUpPr', '<outlinePr summaryBelow="0" /><pageSetUpPr')
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
+# frozen_string_literal: true
+
+require 'htot_conv/generator/base'
+
+module HTOTConv
+  module Generator
+    class XlsxType1 < XlsxBase
+      def self.option_help
+        {
+          :outline_rows => {
+            :default => false,
+            :pat => FalseClass,
+            :desc => "group rows (default: no)",
+          },
+        }
+      end
+
+      def output_to_worksheet(ws)
+        row_index = 0
+        max_value_length = @data.max_value_length
+
+        [@data.key_header[0]].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.item.each do |item|
+          ([item.key].concat(
+            HTOTConv::Util.pad_array(item.value, 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
+        end
+
+        if @option[:outline_rows]
+          @data.item.each_with_index do |item, item_index|
+            ws[item_index + 1].outline_level = (item.level > 1)? (item.level - 1) : nil
+          end
+
+          ws.sheet_pr ||= RubyXL::WorksheetProperties.new
+          ws.sheet_pr.outline_pr ||= RubyXL::OutlineProperties.new
+          ws.sheet_pr.outline_pr.summary_below = false
+        end
+      end
+    end
+  end
+end
+

data/lib/htot_conv/generator/xlsx_type2.rb

@@ -1,104 +1,100 @@
-# frozen_string_literal: true
-require 'axlsx'
-
-require 'htot_conv/generator/base'
-
-module HTOTConv
-  module Generator
-    class XlsxType2 < XlsxBase
-      def self.option_help
-        {
-          :integrate_cells => {
-            :default => nil,
-            :pat => [:colspan, :rowspan],
-            :desc => "integrate key cells (specify 'colspan' or 'rowspan')",
-          },
-          :outline_rows => {
-            :default => false,
-            :pat => FalseClass,
-            :desc => "group rows (default: no)",
-          },
-        }
-      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.item.each_with_index do |item, item_index|
-          key_cell = Array.new(max_level, nil)
-          key_cell[item.level - 1] = item.key
-          value_cell = HTOTConv::Util.pad_array(item.value, max_value_length)
-
-          ws.add_row(key_cell.concat(value_cell),
-                     :style => Axlsx::STYLE_THIN_BORDER)
-
-          (1..max_level).each do |level|
-            edges = []
-            edges << :left if (level <= item.level)
-            edges << :right if ((level < item.level) || (level == max_level))
-            edges << :top if ((level >= item.level) || (item_index == 0))
-            edges << :bottom if ((level > item.level) || (item_index == @data.item.length - 1))
-            ws.rows.last.cells[level - 1].style = ws.styles.add_style(
-              :border => { :style => :thin, :color => "00", :edges => edges })
-          end
-        end
-
-        if @option[:outline_rows]
-          outline_begin = Array.new(max_level, nil)
-          dummy_end_item = HTOTConv::Outline::Item.new(nil, 1, nil)
-          @data.item.concat([dummy_end_item]).each_with_index do |item, item_index|
-            (item.level..max_level).each do |level|
-              if outline_begin[level - 1]
-                if outline_begin[level - 1] < item_index - 1
-                  ws.outline_level_rows((outline_begin[level - 1] + 1) + 1, (item_index - 1) + 1, level, false)
-                end
-                outline_begin[level - 1] = nil
-              end
-            end
-            outline_begin[item.level - 1] = item_index
-          end
-
-          # PR randym/axlsx#440 has been added to master branch
-          # https://github.com/randym/axlsx/commit/c80c8b9d9be5542471d66afcc2ce4ddd80cac1f7
-          # but latest release on rubygems does not contain this.
-          # So apply monkey patch to ws.sheet_pr.
-          if defined? ws.sheet_pr.outline_pr
-            ws.sheet_pr.outline_pr.summary_below = false
-          else
-            class << ws.sheet_pr # monkey patch
-              def to_xml_string(str="".dup)
-                tmp_str = "".dup
-                super(tmp_str)
-                str << tmp_str.sub('<pageSetUpPr', '<outlinePr summaryBelow="0" /><pageSetUpPr')
-              end
-            end
-          end
-        end
-
-        case @option[:integrate_cells]
-        when :colspan
-          @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 - 1)..(max_level - 1))])
-            end
-          end
-        when :rowspan
-          @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 XlsxType2 < XlsxBase
+      def self.option_help
+        {
+          :integrate_cells => {
+            :default => nil,
+            :pat => [:colspan, :rowspan],
+            :desc => "integrate key cells (specify 'colspan' or 'rowspan')",
+          },
+          :outline_rows => {
+            :default => false,
+            :pat => FalseClass,
+            :desc => "group rows (default: no)",
+          },
+        }
+      end
+
+      def output_to_worksheet(ws)
+        row_index = 0
+        max_level = @data.max_level
+        max_value_length = @data.max_value_length
+
+        (((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.item.each_with_index do |item, item_index|
+          key_cell = Array.new(max_level, nil)
+          key_cell[item.level - 1] = item.key
+          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)
+            if col_index >= max_level
+              [:top, :bottom, :left, :right].each do |edge|
+                ws[row_index][col_index].change_border(edge, "thin")
+              end
+            end
+          end
+
+          (1..max_level).each do |level|
+            edges = []
+            edges << :left if (level <= item.level)
+            edges << :right if ((level < item.level) || (level == max_level))
+            edges << :top if ((level >= item.level) || (item_index == 0))
+            edges << :bottom if ((level > item.level) || (item_index == @data.item.length - 1))
+            edges.each do |edge|
+              ws[row_index][level - 1].change_border(edge, "thin")
+            end
+          end
+
+          row_index = row_index.succ
+        end
+
+        if @option[:outline_rows]
+          @data.item.each_with_index do |item, item_index|
+            ws[item_index + 1].outline_level = (item.level > 1)? (item.level - 1) : nil
+          end
+
+          ws.sheet_pr ||= RubyXL::WorksheetProperties.new
+          ws.sheet_pr.outline_pr ||= RubyXL::OutlineProperties.new
+          ws.sheet_pr.outline_pr.summary_below = false
+        end
+
+        case @option[:integrate_cells]
+        when :colspan
+          @data.item.each_with_index do |item, item_index|
+            if item.level < max_level
+              ws.merge_cells(item_index + 1, item.level - 1, item_index + 1, max_level - 1)
+            end
+          end
+        when :rowspan
+          @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