maketable 0.1.0

data/lib/maketable/maketable.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "date"
+require "pp"
+
+module Maketable
+  class Maketable
+    def initialize(yamlfile, year)
+      @yamlfile = yamlfile
+      @yaml = YAML.load_file(@yamlfile)
+      raise InvalidYearError if year.nil?
+      raise InvalidYearError unless year.instance_of?(Integer)
+
+      @year = year
+      @year_str = @year.to_s
+
+      @hs = {}
+      @hs_items = {}
+      @hs_table = {}
+      @columns = []
+
+      @num_of_columns = @yaml.keys.size
+      @label_width = 2
+      @start_month = 4
+      @month_range_group = 1
+      @day_range_group = 3
+      @month_range = Order.get_month_range(@start_month, @month_range_group)
+      @day_range_array = Order.get_day_range_array(@day_range_group)
+      @month_range_x_index = 0
+    end
+
+    def show
+      pp @yaml
+    end
+
+    def analyze
+      analyze_level1
+      # item_sort
+      analyze_level2
+      @hs
+    end
+
+    def output_any(level, item)
+      indent = " " * level
+      if item.instance_of?(String)
+        puts "#{indent}#{item}"
+      elsif item.instance_of?(Array)
+        item.each do |x|
+          output_any(level + 1, x)
+        end
+      elsif item.instance_of?(Hash)
+        output_hash( level + 1, item)
+      else
+        item.output(level)
+      end
+    end
+
+    def output_hash(level, hash)
+      indent_k = " " * level
+      level_v = level + 1
+      indent_v = " " * level_v
+
+      hash.keys.each do |k|
+        puts "#{indent_k}#{k}"
+        output_any(level_v, hash[k])
+      end
+    end
+
+    def xhs_items_0
+      output_hash(0, @hs_items)
+    end
+ 
+    def next_dir( dir )
+      if dir == :v
+        :h
+      else
+        :v
+      end
+    end
+
+    def xhs_items_sub_v(v, h, output_hs, list)
+      puts "xhs_items_sub_v|v=#{v}|h=#{h}"
+      @v = v
+      @h = h
+      output_hs[@v] ||= {}
+
+      if list.instance_of?(String)
+        puts "xhs_items_sub_v|String"
+        output_hs[@v][@h] = list
+        global_position_update(@v, @h, :h)
+      elsif list.instance_of?(Array)
+        puts "xhs_items_sub_v|Array"
+        list.each do |item|
+          xhs_items_sub_h(@v, @h, output_hs, item)
+          global_position_update(v, h, :h)
+        end
+      elsif list == nil
+        puts "xhs_items_sub_v|Nil"
+        output_hs[@v][@h] = nil
+        global_position_update(@v, @h, :h)
+      else
+        puts "xhs_items_sub_v|Hash"
+        # Hashとみなす
+        list.keys.each do |key|
+          output_hs[@v][@h] = key
+          xhs_items_sub_h(@v, @h, output_hs, list[key] )
+          global_position_update(@v, @h, :h)
+        end
+      end
+    end
+
+    def xhs_items_sub_h(v, h, output_hs, list)
+      @v = v
+      @h = h
+      output_hs[@v] ||= {}
+
+      if list.instance_of?(String)
+        output_hs[@v][@h] = list
+        global_position_update(v, h, :v)
+      elsif list.instance_of?(Array)
+        list.each do |item|
+          xhs_items_sub_v(@v, @h, output_hs, item)
+          global_position_update(v, h, :v)
+        end
+      elsif list == nil
+        output_hs[@v][@h] = nil
+        global_position_update(v, h, :v)
+      else
+        # Hashとみなす
+        list.keys.each do |key|
+          output_hs[@v][@h] = nil
+          xhs_items_sub_h(@v, @h, output_hs, list[key] )
+          global_position_update(v, h, :v)
+        end
+      end
+    end
+
+    def global_position_update(v, h, dir)
+      if dir == :h
+        @h += 1
+        @v = v
+      else
+        @h = h
+        @v += 1
+      end
+    end
+
+    def xhs_items
+      v = 0
+      h = 0
+      @hs = {}
+      dir = :v
+      @v = v
+      @h = h
+      next_dir = next_dir(dir)
+
+      @yaml.keys.each do |key|
+        puts "xhs_items|key=#{key}"
+        @hs[@v] ||= {}
+        @hs[@v][@h] = key
+        puts "xhs_items|@hs[#{@v}][#{@h}]=#{ @hs[@v][@h] }"
+        if dir == :v
+          xhs_items_sub_v(@v, @h, @hs, @yaml[key] )
+        else
+          xhs_items_sub_h(@v, @h, @hs, @yaml[key] )
+        end
+        global_position_update(v, h, dir)
+      end
+
+      pp @hs
+    end
+
+    def analyze_2
+      puts "analyze_2"
+      @yaml.each do |k, v|
+        unless v
+          @hs[k] = []
+          @hs_items[k] = []
+          next
+        end
+        v.each do |str|
+          item = Item.new(str, @year_str)
+          #item.analyze
+          @hs_items[k] ||= []
+          @hs_items[k] << item
+        end
+        #@hs_items[k] = @hs_items[k].sort_by(&:date_head)
+      end
+    end
+
+    def analyze_level1
+      @yaml.each do |k, v|
+        unless v
+          @hs[k] = []
+          @hs_items[k] = []
+          next
+        end
+        v.each do |str|
+          item = Item.new(str, @year_str)
+          item.analyze
+          @hs_items[k] ||= []
+          @hs_items[k] << item
+        end
+        @hs_items[k] = @hs_items[k].sort_by(&:date_head)
+      end
+    end
+
+    def analyze_level2
+      @hs_items.each do |column, v|
+        if v.empty?
+          @hs_table[column] = {}
+          @hs_table[column][@month_range_x_index] = {}
+        else
+          v.each do |item|
+            Order.order(@month_range, @day_range_array, column, item, @hs_table)
+          end
+        end
+      end
+      @hs_table
+    end
+
+    def output(table_format = :trac_wiki)
+      ot = OutputTable.new(@month_range, @hs_table, @month_range_x_index, @year, @day_range_group)
+      max_row = ot.make_table
+      ot.output(max_row, table_format)
+    end
+  end
+end

