zakuro 0.0.3 → 0.1.4

data/lib/zakuro/calculation/range/transfer/western_date_allocation.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Range
+      # :nodoc:
+      module Transfer
+        #
+        # WesternDateAllocation 西暦日の割り当て
+        #
+        module WesternDateAllocation
+          #
+          # 月初日の西暦日を更新する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Year>] years 完全範囲（月初日なし）
+          #
+          # @return [Array<Year>] 完全範囲（月初日あり）
+          #
+          def self.get(context:, years:)
+            update_first_day(context: context, years: years)
+
+            years
+          end
+
+          #
+          # 月初日の西暦日を更新する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Year>] years 完全範囲（月初日なし）
+          #
+          def self.update_first_day(context:, years:)
+            years.each_with_index do |year, index|
+              new_year_date = year.new_year_date.clone
+
+              months = year.months
+              update_first_day_within_all_months(
+                context: context,
+                new_year_date: new_year_date, months: months
+              )
+
+              years[index] = Base::Year.new(
+                multi_gengou: year.multi_gengou, new_year_date: new_year_date,
+                months: months, total_days: year.total_days
+              )
+            end
+          end
+
+          #
+          # 全ての月で月初日の西暦日を更新する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Western::Calendar] new_year_date 元旦
+          # @param [Array<Month>] months 月データ
+          #
+          def self.update_first_day_within_all_months(context:,
+                                                      new_year_date:, months:)
+            date = new_year_date.clone
+            months.each_with_index do |month, index|
+              updated_month = Monthly::Month.new(
+                context: context,
+                month_label: month.month_label,
+                first_day: Monthly::FirstDay.new(
+                  remainder: month.first_day.remainder,
+                  western_date: date
+                ),
+                solar_terms: month.solar_terms
+              )
+              months[index] = updated_month
+
+              date = date.clone + updated_month.days
+            end
+          end
+          private_class_method :update_first_day_within_all_months
+        end
+      end
+    end
+  end
+end

data/lib/zakuro/calculation/range/transfer/year_boundary.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require_relative '../../../calculation/base/multi_gengou_roller'
+require_relative '../../../calculation/base/year'
+
+require_relative '../../../era/western'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Range
+      # :nodoc:
+      module Transfer
+        #
+        # YearBoundary 年境界
+        #
+        module YearBoundary
+          #
+          # 年間範囲内の年データの開始月を変更する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Year>] annual_ranges 年データ（冬至基準）
+          #
+          # @return [Array<Year>] 年データ（元旦基準）
+          #
+          def self.get(context:, annual_ranges:)
+            categorize(context: context, annual_ranges: annual_ranges)
+            rearranged_years(annual_ranges: annual_ranges)
+          end
+
+          #
+          # 年間範囲内の年データの開始月を変更する
+          #
+          # @param [Array<Year>] annual_ranges 年データ（冬至基準）
+          #
+          # @return [Array<Year>] 年データ（元旦基準）
+          #
+          def self.rearranged_years(annual_ranges:)
+            years = []
+
+            (0..(annual_ranges.size - 2)).each do |index|
+              year = rearranged_year(annual_ranges: annual_ranges, index: index)
+              years.push(year)
+            end
+
+            years
+          end
+          private_class_method :rearranged_years
+
+          #
+          # 年間範囲を昨年/今年で分類する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Year>] annual_range 1年データ
+          #
+          def self.categorize(context:, annual_ranges:)
+            annual_ranges.each do |annual_range|
+              categorize_year(context: context, annual_range: annual_range)
+            end
+          end
+          private_class_method :categorize
+
+          #
+          # 各月を昨年/今年で分類する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Month>] annual_range 1年データ
+          #
+          def self.categorize_year(context:, annual_range:)
+            is_last_year = true
+            annual_range.each_with_index do |month, index|
+              is_last_year = false if month.number == 1
+
+              annual_range[index] = Monthly::InitializedMonth.new(
+                context: context,
+                month_label: month.month_label, first_day: month.first_day,
+                solar_terms: month.solar_terms, phase_index: month.phase_index,
+                is_last_year: is_last_year
+              )
+            end
+          end
+          private_class_method :categorize_year
+
+          #
+          # 年データの開始月を変更する
+          #
+          # @param [Array<Year>] annual_ranges 年データ（冬至基準）
+          # @param [Integer] index 対象年の要素番号
+          #
+          # @return [Year] 年データ（元旦基準）
+          #
+          def self.rearranged_year(annual_ranges:, index:)
+            current_annual_range = annual_ranges[index]
+            next_annual_range = annual_ranges[index + 1]
+
+            year = push_current_year(annual_range: current_annual_range)
+            push_last_year(annual_range: next_annual_range, year: year)
+
+            year
+          end
+          private_class_method :rearranged_year
+
+          #
+          # 当年データを生成する
+          #
+          # @param [Array<Year>] annual_ranges 年データ（冬至基準）
+          # @param [Year] year 対象年
+          #
+          # @return [Year] 当年月ありの対象年
+          #
+          def self.push_current_year(annual_range:, year: Base::Year.new)
+            annual_range.each do |month|
+              next if month.is_last_year
+
+              year.push(month: month)
+            end
+
+            year
+          end
+          private_class_method :push_current_year
+
+          #
+          # 昨年データを生成する
+          #
+          # @param [Array<Year>] annual_ranges 年データ（冬至基準）
+          # @param [Year] year 対象年
+          #
+          # @return [Year] 昨年月ありの対象年
+          #
+          def self.push_last_year(annual_range:, year: Base::Year.new)
+            annual_range.each do |month|
+              next unless month.is_last_year
+
+              year.push(month: month)
+            end
+
+            year
+          end
+          private_class_method :push_last_year
+        end
+      end
+    end
+  end
+end

