zakuro 0.6.1 → 0.8.0

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

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+require_relative '../../operation/operation'
+require_relative '../monthly/month'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Range
+      #
+      # OperatedSolarTerm 運用時二十四節気
+      #
+      class OperatedSolarTerm
+        # @return [Array<Year>] 完全範囲（年データ）
+        attr_reader :years
+        # @return [Hash<String, SolarTerm>] 二十四節気の移動元/移動先（西暦日 -> 対応する二十四節気）
+        #
+        # * 移動元の二十四節気：無効な大余小余あり（削除対象）
+        # * 移動先の二十四節気：移動元からの二十四節気（追加対象）
+        #
+        attr_reader :directions
+        # @return [Context::Context] 暦コンテキスト
+        attr_reader :context
+
+        #
+        # 初期化
+        #
+        # @param [Context::Context] context 暦コンテキスト
+        # @param [Array<Year>] years 完全範囲（年データ）
+        #
+        def initialize(context:, years: [])
+          @context = context
+          @years = years
+          @directions = {}
+        end
+
+        #
+        # データ生成する
+        #
+        # @return [<Type>] <description>
+        #
+        def create
+          @directions = create_directions
+        end
+
+        #
+        # 二十四節気を取得する
+        #
+        # @param [Western::Calendar] western_date 月初日の西暦日
+        #
+        # @return [True] 対象あり
+        # @return [False] 対象なし
+        # @return [SolarTerm] 二十四節気
+        #
+        def get(western_date: Western::Calendar.new)
+          context = current_context(western_date: western_date)
+
+          solar_term_class = context.resolver.solar_term
+          solar_term = directions.fetch(western_date.format, solar_term_class.new)
+
+          # 合致しない場合
+          return false, solar_term_class.new if solar_term.empty?
+
+          # 合致した上で、二十四節気が移動元（削除対象）の場合
+          # 合致した上で、二十四節気が移動先（追加対象）の場合
+          [true, solar_term]
+        end
+
+        # :reek:LongParameterList {max_params: 4}
+
+        class << self
+          # :reek:TooManyStatements { max_statements: 6 }
+
+          #
+          # 年内の全ての月の移動方向を作成する
+          #
+          # @param [Context::Context] context 暦コンテキスト
+          # @param [Hash<String, SolarTerm>] directions 二十四節気の移動元/移動先（西暦日 -> 対応する二十四節気）
+          # @param [Array<Month>] months 年内の全ての月
+          #
+          def create_directions_with_months(context:, directions: {}, months: [])
+            months.each do |month|
+              history = Operation.specify_history(western_date: month.western_date)
+
+              next if history.invalid?
+
+              direction = history.diffs.solar_term
+
+              next if direction.invalid?
+
+              create_directions_each_month(
+                context: context, directions: directions, direction: direction, month: month
+              )
+            end
+          end
+
+          #
+          # 月毎の移動方向を作成する
+          #
+          # @param [Context::Context] context 暦コンテキスト
+          # @param [Month] 月
+          # @param [Hash<String, SolarTerm>] directions 二十四節気の移動元/移動先（西暦日 -> 対応する二十四節気）
+          # @param [Operation::SolarTerm::Diretion] 二十四節気（移動）
+          #
+          def create_directions_each_month(context:, month:, directions: {},
+                                           direction: Operation::SolarTerm::Diretion.new)
+
+            month.solar_terms.each do |solar_term|
+              push_source(context: context, directions: directions,
+                          direction: direction, solar_term: solar_term)
+            end
+            push_destination(context: context, directions: directions,
+                             destination: direction.destination)
+          end
+
+          # :reek:LongParameterList {max_params: 4}
+
+          #
+          # 移動先に有効な二十四節気（差し替える二十四節気）を指定する
+          #
+          # @param [Context::Context] context 暦コンテキスト
+          # @param [SolarTerm] solar_term 二十四節気（計算値）
+          # @param [Hash<String, SolarTerm>] directions 二十四節気の移動元/移動先（西暦日 -> 対応する二十四節気）
+          # @param [Operation::SolarTerm::Direction] source 二十四節気（移動）
+          #
+          def push_source(context:, solar_term:, directions: {},
+                          direction: Operation::SolarTerm::Direction.new)
+            source = direction.source
+
+            return if source.invalid?
+
+            return unless source.index == solar_term.index
+
+            # 移動先に移動元の二十四節気を指定する
+            directions[source.to.format] = created_source(
+              context: context, direction: direction, solar_term: solar_term
+            )
+          end
+
+          #
+          # 移動先に有効な二十四節気（差し替える二十四節気）を生成する
+          #
+          # @param [Context::Context] context 暦コンテキスト
+          # @param [SolarTerm] solar_term 二十四節気（計算値）
+          # @param [Operation::SolarTerm::Direction] source 二十四節気（移動）
+          #
+          # @return [SolarTerm] 二十四節気（運用値）
+          #
+          def created_source(context:, solar_term:,
+                             direction: Operation::SolarTerm::Direction.new)
+            operated_solar_term = solar_term.clone
+            remainder_class_name = context.resolver.remainder
+
+            unless direction.invalid_days?
+              # 二十四節気の大余をずらす
+              operated_solar_term.remainder.add!(
+                remainder_class_name.new(day: direction.days, minute: 0, second: 0)
+              )
+            end
+
+            operated_solar_term
+          end
+
+          #
+          # 移動元に無効な二十四節気（連番のみ指定）を指定する
+          #
+          # @param [Context::Context] context 暦コンテキスト
+          # @param [Hash<String, SolarTerm>] directions 二十四節気の移動元/移動先（西暦日 -> 対応する二十四節気）
+          # @param [Operation::SolarTerm::Destination] destination 二十四節気（移動先）
+          #
+          def push_destination(context:, directions: {},
+                               destination: Operation::SolarTerm::Destination.new)
+            return if destination.invalid?
+
+            solar_term_class = context.resolver.solar_term
+            directions[destination.from.format] = solar_term_class.new(
+              index: destination.index
+            )
+          end
+        end
+
+        private
+
+        #
+        # 日付に対応する暦コンテキストを取得する
+        #
+        # @param [Western::Calendar] western_date 西暦日
+        #
+        # @return [Context::Context] 暦コンテキスト
+        #
+        def current_context(western_date: Western::Calendar.new)
+          years.each do |year|
+            return year.context if western_date >= year.new_year_date
+          end
+
+          Context::Context.new
+        end
+
+        #
+        # 二十四節気の移動元/移動先を生成する
+        #
+        # @return [Hash<String, SolarTerm>] 二十四節気の移動元/移動先（西暦日 -> 対応する二十四節気）
+        #
+        def create_directions
+          directions = {}
+
+          years.each do |year|
+            self.class.create_directions_with_months(
+              context: year.context, directions: directions, months: year.months
+            )
+          end
+
+          directions
+        end
+      end
+    end
+  end
+end

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

