zakuro 0.5.0 → 0.7.0

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

@@ -3,8 +3,6 @@
 require_relative '../../operation/operation'
 require_relative '../monthly/month'
 
-# TODO: solar_termの中はsrc/destだが、yamlはcalc/actual。統一したい。
-
 # :nodoc:
 module Zakuro
   # :nodoc:
@@ -57,6 +55,8 @@ module Zakuro
         # @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)
 
@@ -68,23 +68,6 @@ module Zakuro
           [true, solar_term]
         end
 
-        #
-        # 二十四節気の移動元/移動先を生成する
-        #
-        # @return [Hash<String, SolarTerm>] 二十四節気の移動元/移動先（西暦日 -> 対応する二十四節気）
-        #
-        def create_directions
-          directions = {}
-
-          years.each do |year|
-            OperatedSolarTerms.create_directions_with_months(
-              context: context, directions: directions, months: year.months
-            )
-          end
-
-          directions
-        end
-
         # :reek:TooManyStatements { max_statements: 6 }
 
         #
@@ -195,6 +178,40 @@ module Zakuro
             index: destination.index
           )
         end
+
+        private
+
+        #
+        # 日付に対応する暦コンテキストを取得する
+        #
+        # @param [Western::Calendar] western_date 西暦日
+        #
+        # @return [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.new
+        end
+
+        #
+        # 二十四節気の移動元/移動先を生成する
+        #
+        # @return [Hash<String, SolarTerm>] 二十四節気の移動元/移動先（西暦日 -> 対応する二十四節気）
+        #
+        def create_directions
+          directions = {}
+
+          years.each do |year|
+            OperatedSolarTerms.create_directions_with_months(
+              context: year.context, directions: directions, months: year.months
+            )
+          end
+
+          directions
+        end
       end
     end
   end

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../../monthly/month'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Range
+      # :nodoc:
+      module Transfer
+        #
+        # 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)
+            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
+              )
+            end
+          end
+          private_class_method :update_gengou_year
+        end
+      end
+    end
+  end
+end

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

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../../../calculation/base/multi_gengou_roller'
 require_relative '../../../calculation/base/year'
 
-require_relative '../../../era/western'
+require_relative '../../../era/western/calendar'
 
 # :nodoc:
 module Zakuro
@@ -21,27 +20,30 @@ module Zakuro
           # 年間範囲内の年データの開始月を変更する
           #
           # @param [Context] context 暦コンテキスト
-          # @param [Array<Year>] annual_ranges 年データ（冬至基準）
+          # @param [Array<Base::Year>] annual_ranges 年データ（冬至基準）
           #
-          # @return [Array<Year>] 年データ（元旦基準）
+          # @return [Array<Base::Year>] 年データ（元旦基準）
           #
           def self.get(context:, annual_ranges:)
             categorize(context: context, annual_ranges: annual_ranges)
-            rearranged_years(annual_ranges: annual_ranges)
+            rearranged_years(context: context, annual_ranges: annual_ranges)
           end
 
           #
           # 年間範囲内の年データの開始月を変更する
           #
-          # @param [Array<Year>] annual_ranges 年データ（冬至基準）
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Base::Year>] annual_ranges 年データ（冬至基準）
           #
-          # @return [Array<Year>] 年データ（元旦基準）
+          # @return [Array<Base::Year>] 年データ（元旦基準）
           #
-          def self.rearranged_years(annual_ranges:)
+          def self.rearranged_years(context:, annual_ranges:)
             years = []
 
             (0..(annual_ranges.size - 2)).each do |index|
-              year = rearranged_year(annual_ranges: annual_ranges, index: index)
+              year = rearranged_year(
+                context: context, annual_ranges: annual_ranges, index: index
+              )
               years.push(year)
             end
 
@@ -53,7 +55,7 @@ module Zakuro
           # 年間範囲を昨年/今年で分類する
           #
           # @param [Context] context 暦コンテキスト
-          # @param [Array<Year>] annual_range 1年データ
+          # @param [Array<Base::Year>] annual_range 1年データ
           #
           def self.categorize(context:, annual_ranges:)
             annual_ranges.each do |annual_range|
@@ -86,16 +88,17 @@ module Zakuro
           #
           # 年データの開始月を変更する
           #
-          # @param [Array<Year>] annual_ranges 年データ（冬至基準）
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Base::Year>] annual_ranges 年データ（冬至基準）
           # @param [Integer] index 対象年の要素番号
           #
-          # @return [Year] 年データ（元旦基準）
+          # @return [Base::Year] 年データ（元旦基準）
           #
-          def self.rearranged_year(annual_ranges:, index:)
+          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(annual_range: current_annual_range)
+            year = push_current_year(context: context, annual_range: current_annual_range)
             push_last_year(annual_range: next_annual_range, year: year)
 
             year
@@ -105,12 +108,13 @@ module Zakuro
           #
           # 当年データを生成する
           #
-          # @param [Array<Year>] annual_ranges 年データ（冬至基準）
-          # @param [Year] year 対象年
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Month>] annual_range 1年データ
           #