data/lib/zakuro/calculation/specifier/single_day.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative '../base/multi_gengou_roller'
+require_relative '../base/year'
+
+require_relative '../../era/western'
+require_relative '../../output/response'
+require_relative '../../output/logger'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Specifier
+      #
+      # SingleDay 一日検索
+      #
+      module SingleDay
+        # @return [Output::Logger] ロガー
+        LOGGER = Output::Logger.new(location: 'specifier')
+
+        #
+        # 取得する
+        #
+        # @param [Array<Year>] yeas 範囲
+        # @param [Western::Calendar] date 西暦日
+        #
+        # @return [Result::Data::SingleDay] 和暦日
+        #
+        def self.get(years: [], date: Western::Calendar.new)
+          year = specify_year(years: years, date: date)
+
+          year = transfer(year: year, date: date)
+
+          month = specify_month(year: year, date: date)
+          first_date = month.western_date
+
+          Output::Response::SingleDay.save_single_day(
+            param: Output::Response::SingleDay::Param.new(
+              year: year, month: month,
+              date: date, days: date - first_date
+            )
+          )
+        end
+
+        #
+        # 年を特定する
+        #
+        # @param [Array<Year>] years 範囲
+        # @param [Western::Calendar] date 西暦日
+        #
+        # @return [Year] 対象年
+        #
+        def self.specify_year(years:, date:)
+          years.reverse_each do |year|
+            return year if date >= year.new_year_date
+          end
+
+          raise ArgumentError, "invalid year range. date: #{date.format}"
+        end
+        private_class_method :specify_year
+
+        #
+        # 改元する
+        #
+        # @param [Year] year 年
+        # @param [Western::Calendar] date 西暦日
+        #
+        # @return [Year] 改元後の年
+        #
+        def self.transfer(year:, date:)
+          multi_gengou = Calculation::Base::MultiGengouRoller.transfer(
+            multi_gengou: year.multi_gengou, date: date
+          )
+          Calculation::Base::Year.new(
+            multi_gengou: multi_gengou, new_year_date: year.new_year_date,
+            months: year.months, total_days: year.total_days
+          )
+        end
+        private_class_method :transfer
+
+        # :reek:TooManyStatements { max_statements: 7 }
+
+        #
+        # 月を特定する
+        #
+        # @param [Year] year 年
+        # @param [Western::Calendar] date 西暦日
+        #
+        # @return [Month] 対象月
+        #
+        def self.specify_month(year:, date:)
+          months = year.months
+
+          current_month = months[0]
+          months.each do |month|
+            return current_month if month.western_date > date
+
+            current_month = month
+          end
+
+          current_month
+        end
+        private_class_method :specify_month
+      end
+    end
+  end
+end

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+require_relative '../specifier/single_day'
+
+require_relative '../range/operated_range'
+
+require_relative '../range/full_range'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Summary
+      #
+      # Single 一日
+      #
+      module Single
+        #
+        # 生成する
+        #
+        # @param [Context] context 暦コンテキスト
+        # @param [Western::Calendar] date 西暦日
+        #
+        # @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
+
+          calc_date = Calculation::Specifier::SingleDay.get(
+            years: years, date: date
+          )
+
+          operated_range = Calculation::Range::OperatedRange.new(context: context, years: years)
+
+          Result::Single.new(
+            data: Calculation::Specifier::SingleDay.get(
+              years: operated_range.get, date: date
+            ),
+            operation: create_operation(calc_date: calc_date)
+          )
+        end
+
+        #
+        # 運用情報を生成する
+        #
+        # @param [Result::Data::SingleDay] calc_date 和暦日（計算値）
+        #
+        # @return [Result::Operation::Bundle] 運用情報
+        #
+        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
+          )
+        end
+        private_class_method :create_operation
+
+        #
+        # 月履歴集約情報を生成する
+        #
+        # @param [Operation::MonthHistory] operation_history 変更履歴（月）
+        #
+        # @return [Result::Operation::Month::Bundle] 月履歴集約情報
+        #
+        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)
+          )
+        end
+        private_class_method :create_operation_month
+
+        #
+        # 月別履歴情報を生成する
+        #
+        # @param [Operation::MonthHistory] operation_history 変更履歴（月）
+        #
+        # @return [Result::Operation::Month::History] 月別履歴情報
+        #
+        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)
+
+          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
+          )
+        end
+        private_class_method :create_operation_month_history
+
+        #
+        # 注釈情報を生成する
+        #
+        # @param [Operation::MonthHistory] operation_history 変更履歴（月）
+        #
+        # @return [Array<Result::Operation::Month::Annotation>] 注釈
+        #
+        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
+
+          annotations
+        end
+        private_class_method :create_annnotations
+      end
+    end
+  end
+end