@@ -14,39 +14,42 @@ module Zakuro
         # GengouScroller 元号スクロール
         #
         module GengouScroller
-          #
-          # 元号を年に設定する
-          #
-          # @param [Gengou::Scroll] scroll 元号スクロール
-          # @param [Array<Base::Year>] years 年
-          #
-          def self.set(scroll:, years: [])
-            years.each do |year|
-              update_gengou_year(scroll: scroll, year: year)
+          class << self
+            #
+            # 元号を年に設定する
+            #
+            # @param [Gengou::Scroll] scroll 元号スクロール
+            # @param [Array<Base::Year>] years 年
+            #
+            def set(scroll:, years: [])
+              years.each do |year|
+                update_gengou_year(scroll: scroll, year: year)
+              end
             end
-          end
 
-          #
-          # 年の元号を更新する
-          #
-          # @param [Base::Year] year 年
-          #
-          def self.update_gengou_year(scroll:, year:)
-            year.months.each_with_index do |month, index|
-              scroll.run(month: month)
-              gengou = scroll.to_gengou
-              year.months[index] = Monthly::Month.new(
-                context: month.context,
-                month_label: month.month_label,
-                first_day: Monthly::FirstDay.new(
-                  remainder: month.first_day.remainder,
-                  western_date: gengou.start_date.clone
-                ),
-                solar_terms: month.solar_terms, gengou: gengou
-              )
+            private
+
+            #
+            # 年の元号を更新する
+            #
+            # @param [Base::Year] year 年
+            #
+            def update_gengou_year(scroll:, year:)
+              year.months.each_with_index do |month, index|
+                scroll.run(month: month)
+                gengou = scroll.to_gengou
+                year.months[index] = Monthly::Month.new(
+                  context: month.context,
+                  month_label: month.month_label,
+                  first_day: Monthly::FirstDay.new(
+                    remainder: month.first_day.remainder,
+                    western_date: gengou.start_date.clone
+                  ),
+                  solar_terms: month.solar_terms, gengou: gengou
+                )
+              end
             end
           end