-          # @return [Year] 当年月ありの対象年
+          # @return [Base::Year] 当年月ありの対象年
           #
-          def self.push_current_year(annual_range:, year: Base::Year.new)
+          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
 
@@ -124,10 +128,10 @@ module Zakuro
           #
           # 昨年データを生成する
           #
-          # @param [Array<Year>] annual_ranges 年データ（冬至基準）
-          # @param [Year] year 対象年
+          # @param [Array<Month>] annual_range 1年データ
+          # @param [Base::Year] year 対象年
           #
-          # @return [Year] 昨年月ありの対象年
+          # @return [Base::Year] 昨年月ありの対象年
           #
           def self.push_last_year(annual_range:, year: Base::Year.new)
             annual_range.each do |month|

data/lib/zakuro/calculation/summary/internal/month.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative '../../../output/response'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Summary
+      #
+      # Month 特定月
+      #
+      class Month
+        # @return [Western::Calendar] 西暦開始日
+        attr_reader :start_date
+        # @return [Western::Calendar] 西暦終了日
+        attr_reader :last_date
+        # @return [Base::Year] 年
+        attr_reader :year
+        # @return [Monthly::Month] 月
+        attr_reader :month
+
+        #
+        # 初期化
+        #
+        # @param [Western::Calendar] start_date 西暦開始日
+        # @param [Western::Calendar] last_date 西暦終了日
+        # @param [Base::Year] year 年
+        # @param [Monthly::Month] month 月
+        #
+        def initialize(start_date:, last_date:, year:, month:)
+          @start_date = start_date
+          @last_date = last_date
+          @year = year
+          @month = month
+        end
+
+        #
+        # 取得する
+        #
+        # @return [Array<Result::Data::SingleDay>] 1日データ
+        #
+        def get
+          result = []
+          first_date = @month.western_date.clone
+
+          (0..@month.days).each do |index|
+            current_date = first_date.clone + index
+
+            next unless include?(date: current_date)
+
+            day = Output::Response::SingleDay.save_single_day(
+              param: Output::Response::SingleDay::Param.new(
+                year: @year, month: @month,
+                date: current_date, days: index
+              )
+            )
+
+            result.push(day)
+          end
+
+          result
+        end
+
+        #
+        # 含まれるか
+        #
+        # @param [Western::Calendar] date 西暦日
+        #
+        # @return [True] 含む
+        # @return [False] 含まない
+        #
+        def include?(date:)
+          return false if date < @start_date
+
+          return false if date > @last_date
+
+          true
+        end
+      end
+    end
+  end
+end

data/lib/zakuro/calculation/summary/{single.rb → internal/operation.rb}

@@ -1,10 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../specifier/single_day'
-
-require_relative '../range/operated_range'
-
-require_relative '../range/full_range'
+require_relative '../../../operation/operation'
 
 # :nodoc:
 module Zakuro
@@ -13,35 +9,9 @@ module Zakuro
     # :nodoc:
     module Summary
       #
-      # Single 一日
+      # Operation 運用情報
       #
-      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
-
+      module Operation
         #
         # 運用情報を生成する
         #
@@ -49,9 +19,9 @@ module Zakuro
         #
         # @return [Result::Operation::Bundle] 運用情報
         #
-        def self.create_operation(calc_date: Result::Data::SingleDay.new)
+        def self.create(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_history = Zakuro::Operation.specify_history(western_date: first_day)
 
           operation_month = create_operation_month(operation_history: operation_history)
 
@@ -59,7 +29,6 @@ module Zakuro
             operated: !operation_history.invalid?, month: operation_month, original: calc_date
           )
         end
-        private_class_method :create_operation
 
         #
         # 月履歴集約情報を生成する