data/lib/maketable/order.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module Maketable
+  class Order
+    @order_month = {
+      1 => {
+        1 => [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]],
+        2 => [[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]],
+        3 => [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
+        4 => [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
+      },
+      4 => {
+        1 => [[4, 5, 6,   7,   8, 9,   10, 11,   12,   1, 2, 3]],
+        2 => [[4, 5, 6,   7,   8, 9], [10, 11,   12,   1, 2, 3]],
+        3 => [[4, 5, 6,   7], [8, 9,   10, 11], [12,   1, 2, 3]],
+        4 => [[4, 5, 6], [7,   8, 9], [10, 11,   12], [1, 2, 3]]
+      }
+    }
+    @order_month_1 = {
+      1 => [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]],
+      2 => [[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]],
+      3 => [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]],
+      4 => [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]]
+    }
+    @order_month_4 = {
+      1 => [[4, 5, 6,   7,   8, 9,   10, 11,   12,   1, 2, 3]],
+      2 => [[4, 5, 6,   7,   8, 9], [10, 11,   12,   1, 2, 3]],
+      3 => [[4, 5, 6,   7], [8, 9,   10, 11], [12,   1, 2, 3]],
+      4 => [[4, 5, 6], [7,   8, 9], [10, 11,   12], [1, 2, 3]]
+    }
+
+    @order_month_a = {}
+
+    @order_day = {
+      1 => [[1, 31]],
+      2 => [[1, 15], [16, 31]],
+      3 => [[1, 10], [11, 20], [21, 31]],
+      4 => [[1, 8], [9, 16], [17, 24], [25, 31]],
+      5 => [[1, 6], [7, 12], [13, 18], [19, 24], [25, 31]]
+    }
+
+    @day_range_label = {
+      1 => { 0 => "" },
+      2 => { 0 => "上", 1 => "下" },
+      3 => { 0 => "上", 1 => "中", 2 => "下" },
+      4 => { 0 => "1", 1 => "2", 2 => "3", 3 => "4" },
+      5 => { 0 => "1", 1 => "2", 2 => "3", 3 => "4", 4 => "5" }
+    }
+
+    class << self
+      def make_month_order(year, start_month, max)
+        # datetime_hash = Util.make_datetime_hash(year, start_month, max)
+        date_hash = Util.make_date_hash(year, start_month, max)
+        # Util.make_month_order(@order_month, datetime_hash)
+        Util.make_month_order(@order_month, date_hash)
+      end
+
+      def make_month_order_1(year, max)
+        start_month = 1
+        # datetime_hash = Util.make_datetime_hash(year, start_month, max)
+        date_hash = Util.make_date_hash(year, start_month, max)
+        # Util.make_month_order(@order_month_1, datetime_hash)
+        Util.make_month_order(@order_month_1, date_hash)
+      end
+
+      def make_month_order_4(year, max)
+        start_month = 4
+        # datetime_hash = Util.make_datetime_hash(year, start_month, max)
+        date_hash = Util.make_date_hash(year, start_month, max)
+        # Util.make_month_order(@order_month_4, datetime_hash)
+        Util.make_month_order(@order_month_4, date_hash)
+      end
+
+      def make_month_order_a(year, max)
+        @order_month_a[1] = make_month_order_1(year, max)
+        @order_month_a[4] = make_month_order_4(year, max)
+        @order_month_a
+      end
+
+      def get_day_range_label(day_range, index)
+        @day_range_label[day_range][index]
+      end
+
+      def month_range_index(range_array, target)
+        range_array.index { |v| v.include?(target) }
+      end
+
+      def month_range_index_a(range_array, target)
+        range_array.index { |v| v.include?(target) }
+      end
+
+      def day_range_index(range_array, target)
+        range_array.index { |v| v.first <= target && v.last >= target }
+      end
+
+      def get_month_range(start_month, month_range_group)
+        @order_month[start_month][month_range_group]
+      end
+
+      def get_day_range_array(day_range_group)
+        @order_day[day_range_group]
+      end
+
+      def order(month_range, day_range_array, column, item, hs_table)
+        # month = item.datetime_head.month
+        month = item.date_head.month
+        # day = item.datetime_head.day
+        day = item.date_head.day
+
+        m_r_index = month_range_index(month_range, month)
+        d_r_index = day_range_index(day_range_array, day)
+
+        hs_table[column] ||= {}
+        hs_table[column][m_r_index] ||= {}
+        hs_table[column][m_r_index][month] ||= {}
+        hs_table[column][m_r_index][month][d_r_index] ||= []
+        hs_table[column][m_r_index][month][d_r_index] << item
+      end
+
+      def make_table_row_label(start_month)
+        start_day = "#{start_month}/1"
+        @order_month[1][1][0].each_with_object([]) do |_x, list|
+          list << if list.empty?
+                    item = Item.new(start_day, @year)
+                    item.analyze
+                    item
+                  else
+                    list.last.make_next_month_item
+                  end
+        end
+      end
+    end
+  end
+end