-          private_class_method :update_gengou_year
         end
       end
     end

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

@@ -16,133 +16,131 @@ module Zakuro
         # YearBoundary 年境界
         #
         module YearBoundary
-          #
-          # 年間範囲内の年データの開始月を変更する
-          #
-          # @param [Context] context 暦コンテキスト
-          # @param [Array<Base::Year>] annual_ranges 年データ（冬至基準）
-          #
-          # @return [Array<Base::Year>] 年データ（元旦基準）
-          #
-          def self.get(context:, annual_ranges:)
-            categorize(context: context, annual_ranges: annual_ranges)
-            rearranged_years(context: context, annual_ranges: annual_ranges)
-          end
+          class << self
+            #
+            # 年間範囲内の年データの開始月を変更する
+            #
+            # @param [Context::Context] context 暦コンテキスト
+            # @param [Array<Base::Year>] annual_ranges 年データ（冬至基準）
+            #
+            # @return [Array<Base::Year>] 年データ（元旦基準）
+            #
+            def get(context:, annual_ranges:)
+              categorize(context: context, annual_ranges: annual_ranges)
+              rearranged_years(context: context, annual_ranges: annual_ranges)
+            end
 
-          #
-          # 年間範囲内の年データの開始月を変更する
-          #
-          # @param [Context] context 暦コンテキスト
-          # @param [Array<Base::Year>] annual_ranges 年データ（冬至基準）
-          #
-          # @return [Array<Base::Year>] 年データ（元旦基準）
-          #
-          def self.rearranged_years(context:, annual_ranges:)
-            years = []
-
-            (0..(annual_ranges.size - 2)).each do |index|
-              year = rearranged_year(
-                context: context, annual_ranges: annual_ranges, index: index
-              )
-              years.push(year)
+            private
+
+            #
+            # 年間範囲内の年データの開始月を変更する
+            #
+            # @param [Context::Context] context 暦コンテキスト
+            # @param [Array<Base::Year>] annual_ranges 年データ（冬至基準）
+            #
+            # @return [Array<Base::Year>] 年データ（元旦基準）
+            #
+            def rearranged_years(context:, annual_ranges:)
+              years = []
+
+              (0..(annual_ranges.size - 2)).each do |index|
+                year = rearranged_year(
+                  context: context, annual_ranges: annual_ranges, index: index
+                )
+                years.push(year)
+              end
+
+              years
             end
 
