zakuro 0.6.0 → 0.7.2

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,38 +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, start_date: date, years: years
-          )
-          operated_years = operated_range.get
-
-          Result::Single.new(
-            data: Calculation::Specifier::SingleDay.get(
-              years: operated_years, date: date
-            ),
-            operation: create_operation(calc_date: calc_date)
-          )
-        end
-
+      module Operation
         #
         # 運用情報を生成する
         #
@@ -52,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)
 
@@ -62,7 +29,6 @@ module Zakuro
             operated: !operation_history.invalid?, month: operation_month, original: calc_date
           )
         end
-        private_class_method :create_operation
 
         #
         # 月履歴集約情報を生成する
@@ -74,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/internal/option.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../../../context/option'
+require_relative '../../../result/data/option/dropped_date/option'
+require_relative '../../../result/data/solar_term'
+
+require_relative '../../option/dropped_date/location'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Summary
+      #
+      # Option オプション
+      #
+      module Option
+        #
+        # 初期化
+        #
+        # @param [Calculation::Monthly::Month] month 月情報（各暦のデータ型）
+        # @param [Calculation::Base::Day] day 日情報
+        #
+        # @return [Hash<String, Result::Data::Option::AbstractOption>] オプション結果
+        #
+        def self.create(month:, day:)
+          # TODO: test
+          options = {}
+          context = month.context
+
+          if context.option.dropped_date?
+            remainder = day.remainder
+            solar_terms = month.solar_terms
+            option = dropped_date(context: context, remainder: remainder, solar_terms: solar_terms)
+            options[Context::Option::DROPPED_DATE_KEY] = option
+          end
+
+          options
+        end
+
+        #
+        # 没日を求める
+        #
+        # @param [Context::Context] context 暦コンテキスト
+        # @param [Cycle::AbstractRemainder] remainder 当日和暦日
+        # @param [Array<Cycle::AbstractSolarTerm>] solar_terms 二十四節気
+        #
+        # @return [Result::Data::Option::DroppedDate::Option] 没日
+        #
+        def self.dropped_date(context:, remainder:, solar_terms:)
+          # TODO: refactor
+          option = Result::Data::Option::DroppedDate::Option.new(
+            matched: false,
+            calculation: Result::Data::Option::DroppedDate::Calculation.new
+          )
+
+          return option if remainder.invalid?
+
+          location = Calculation::Option::DroppedDate::Location.new(
+            context: context, solar_terms: solar_terms
+          )
+
+          return option unless location.exist?
+
+          dropped_date = location.get
+
+          return option unless remainder.day == dropped_date.day
+
+          solar_term = location.solar_term
+          Result::Data::Option::DroppedDate::Option.new(
+            matched: true,
+            calculation: Result::Data::Option::DroppedDate::Calculation.new(
+              remainder: dropped_date.format,
+              solar_term: Result::Data::SolarTerm.new(
+                index: solar_term.index,
+                remainder: solar_term.remainder.format
+              )
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+# 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] 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(
+              context: context,
+              operated_years: operated_years, years: years,
+              start_date: japan_start_date, last_date: japan_last_date
+            )
+
+            Result::Range.new(list: list)
+          end
+
+          #
+          # 1日検索結果リストを生成する
+          #
+          # @param [Context::Context] context 暦コンテキスト
+          # @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(context:, 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(
+              context: context, years: operated_years, start_date: western_start_date, last_date: western_last_date
+            )
+
+            dates = Western::Specifier::MultipleDay.get(
+              context: context, 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] 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] 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] 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] 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] 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] context 暦コンテキスト
+          # @param [Array<Calculation::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 [Array<Calculation::Base::Year>] years 完全範囲
+          # @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

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

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require_relative '../../../../era/japan/calendar'
+require_relative '../../../../era/western/calendar'
+require_relative '../../../../output/response'
+require_relative '../../../../output/logger'
+
+require_relative '../../../base/year'
+
+require_relative '../../internal/day'
+require_relative '../../internal/option'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Summary
+      # :nodoc:
+      module Japan
+        # :nodoc:
+        module Specifier
+          #
+          # SingleDay 一日検索
+          #
+          module SingleDay
+            # @return [Output::Logger] ロガー
+            LOGGER = Output::Logger.new(location: 'specifier')
+
+            #
+            # 取得する
+            #
+            # @param [Array<Year>] yeas 範囲
+            # @param [Japan::Calendar] date 和暦日
+            #
+            # @return [Result::Data::SingleDay] 和暦日
+            #
+            def self.get(years: [], date: Japan::Calendar.new)
+              year, month = specify(years: years, date: date)
+              first_date = month.western_date.clone
+              days = date.day - 1
+              western_date = first_date + days
+              day = Day.get(month: month, date: western_date)
+
+              options = Option.create(month: month, day: day)
+
+              Output::Response::SingleDay.create(
+                year: year, month: month, day: day, options: options
+              )
+            end
+
+            #
+            # 年を特定する
+            #
+            # @param [Array<Year>] years 範囲
+            # @param [Japan::Calendar] date 和暦日
+            #
+            # @return [Base::Year] 対象年
+            # @return [Monthly::Month] 対象月
+            #
+            # @raise [ArgumentError] 引数エラー
+            #
+            def self.specify(years:, date:)
+              years.each do |year|
+                month = specify_month(year: year, date: date)
+                return year, month unless month.invalid?
+              end
+
+              raise ArgumentError, "invalid year range. date: #{date.format}"
+            end
+            private_class_method :specify
+
+            #
+            # 月を特定する
+            #
+            # @param [Base::Year] year 年
+            # @param [Japan::Calendar] date 和暦日
+            #
+            # @return [Monthly::Month] 対象月
+            #
+            def self.specify_month(year:, date:)
+              months = year.months
+
+              months.each do |month|
+                return month if month.include_by_japan_date?(date: date)
+              end
+
+              Monthly::Month.new
+            end
+            private_class_method :specify_month
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative '../../range/dated_operation_range'
+
+require_relative '../../range/dated_full_range'
+
+require_relative './specifier/multiple_day'
+
+require_relative '../internal/operation'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Summary
+      # :nodoc:
+      module Western
+        #
+        # Range 期間
+        #
+        module Range
+          #
+          # 生成する
+          #
+          # @param [Context::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_operation_range_years(
+              context: context, years: years, start_date: start_date, last_date: last_date
+            )
+
+            dates = Specifier::MultipleDay.get(
+              context: context, years: years, start_date: start_date, last_date: last_date
+            )
+
+            operated_dates = Specifier::MultipleDay.get(
+              context: context, 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] 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::DatedFullRange.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] context 暦コンテキスト
+          # @param [Array<Base::Year>] years 完全範囲
+          # @param [Western::Calendar] start_date 西暦開始日
+          # @param [Western::Calendar] last_date 西暦終了日
+          #
+          # @return [Array<Base::OperatedYear>] 運用結果範囲
+          #
+          def self.get_operation_range_years(context:, years:, start_date: Western::Calendar.new,
+                                             last_date: Western::Calendar.new)
+            operation_range = Calculation::Range::DatedOperationRange.new(
+              context: context, start_date: start_date, last_date: last_date, years: years
+            )
+            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