data/lib/maketable/outputtable.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Maketable
+  class OutputTable
+    def initialize(month_range, hs_table, month_range_x_index, year, day_range_group)
+      @row_index = 0
+      @col_index = 0
+      @max_row_index = 0
+
+      @month_range = month_range
+      @hs_table = hs_table
+      @tc_ary = []
+      @month_range_x_index = month_range_x_index
+      @year = year
+      @day_range_group = day_range_group
+
+      @label_width = 2
+      @width = @hs_table.keys.size + @label_width
+      @output_table = Array.new(@width) { [] }
+
+      @hs_table.keys.each_with_index do |column, index|
+        @tc_ary << TableColumn.new(index, column, @hs_table[column][@month_range_x_index], @month_range)
+      end
+    end
+
+    def make_table
+      @months_of_year = 12
+      @month_index_conv = { 4 => 4, 5 => 5, 6 => 6, 7 => 7, 8 => 8, 9 => 9, 10 => 10, 11 => 11, 12 => 12, 13 => 1,
+                            14 => 2, 15 => 3 }
+
+      output_pad = 2
+
+      @month_first = 4
+      @month_last = 3
+      @day_range_first = 0
+      @day_range_last = 2
+
+      @tc_first = 0
+      @tc_last = (@tc_ary.size - 1)
+
+      @label_item_list = Order.make_table_row_label(@month_first)
+      start_row = 0
+      make_output_table_header(output_pad, start_row)
+      start_row = 2
+      make_output_table(output_pad, start_row)
+    end
+
+    def make_output_table_header(output_pad, start_row)
+      # byebug
+      max_row = 0
+      @tc_first.upto(@tc_last) do |tc_index|
+        output_column_index = tc_index + output_pad
+        next_row = start_row
+        next_row = @tc_ary[tc_index].output_key(@output_table[output_column_index], next_row)
+        max_row = next_row if max_row < next_row
+      end
+      max_row
+    end
+
+    def make_table_row_label(start_row, month_index, day_range_index)
+      index = month_index - @month_first
+      item = @label_item_list[index]
+      date = item.date_head
+      content = if day_range_index == 0
+                  %(#{date.year}-#{date.month})
+                else
+                  ""
+                end
+      @output_table[0][start_row] = content
+    end
+
+    def make_output_table(output_pad, start_row)
+      max_row = 0
+      tc_start_row = start_row
+
+      @month_first.upto(@month_first + @months_of_year - 1) do |m_index|
+        month_index = @month_index_conv[m_index]
+        @day_range_first.upto(@day_range_last) do |day_range_index|
+          make_table_row_label(tc_start_row, m_index, day_range_index)
+          @tc_first.upto(@tc_last) do |tc_index|
+            output_column_index = tc_index + output_pad
+            next_row = tc_start_row
+            tc = @tc_ary[tc_index]
+            next_row = tc.output(@output_table[output_column_index], next_row, month_index, day_range_index)
+            max_row = next_row if max_row < next_row
+          end
+          tc_start_row = max_row
+        end
+      end
+      max_row
+    end
+
+    def make_table_format(head_flag:, data:, format: :trac_wiki)
+      lines = []
+      case format
+      when :trac_wiki
+        lines << %(|| #{data.join(" || ")} ||)
+      when :markdown
+        lines << %(| #{data.join(" | ")} |)
+        if head_flag
+          data.size
+          lines << %(|#{Array.new(data.size) { "-" }.join("|")}|)
+        end
+      else
+        raise InvalidFormatError
+      end
+      lines
+    end
+
+    def output(max_row, table_format)
+      lineno = 0
+      lines = []
+      0.upto(max_row - 1) do |j|
+        ary = []
+        0.upto(@width - 1) do |i|
+          ary << if @output_table[i]
+                   @output_table[i][j] || ""
+                 else
+                   ""
+                 end
+        end
+        lines = make_table_format(head_flag: (lineno == 0), data: ary, format: table_format)
+        lines.map { |l| puts l }
+        lineno += 1
+      end
+    end
+  end
+end

data/lib/maketable/table.rb

@@ -0,0 +1,9 @@
+module Maketable
+  class Table
+    def initialize(start_dir)
+      @axi = {}
+      @start_dir = start_dir
+      @cur_dir = @start_dir
+    end
+  end
+end

data/lib/maketable/tablecolumn.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Maketable
+  class TableColumn
+    def initialize(column_index, key, data_hs, month_range)
+      @column_index = column_index
+      @key = key
+      @data_hs = data_hs
+      @month_range = month_range
+    end
+
+    def show
+      pp @month_range
+      pp @column_index
+      pp @key
+      pp @data_hs
+    end
+
+    def output_key(output_hs, output_row)
+      lh, sep, rh = @key.partition("//")
+      if sep == ""
+        output_hs[output_row] = @key
+      else
+        output_hs[output_row] = lh
+        output_row += 1
+        output_hs[output_row] = rh
+      end
+      output_row += 1
+      output_row
+    end
+
+    def output(output_hs, start_row, month_index, day_range_index)
+      output_row = start_row
+      if @data_hs
+        m_info = @data_hs[month_index]
+        if m_info && m_info[day_range_index] && !m_info[day_range_index].empty?
+          m_info[day_range_index].each do |item|
+            output_hs[output_row] = item.desc_str
+            output_row += 1
+          end
+        end
+      end
+      if output_row == start_row
+        output_hs[output_row] = ""
+        output_row += 1
+      end
+      output_row
+    end
+  end
+end

data/lib/maketable/util.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Maketable
+  class Util
+    class << self
+      def make_date_list(year, month, max = 12)
+        @dt_list = []
+        dt = nil
+        month.upto(month + max - 1) do |x|
+          dt = if dt
+                 dt.next_month
+               else
+                 Date.new(year, x)
+               end
+          @dt_list << dt
+        end
+        @dt_list
+      end
+
+      def convert_index(month)
+        month -= 12 if month > 12
+        month
+      end
+
+      def make_date_hash(year, month, max = 12)
+        @dt_hash = {}
+        dt = nil
+        month.upto(month + max - 1) do |x|
+          dt = if dt
+                 dt.next_month
+               else
+                 Date.new(year, x)
+               end
+          y = convert_index(x)
+          @dt_hash[y] = dt
+        end
+        @dt_hash
+      end
+
+      def make_month_order(src, date_hash)
+        if src.instance_of?(Hash)
+          dest_hash = {}
+          src.each do |k, v|
+            dest_hash[k] = make_month_order(v, date_hash)
+          end
+          dest_hash
+        elsif src.instance_of?(Array)
+          dest_array = []
+          src.each do |v|
+            dest_array << make_month_order(v, date_hash)
+          end
+          dest_array
+        elsif src.instance_of?(Integer)
+          date_hash[src]
+        else
+          raise InvalidObjectError
+        end
+      end
+    end
+  end
+end

data/lib/maketable/utilx.rb

@@ -0,0 +1,19 @@
+module Maketable
+  class Utilx
+    class << self
+      def make_table_format(data:, format: :trac_wiki)
+        lines = []
+        case format
+        when :trac_wiki
+          line = %(|| #{data.join(" || ")} ||)
+          lines << line
+        when :markdown
+          lines << %(| #{data.join(" | ")} |)
+        else
+          raise InvalidFormatError
+        end
+        lines
+      end
+    end
+  end
+end

data/lib/maketable/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Maketable
+  VERSION = "0.1.0"
+end

data/lib/maketable.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative "maketable/version"
+require_relative "maketable/item"
+require_relative "maketable/order"
+require_relative "maketable/maketable"
+require_relative "maketable/outputtable"
+require_relative "maketable/tablecolumn"
+require_relative "maketable/util"
+require_relative "maketable/limitedmarkdown"
+require_relative "maketable/utilx"
+#require_relative "maketable/itemx"
+
+require "pathname"
+require "byebug"
+module Maketable
+  TEST_DATA_DIR = Pathname.new(__dir__).parent + "test_data"
+
+  class Error < StandardError; end
+  class InvalidYearError < Error; end
+  class InvalidObjectError < Error; end
+  class InvalidFormatError < Error; end
+  class InvalidLevelChangeError < Error; end
+  class NoParentItemxError < Error; end
+  class InvalidParentLevelError < Error; end
+  # Your code goes here...
+end

data/sig/maketable.rbs

@@ -0,0 +1,4 @@
+module Maketable
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end