zakuro 0.6.0 → 0.6.1

data/lib/zakuro/calculation/summary/range.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require_relative '../specifier/multiple_day'
+
+require_relative '../range/operated_range'
+
+require_relative '../range/full_range'
+
+require_relative './internal/operation'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Summary
+      #
+      # Range 期間
+      #
+      module Range
+        #
+        # 生成する
+        #
+        # @param [Context] context 暦コンテキスト
+        # @param [Western::Calendar] start_date 西暦開始日
+        # @param [Western::Calendar] last_date 西暦終了日
+        #
+        # @return [Result::Range] 期間検索結果（和暦日）
+        #
+        def self.get(context:, start_date: Western::Calendar.new, last_date: Western::Calendar.new)
+          years = get_full_range_years(
+            context: context, start_date: start_date, last_date: last_date
+          )
+          operated_years = get_operated_range_years(
+            context: context, years: years, start_date: start_date, last_date: last_date
+          )
+
+          dates = Specifier::MultipleDay.get(
+            years: years, start_date: start_date, last_date: last_date
+          )
+
+          operated_dates = Specifier::MultipleDay.get(
+            years: operated_years, start_date: start_date, last_date: last_date
+          )
+
+          list = create_result_list(dates: dates, operated_dates: operated_dates)
+
+          Result::Range.new(list: list)
+        end
+
+        #
+        # 完全範囲を取得する
+        #
+        # @param [Context] context 暦コンテキスト
+        # @param [Western::Calendar] start_date 西暦開始日
+        # @param [Western::Calendar] last_date 西暦終了日
+        #
+        # @return [Array<Base::Year>] 完全範囲
+        #
+        def self.get_full_range_years(context:, start_date: Western::Calendar.new,
+                                      last_date: Western::Calendar.new)
+          full_range = Calculation::Range::FullRange.new(
+            context: context, start_date: start_date, last_date: last_date
+          )
+          full_range.get
+        end
+        private_class_method :get_full_range_years
+
+        #
+        # 運用結果範囲を取得する
+        #
+        # @param [Context] context 暦コンテキスト
+        # @param [Western::Calendar] start_date 西暦開始日
+        # @param [Western::Calendar] last_date 西暦終了日
+        # @param [Western::Calendar] date 西暦日
+        #
+        # @return [Array<Base::OperatedYear>] 運用結果範囲
+        #
+        def self.get_operated_range_years(context:, years:, start_date: Western::Calendar.new,
+                                          last_date: Western::Calendar.new)
+          operated_range = Calculation::Range::OperatedRange.new(
+            context: context, start_date: start_date, last_date: last_date, years: years
+          )
+          operated_range.get
+        end
+        private_class_method :get_operated_range_years
+
+        #
+        # 結果リストを生成する
+        #
+        # @param [Array<Result::Data::SingleDay>] dates 検索結果（計算値）
+        # @param [Array<Result::Data::SingleDay>] operated_dates 検索結果（運用値）
+        #
+        # @return [Array<Result::Single>] 結果リスト
+        #
+        def self.create_result_list(dates:, operated_dates:)
+          result = []
+
+          return result if dates.size != operated_dates.size
+
+          (0..(dates.size - 1)).each do |index|
+            data = operated_dates[index]
+
+            date = dates[index]
+            operation = Operation.create(calc_date: date)
+
+            result.push(
+              Result::Single.new(
+                data: data,
+                operation: operation
+              )
+            )
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/zakuro/calculation/summary/single.rb

@@ -6,6 +6,8 @@ require_relative '../range/operated_range'
 
 require_relative '../range/full_range'
 
+require_relative './internal/operation'
+
 # :nodoc:
 module Zakuro
   # :nodoc:
@@ -25,107 +27,83 @@ module Zakuro
         # @return [Result::Single] 一日検索結果（和暦日）
         #
         def self.get(context:, date: Western::Calendar.new)
-          full_range = Calculation::Range::FullRange.new(context: context, start_date: date)
-          years = full_range.get
+          years = get_full_range_years(context: context, date: date)
 
-          calc_date = Calculation::Specifier::SingleDay.get(
-            years: years, date: date
-          )
+          data = get_data(context: context, years: years, date: date)
 
