zakuro 0.4.0 → 0.6.1

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

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+require_relative '../base/year'
+
+require_relative '../../era/western/calendar'
+require_relative '../../output/response'
+require_relative '../../output/logger'
+
+require_relative './internal/month'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Specifier
+      #
+      # MultipleDay 複数日検索
+      #
+      module MultipleDay
+        # @return [Output::Logger] ロガー
+        LOGGER = Output::Logger.new(location: 'specifier')
+
+        #
+        # 取得する
+        #
+        # @param [Array<Base::Year>] years 範囲
+        # @param [Western::Calendar] start_date 西暦開始日
+        # @param [Western::Calendar] last_date 西暦終了日
+        #
+        # @return [Array<Result::Data::SingleDay>] 期間検索結果（和暦日）
+        #
+        def self.get(years: [], start_date: Western::Calendar.new, last_date: Western::Calendar.new)
+          months = specify(years: years, start_date: start_date, last_date: last_date)
+
+          result = []
+          months.each do |month|
+            result |= month.get
+          end
+
+          result
+        end
+
+        #
+        # 年を特定する
+        #
+        # @param [Array<Year>] years 範囲
+        # @param [Western::Calendar] start_date 西暦開始日
+        # @param [Western::Calendar] last_date 西暦終了日
+        #
+        # @return [Array<Month>] 特定月
+        #
+        def self.specify(years: [], start_date: Western::Calendar.new,
+                         last_date: Western::Calendar.new)
+          result = []
+          years.each do |year|
+            result |= specify_month(
+              year: year, start_date: start_date, last_date: last_date
+            )
+          end
+
+          result
+        end
+        private_class_method :specify
+
+        # :reek:TooManyStatements { max_statements: 7 }
+
+        #
+        # 月を特定する
+        #
+        # @param [Year] year 年
+        # @param [Western::Calendar] start_date 西暦開始日
+        # @param [Western::Calendar] last_date 西暦終了日
+        #
+        # @return [Month] 対象月
+        #
+        def self.specify_month(year:, start_date: Western::Calendar.new,
+                               last_date: Western::Calendar.new)
+          months = year.months
+
+          specify_months = []
+          months.each do |month|
+            next unless include?(month: month, start_date: start_date, last_date: last_date)
+
+            monthly_start_date = month.western_date.clone
+            monthly_last_date = month.last_date.clone
+
+            monthly_start_date = start_date.clone if start_date > monthly_start_date
+
+            monthly_last_date = last_date.clone if last_date < monthly_last_date
+
+            specify_months.push(
+              Month.new(year: year, month: month,
+                        start_date: monthly_start_date, last_date: monthly_last_date)
+            )
+          end
+
+          specify_months
+        end
+        private_class_method :specify_month
+
+        #
+        # 月が範囲に含まれるか
+        #
+        # @param [Monthly::Month] month 月
+        # @param [Western::Calendar] start_date 西暦開始日
+        # @param [Western::Calendar] last_date 西暦終了日
+        #
+        # @return [True] 含む
+        # @return [False] 含まない
+        #
+        def self.include?(month:, start_date:, last_date:)
+          monthly_start_date = month.western_date.clone
+          monthly_last_date = month.last_date.clone
+
+          return false if monthly_start_date.invalid?
+
+          return false if monthly_last_date.invalid?
+
+          return false if under(monthly_start_date: monthly_start_date,
+                                start_date: start_date, last_date: last_date)
+
+          return false if over(monthly_last_date: monthly_last_date,
+                               start_date: start_date, last_date: last_date)
+
+          true
+        end
+        private_class_method :include?
+
+        #
+        # 範囲が月より前にあるか
+        #
+        # @param [Western::Calendar] monthly_start_date 月初日
+        # @param [Western::Calendar] start_date 西暦開始日
+        # @param [Western::Calendar] last_date 西暦終了日
+        #
+        # @return [True] 前にある
+        # @return [False] 前にない
+        #
+        def self.under(monthly_start_date:, start_date:, last_date:)
+          start_date < monthly_start_date && last_date < monthly_start_date
+        end
+        private_class_method :under
+
+        #
+        # 範囲が月より後にあるか
+        #
+        # @param [Western::Calendar] monthly_start_date 月末日
+        # @param [Western::Calendar] start_date 西暦開始日
+        # @param [Western::Calendar] last_date 西暦終了日
+        #
+        # @return [True] 後にある
+        # @return [False] 後にない
+        #
+        def self.over(monthly_last_date:, start_date:, last_date:)
+          start_date > monthly_last_date && last_date > monthly_last_date
+        end
+        private_class_method :over
+      end
+    end
+  end
+end

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

@@ -1,9 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../base/multi_gengou_roller'
 require_relative '../base/year'
 
-require_relative '../../era/western'
+require_relative '../../era/western/calendar'
 require_relative '../../output/response'
 require_relative '../../output/logger'
 
@@ -29,11 +28,7 @@ module Zakuro
         # @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)
+          year, month = specify(years: years, date: date)
           first_date = month.western_date
 
           Output::Response::SingleDay.save_single_day(
@@ -50,57 +45,40 @@ module Zakuro
         # @param [Array<Year>] years 範囲
         # @param [Western::Calendar] date 西暦日
         #
-        # @return [Year] 対象年
+        # @return [Base::Year] 対象年
+        # @return [Base::Month] 対象月
         #
-        def self.specify_year(years:, date:)
-          years.reverse_each do |year|
-            return year if date >= year.new_year_date
+        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_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
+        private_class_method :specify
 
         # :reek:TooManyStatements { max_statements: 7 }
 
         #
         # 月を特定する
         #
-        # @param [Year] year 年
+        # @param [Base::Year] year 年
         # @param [Western::Calendar] date 西暦日
         #
-        # @return [Month] 対象月
+        # @return [Base::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
+            western_date = month.western_date
+            next if western_date.invalid?
 
-            current_month = month
+            return month if month.include?(date: date)
           end
 
-          current_month
+          Monthly::Month.new
         end
         private_class_method :specify_month
       end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require_relative '../../../operation/operation'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Summary
+      #
+      # Operation 運用情報
+      #
+      module Operation
+        #
+        # 運用情報を生成する
+        #
+        # @param [Result::Data::SingleDay] calc_date 和暦日（計算値）
+        #
+        # @return [Result::Operation::Bundle] 運用情報
+        #
+        def self.create(calc_date: Result::Data::SingleDay.new)
+          first_day = calc_date.month.first_day.western_date
+          operation_history = Zakuro::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
+
+        #
+        # 月履歴集約情報を生成する
+        #
+        # @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 = Zakuro::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

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,104 +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, years: years)
+          operation = get_operation(years: years, date: date)
 
           Result::Single.new(
-            data: Calculation::Specifier::SingleDay.get(
-              years: operated_range.get, 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?
+        def self.get_data(context:, years:, date: Western::Calendar.new)
+          operated_years = get_operated_range_years(context: context, years: years, date: date)
 
-          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
+          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
 
     #