@@ -71,7 +40,7 @@ module Zakuro
         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(
+          parent_operation_history = Zakuro::Operation.specify_history_by_id(
             id: operation_history.parent_id
           )
 

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

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require_relative '../../range/named_operation_range'
+
+require_relative '../../range/named_full_range'
+
+require_relative '../western/specifier/multiple_day'
+
+require_relative '../internal/operation'
+
+require_relative './specifier/single_day'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Summary
+      # :nodoc:
+      module Japan
+        #
+        # Range 期間
+        #
+        module Range
+          #
+          # 生成する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Japan::Calendar] start_date 和暦開始日
+          # @param [Japan::Calendar] last_date 和暦終了日
+          #
+          # @return [Result::Range] 期間検索結果（和暦日）
+          #
+          def self.get(context:, start_date: Japan::Calendar.new,
+                       last_date: Japan::Calendar.new)
+            years = get_full_range_years(
+              context: context, start_date: start_date, last_date: last_date
+            )
+            operated_years = get_operation_range_years(
+              context: context, years: years, start_date: start_date, last_date: last_date
+            )
+
+            japan_start_date = Specifier::SingleDay.get(years: operated_years, date: start_date)
+            japan_last_date = Specifier::SingleDay.get(years: operated_years, date: last_date)
+
+            list = create_list(
+              operated_years: operated_years, years: years,
+              start_date: japan_start_date, last_date: japan_last_date
+            )
+
+            Result::Range.new(list: list)
+          end
+
+          #
+          # <Description>
+          #
+          # @param [Array<Base::OperatedYear>] operated_years 運用結果範囲
+          # @param [Array<Base::Year>] years 完全範囲
+          # @param [Result::Data::SingleDay] start_date 和暦開始日
+          # @param [Result::Data::SingleDay] last_date 和暦終了日
+          #
+          # @return [Array<Result::Single>] 結果リスト
+          #
+          def self.create_list(operated_years: [], years: [],
+                               start_date:, last_date:)
+            western_start_date = start_date.day.western_date
+            western_last_date = last_date.day.western_date
+
+            operated_dates = Western::Specifier::MultipleDay.get(
+              years: operated_years, start_date: western_start_date, last_date: western_last_date
+            )
+
+            dates = Western::Specifier::MultipleDay.get(
+              years: years, start_date: western_start_date, last_date: western_last_date
+            )
+
+            create_result_list(dates: dates, operated_dates: operated_dates)
+          end
+          private_class_method :create_list
+
+          #
+          # 完全範囲を取得する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Japan::Calendar] start_date 和暦開始日
+          # @param [Japan::Calendar] last_date 和暦終了日
+          #
+          # @return [Array<Base::Year>] 完全範囲
+          #
+          def self.get_full_range_years(context:, start_date: Japan::Calendar.new,
+                                        last_date: Japan::Calendar.new)
+            full_range = Calculation::Range::NamedFullRange.new(
+              context: context, start_name: start_date.gengou, last_name: last_date.gengou
+            )
+            full_range.get
+          end
+          private_class_method :get_full_range_years
+
+          #
+          # 運用結果範囲を取得する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Base::Year>] years 完全範囲
+          # @param [Japan::Calendar] start_date 和暦開始日
+          # @param [Japan::Calendar] last_date 和暦終了日
+          #
+          # @return [Array<Base::OperatedYear>] 運用結果範囲
+          #
+          def self.get_operation_range_years(context:, years:, start_date: Japan::Calendar.new,
+                                             last_date: Japan::Calendar.new)
+            operation_range = Calculation::Range::NamedOperationRange.new(
+              context: context, years: years,
+              start_name: start_date.gengou, last_name: last_date.gengou
+            )
+            operation_range.get
+          end
+          private_class_method :get_operation_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
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative '../../range/named_operation_range'
+
+require_relative '../../range/named_full_range'
+
+require_relative '../western/specifier/single_day'
+
+require_relative '../internal/operation'
+
+require_relative './specifier/single_day'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Summary
+      # :nodoc:
+      module Japan
+        #
+        # Single 一日
+        #
+        module Single
+          #
+          # 生成する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Japan::Calendar] date 和暦日
+          #
+          # @return [Result::Single] 一日検索結果（和暦日）
+          #
+          def self.get(context:, date: Japan::Calendar.new)
+            years = get_full_range_years(context: context, date: date)
+
+            data = get_data(context: context, years: years, date: date)
+
+            western_date = data.day.western_date
+            operation = get_operation(years: years, date: western_date)
+
+            Result::Single.new(
+              data: data,
+              operation: operation
+            )
+          end
+
+          #
+          # 完全範囲を取得する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Japan::Calendar] date 和暦日
+          #
+          # @return [Array<Base::Year>] 完全範囲
+          #
+          def self.get_full_range_years(context:, date: Japan::Calendar.new)
+            full_range = Calculation::Range::NamedFullRange.new(
+              context: context, start_name: date.gengou
+            )
+            full_range.get
+          end
+          private_class_method :get_full_range_years
+
+          #
+          # 1日を取得する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Base::Year>] years 完全範囲
+          # @param [Japan::Calendar] date 和暦日
+          #
+          # @return [Data::SingleDay] 1日
+          #
+          def self.get_data(context:, years:, date: Japan::Calendar.new)
+            operated_years = get_operation_range_years(context: context, years: years, date: date)
+
+            Specifier::SingleDay.get(
+              years: operated_years, date: date
+            )
+          end
+          private_class_method :get_data
+
+          #
+          # 運用結果範囲を取得する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Array<Base::Year>] years 完全範囲
+          # @param [Japan::Calendar] date 和暦日
+          #
+          # @return [Array<Base::OperatedYear>] 運用結果範囲
+          #
+          def self.get_operation_range_years(context:, years:, date: Japan::Calendar.new)
+            operation_range = Calculation::Range::NamedOperationRange.new(
+              context: context, start_name: date.gengou, years: years
+            )
+            operation_range.get
+          end
+          private_class_method :get_operation_range_years
+
+          #
+          # 完全範囲を取得する
+          #
+          # @param [Context] context 暦コンテキスト
+          # @param [Western::Calendar] date 和暦日
+          #
+          # @return [Array<Base::Year>] 完全範囲
+          #
+          def self.get_operation(years:, date: Western::Calendar.new)
+            calc_date = Western::Specifier::SingleDay.get(
+              years: years, date: date
+            )
+
+            Operation.create(calc_date: calc_date)
+          end
+          private_class_method :get_operation
+        end
+      end
+    end
+  end
+end