-          operated_range = Calculation::Range::OperatedRange.new(
-            context: context, start_date: date, years: years
-          )
-          operated_years = operated_range.get
+          operation = get_operation(years: years, date: date)
 
           Result::Single.new(
-            data: Calculation::Specifier::SingleDay.get(
-              years: operated_years, date: date
-            ),
-            operation: create_operation(calc_date: calc_date)
+            data: data,
+            operation: operation
           )
         end
 
         #
-        # 運用情報を生成する
+        # 完全範囲を取得する
         #
-        # @param [Result::Data::SingleDay] calc_date 和暦日（計算値）
+        # @param [Context] context 暦コンテキスト
+        # @param [Western::Calendar] date 西暦日
         #
-        # @return [Result::Operation::Bundle] 運用情報
+        # @return [Array<Base::Year>] 完全範囲
         #
-        def self.create_operation(calc_date: Result::Data::SingleDay.new)
-          first_day = calc_date.month.first_day.western_date
-          operation_history = Operation.specify_history(western_date: first_day)
-
-          operation_month = create_operation_month(operation_history: operation_history)
-
-          Result::Operation::Bundle.new(
-            operated: !operation_history.invalid?, month: operation_month, original: calc_date
-          )
+        def self.get_full_range_years(context:, date: Western::Calendar.new)
+          full_range = Calculation::Range::FullRange.new(context: context, start_date: date)
+          full_range.get
         end
-        private_class_method :create_operation
+        private_class_method :get_full_range_years
 
         #
-        # 月履歴集約情報を生成する
+        # 運用結果範囲を取得する
         #
-        # @param [Operation::MonthHistory] operation_history 変更履歴（月）
+        # @param [Context] context 暦コンテキスト
+        # @param [Array<Base::Year>] years 完全範囲
+        # @param [Western::Calendar] date 西暦日
         #
-        # @return [Result::Operation::Month::Bundle] 月履歴集約情報
+        # @return [Array<Base::OperatedYear>] 運用結果範囲
         #