-            years
-          end
-          private_class_method :rearranged_years
-
-          #
-          # 年間範囲を昨年/今年で分類する
-          #
-          # @param [Context] context 暦コンテキスト
-          # @param [Array<Base::Year>] annual_range 1年データ
-          #
-          def self.categorize(context:, annual_ranges:)
-            annual_ranges.each do |annual_range|
-              categorize_year(context: context, annual_range: annual_range)
+            #
+            # 年間範囲を昨年/今年で分類する
+            #
+            # @param [Context::Context] context 暦コンテキスト
+            # @param [Array<Base::Year>] annual_range 1年データ
+            #
+            def categorize(context:, annual_ranges:)
+              annual_ranges.each do |annual_range|
+                categorize_year(context: context, annual_range: annual_range)
+              end
             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
-              )
+
+            #
+            # 各月を昨年/今年で分類する
+            #
+            # @param [Context::Context] context 暦コンテキスト
+            # @param [Array<Month>] annual_range 1年データ
+            #
+            def 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
-          end
-          private_class_method :categorize_year
-
-          #
-          # 年データの開始月を変更する
-          #
-          # @param [Context] context 暦コンテキスト
-          # @param [Array<Base::Year>] annual_ranges 年データ（冬至基準）
-          # @param [Integer] index 対象年の要素番号
-          #
-          # @return [Base::Year] 年データ（元旦基準）
-          #
-          def self.rearranged_year(context:, annual_ranges:, index:)
-            current_annual_range = annual_ranges[index]
-            next_annual_range = annual_ranges[index + 1]
-
-            year = push_current_year(context: context, annual_range: current_annual_range)
-            push_last_year(annual_range: next_annual_range, year: year)
-
-            year
-          end
-          private_class_method :rearranged_year
-
-          #
-          # 当年データを生成する
-          #
-          # @param [Context] context 暦コンテキスト
-          # @param [Array<Month>] annual_range 1年データ
-          #
-          # @return [Base::Year] 当年月ありの対象年
-          #
-          def self.push_current_year(context:, annual_range:)
-            year = Base::Year.new(context: context)
-            annual_range.each do |month|
-              next if month.is_last_year
-
-              year.push(month: month)
+
+            #
+            # 年データの開始月を変更する
+            #
+            # @param [Context::Context] context 暦コンテキスト
+            # @param [Array<Base::Year>] annual_ranges 年データ（冬至基準）
+            # @param [Integer] index 対象年の要素番号
+            #
+            # @return [Base::Year] 年データ（元旦基準）
+            #
+            def rearranged_year(context:, annual_ranges:, index:)
+              current_annual_range = annual_ranges[index]
+              next_annual_range = annual_ranges[index + 1]
+
+              year = push_current_year(context: context, annual_range: current_annual_range)
+              push_last_year(annual_range: next_annual_range, year: year)
+
+              year
             end
 
-            year
-          end
-          private_class_method :push_current_year
-
-          #
-          # 昨年データを生成する
-          #
-          # @param [Array<Month>] annual_range 1年データ
-          # @param [Base::Year] year 対象年
-          #
-          # @return [Base::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)
+            #
+            # 当年データを生成する
+            #
+            # @param [Context::Context] context 暦コンテキスト
+            # @param [Array<Month>] annual_range 1年データ
+            #
+            # @return [Base::Year] 当年月ありの対象年
+            #
+            def push_current_year(context:, annual_range:)
+              year = Base::Year.new(context: context)
+              annual_range.each do |month|
+                next if month.is_last_year
+
+                year.push(month: month)
+              end
+
+              year
             end
 
-            year
+            #
+            # 昨年データを生成する
+            #
+            # @param [Array<Month>] annual_range 1年データ
+            # @param [Base::Year] year 対象年
+            #
+            # @return [Base::Year] 昨年月ありの対象年
+            #
+            def 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
           end
-          private_class_method :push_last_year
         end
       end
     end

data/lib/zakuro/calculation/stella/lunar/abstract_location.rb

@@ -52,7 +52,7 @@ module Zakuro
         # @return [Cycle::AbstractRemainder] 1始まりの大余小余
         #
         def adjusted_remainder
-          @remainder.add(Cycle::AbstractRemainder.new(day: 1, minute: 0, second: 0))
+          remainder.add(Cycle::AbstractRemainder.new(day: 1, minute: 0, second: 0))
         end
 
         private

data/lib/zakuro/calculation/stella/lunar/choukei_value.rb

@@ -12,59 +12,61 @@ module Zakuro
       # ChoukeiValue 再考長慶宣明暦算法
       #
       module ChoukeiValue
-        #
-        # 四捨五入した大余を返す
-        #
-        # @param [Integer] per 増減率
-        # @param [Integer] denominator 小余の分母
-        # @param [Integer] minute 小余
-        #
-        # @return [Integer] 累計値（大余）
-        #
-        def self.rounded_day(per:, denominator:, minute:)
-          remainder_minute = Type::OldFloat.new((per * minute).to_f)
-          day = day_only(remainder_minute: remainder_minute.get, denominator: denominator)
-          # 繰り上げ結果を足す
-          day += carried_minute(remainder_minute: remainder_minute, denominator: denominator)
+        class << self
+          #
+          # 四捨五入した大余を返す
+          #
+          # @param [Integer] per 増減率
+          # @param [Integer] denominator 小余の分母
+          # @param [Integer] minute 小余
+          #
+          # @return [Integer] 累計値（大余）
+          #
+          def rounded_day(per:, denominator:, minute:)
+            remainder_minute = Type::OldFloat.new((per * minute).to_f)
+            day = day_only(remainder_minute: remainder_minute.get, denominator: denominator)
+            # 繰り上げ結果を足す
+            day += carried_minute(remainder_minute: remainder_minute, denominator: denominator)
 
-          day
-        end
+            day
+          end
 
-        #
-        # 秒がない大余小余にする
-        #
-        # @param [Cycle::LunarRemainder] remainder 大余小余
-        #
-        # @note 815年で大余繰り上げあり
-        #
-        # @return [Integer] 大余
-        # @return [Float] 小余
-        #
-        def self.remainder_without_second(remainder:)
-          adjusted = remainder.class.new(
-            day: remainder.day, minute: remainder.floor_minute, second: 0
-          )
-          adjusted.carry!
+          #
+          # 秒がない大余小余にする
+          #
+          # @param [Cycle::LunarRemainder] remainder 大余小余
+          #
+          # @note 815年で大余繰り上げあり
+          #
+          # @return [Integer] 大余
+          # @return [Float] 小余
+          #
+          def remainder_without_second(remainder:)
+            adjusted = remainder.class.new(
+              day: remainder.day, minute: remainder.floor_minute, second: 0
+            )
+            adjusted.carry!
 
-          [adjusted.day, adjusted.minute]
-        end
+            [adjusted.day, adjusted.minute]
+          end
 
-        def self.day_only(remainder_minute:, denominator:)
-          float_day = Type::OldFloat.new(remainder_minute / denominator)
-          # 切り捨て（プラスマイナスに関わらず小数点以下切り捨て）
-          float_day.floor!
-          float_day.get
-        end
-        private_class_method :day_only
+          private
+
+          def day_only(remainder_minute:, denominator:)
+            float_day = Type::OldFloat.new(remainder_minute / denominator)
+            # 切り捨て（プラスマイナスに関わらず小数点以下切り捨て）
+            float_day.floor!
+            float_day.get
+          end
 
-        def self.carried_minute(remainder_minute:, denominator:)
-          remainder_day = remainder_minute.abs % denominator
-          # 四捨五入（1/2日 以上なら繰り上げる）
-          return remainder_minute.sign if remainder_day >= (denominator / 2)
+          def carried_minute(remainder_minute:, denominator:)
+            remainder_day = remainder_minute.abs % denominator
+            # 四捨五入（1/2日 以上なら繰り上げる）
+            return remainder_minute.sign if remainder_day >= (denominator / 2)
 
-          0
+            0
+          end
         end
-        private_class_method :carried_minute
       end
     end
   end