-        def self.create_operation_month(operation_history: Operation::MonthHistory.new)
-          return Result::Operation::Month::Bundle.new if operation_history.invalid?
-
-          parent_operation_history = Operation.specify_history_by_id(
-            id: operation_history.parent_id
-          )
-
-          Result::Operation::Month::Bundle.new(
-            current: create_operation_month_history(operation_history: operation_history),
-            parent: create_operation_month_history(operation_history: parent_operation_history)
+        def self.get_operated_range_years(context:, years:, date: Western::Calendar.new)
+          operated_range = Calculation::Range::OperatedRange.new(
+            context: context, start_date: date, years: years
           )
+          operated_range.get
         end
-        private_class_method :create_operation_month
+        private_class_method :get_operated_range_years
 
         #
-        # 月別履歴情報を生成する
+        # 1日を取得する
         #
-        # @param [Operation::MonthHistory] operation_history 変更履歴（月）
+        # @param [Context] context 暦コンテキスト
+        # @param [Array<Base::Year>] years 完全範囲
+        # @param [Western::Calendar] date 西暦日
         #
-        # @return [Result::Operation::Month::History] 月別履歴情報
+        # @return [Data::SingleDay] 1日
         #
-        def self.create_operation_month_history(operation_history: Operation::MonthHistory.new)
-          return Result::Operation::Month::History.new if operation_history.invalid?
-
-          annotations = create_annnotations(operation_history: operation_history)
+        def self.get_data(context:, years:, date: Western::Calendar.new)
+          operated_years = get_operated_range_years(context: context, years: years, date: date)
 
-          reference = operation_history.reference
-          Result::Operation::Month::History.new(
-            id: operation_history.id, western_date: operation_history.western_date.format,
-            page: reference.page, number: reference.number, annotations: annotations
+          Calculation::Specifier::SingleDay.get(
+            years: operated_years, date: date
           )
         end
-        private_class_method :create_operation_month_history
+        private_class_method :get_data
 
         #
-        # 注釈情報を生成する
+        # 完全範囲を取得する
         #
-        # @param [Operation::MonthHistory] operation_history 変更履歴（月）
+        # @param [Context] context 暦コンテキスト
+        # @param [Western::Calendar] date 西暦日
         #
-        # @return [Array<Result::Operation::Month::Annotation>] 注釈
+        # @return [Array<Base::Year>] 完全範囲
         #
-        def self.create_annnotations(operation_history: Operation::MonthHistory.new)
-          annotations = []
-          operation_history.annotations.each do |annotation|
-            annotations.push(
-              Result::Operation::Month::Annotation.new(
-                description: annotation.description,
-                note: annotation.note
-              )
-            )
-          end
+        def self.get_operation(years:, date: Western::Calendar.new)
+          calc_date = Calculation::Specifier::SingleDay.get(
+            years: years, date: date
+          )
 
-          annotations
+          Operation.create(calc_date: calc_date)
         end
-        private_class_method :create_annnotations
+        private_class_method :get_operation
       end
     end
   end

data/lib/zakuro/condition.rb

@@ -87,6 +87,20 @@ module Zakuro
 
         failed
       end
+
+      #
+      # 不正か
+      #
+      # @return [True] 不正
+      # @return [False] 不正なし
+      #
+      def invalid?
+        return true unless @start
+
+        return true unless @end
+
+        false
+      end
     end
 
     #

data/lib/zakuro/era/japan/gengou/alignment/aligner.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_relative '../../../western/calendar'
+
+require_relative './line'
+
+# :nodoc:
+module Zakuro
+  #
+  # Japan 和暦
+  #
+  module Japan
+    #
+    # Alignment 整列
+    #
+    module Alignment
+      #
+      # Aligner 元号整列
+      #
+      class Aligner
+        # @return [Integer] 1行目元号
+        FIRST_LINE = 0
+
+        # @return [Integer] 2行目元号
+        SECOND_LINE = 1
+
+        # @return [Array<Integer>] 元号リスト
+        LINE_INDEXES = [FIRST_LINE, SECOND_LINE].freeze
+
+        # @return [Integer] 行数
+        LINE_SIZE = LINE_INDEXES.size
+
+        # @return [Array<Line>] 行元号
+        attr_reader :lines
+
+        #
+        # 初期化
+        #
+        # @param [Array<Set>] resources 元号解析結果
+        #
+        def initialize(resources: [])
+          @lines = []
+          (1..LINE_SIZE).each do |_index|
+            @lines.push(Line.new)
+          end
+
+          save(resources: resources)
+        end
+
+        #
+        # 行元号に追加する
+        #
+        # @param [Set] set 元号セット
+        #
+        def push(set:)
+          list = set.list
+          list.each do |gengou|
+            push_gengou(gengou: gengou)
+          end
+        end
+
+        #
+        # 指定した範囲内の元号を取得する
+        #
+        # @param [Integer] line 行
+        # @param [Western::Calendar] start_date 開始日
+        # @param [Western::Calendar] last_date 終了日
+        #
+        # @return [Array<LinearGengou>] 元号
+        #
+        def get(line:, start_date:, last_date:)
+          raise ArgumentError.new, 'invalid line number' unless LINE_INDEXES.include?(line)
+
+          @lines[line].get(start_date: start_date, last_date: last_date)
+        end
+
+        private
+
+        #
+        # 保存する
+        #
+        # @param [Array<Set>] resources 元号解析結果
+        #
+        def save(resources: [])
+          resources.each do |set|
+            push(set: set)
+          end
+        end
+
+        #
+        # 元号を追加する
+        #
+        # @param [Gengou] gengou 元号
+        #
+        def push_gengou(gengou:)
+          rest = [
+            LinearGengou.new(gengou: gengou)
+          ]
+          @lines.each do |line|
+            rest = line.push(list: rest)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zakuro/era/japan/gengou/alignment/division.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative './linear_gengou'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Japan
+    # :nodoc:
+    module Alignment
+      #
+      # Division 元号区分
+      #
+      module Division
+        #
+        # 重複した範囲を返す
+        #
+        # @param [LinearGengou] this 残り元号
+        # @param [LinearGengou] other 比較元号
+        #
+        # @return [Array<LinearGengou>] 重複分
+        #
+        def self.match(this:, other:)
+          result = []
+          if other.in?(start_date: this.start_date, last_date: this.last_date)
+            result.push(this)
+            return result
+          end
+
+          if other.out?(start_date: this.start_date, last_date: this.last_date)
+            # 該当なし
+            return result
+          end
+
+          if other.covered?(start_date: this.start_date, last_date: this.last_date)
+            # 範囲内のみ返す
+            result.push(trim_gengou(this: this, other: other))
+            return result
+          end
+
+          result.push(narrow_gengou(this: this, other: other))
+
+          result
+        end
+
+        #
+        # 範囲が重複しない差分を返す
+        #
+        # @param [LinearGengou] this 積元号
+        # @param [LinearGengou] other 比較元号
+        #
+        # @return [Array<LinearGengou>] 差分
+        #
+        def self.mismatch(this:, other:)
+          result = []
+          if other.in?(start_date: this.start_date, last_date: this.last_date)
+            # 該当なし
+            return result
+          end
+
+          if other.out?(start_date: this.start_date, last_date: this.last_date)
+            result.push(this)
+            return result
+          end
+
+          if other.covered?(start_date: this.start_date, last_date: this.last_date)
+            result |= split_gengou(this: this, other: other)
+            return result
+          end
+
+          result.push(shave_gengou(this: this, other: other))
+          result
+        end
+
+        #
+        # 比較により分離した元号をつなげる
+        #
+        # @param [Array<LinearGengou>] list 元号
+        #
+        # @return [Array<LinearGengou>] 同一元号がつながった元号
+        #
+        def self.connect(list: []) # rubocop:disable Metrics/MethodLength
+          result = []
+          list.each do |linear_gengou|
+            if result.size.zero?
+              result.push(linear_gengou)
+              next
+            end
+
+            before = result[-1]
+
+            if unconnectable?(current: linear_gengou, before: before)
+              result.push(linear_gengou)
+              next
+            end
+
+            result[-1] = LinearGengou.new(
+              start_date: before.start_date, last_date: linear_gengou.last_date,
+              gengou: linear_gengou.gengou
+            )
+          end
+
+          result
+        end
+
+        def self.unconnectable?(current:, before:)
+          return true unless current.gengou.name == before.gengou.name
+
+          return true unless (before.last_date.clone + 1) == current.start_date
+
+          false
+        end
+        private_class_method :unconnectable?
+
+        def self.split_gengou(this:, other:)
+          [
+            LinearGengou.new(
+              start_date: this.start_date.clone, last_date: other.start_date.clone - 1,
+              gengou: this.gengou
+            ),
+            LinearGengou.new(
+              start_date: other.last_date.clone + 1, last_date: this.last_date.clone,
+              gengou: this.gengou
+            )
+          ]
+        end
+        private_class_method :split_gengou
+
+        def self.trim_gengou(this:, other:)
+          LinearGengou.new(
+            start_date: other.start_date, last_date: other.last_date,
+            gengou: this.gengou
+          )
+        end
+        private_class_method :trim_gengou
+
+        def self.narrow_gengou(this:, other:)
+          start = this.start_date > other.start_date ? this.start_date : other.start_date
+          last = this.last_date < other.last_date ? this.last_date : other.last_date
+
+          LinearGengou.new(
+            start_date: start.clone, last_date: last.clone, gengou: this.gengou
+          )
+        end
+        private_class_method :narrow_gengou
+
+        def self.shave_gengou(this:, other:) # rubocop:disable Metrics/AbcSize
+          start = this.start_date
+          last = this.last_date
+
+          # 開始日が比較元号の開始日より前の範囲
+          last = other.start_date.clone - 1 if this.start_date < other.start_date
+
+          # 終了日が比較元号の開始日より後の範囲
+          start = other.last_date.clone + 1 if this.last_date > other.last_date
+
+          LinearGengou.new(
+            start_date: start.clone, last_date: last.clone, gengou: this.gengou
+          )
+        end
+        private_class_method :shave_gengou
+      end
+    end
+  end
+end