zakuro 0.6.0 → 0.6.1

data/lib/zakuro/calculation/{version → era/version}/internal/crawler.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../../era/japan/version'
+require_relative '../../../../era/japan/version'
 require_relative './range'
 
 # :nodoc:
@@ -17,12 +17,12 @@ module Zakuro
         # 暦の範囲を取得する
         #
         # @param [Integer] start_year 開始西暦年
-        # @param [Integer] end_year 終了西暦年
+        # @param [Integer] last_year 終了西暦年
         #
         # @return [Array<Range>] 暦の範囲
         #
-        def self.get(start_year:, end_year:)
-          ranges = Japan::Version.ranges_with_year(start_year: start_year, end_year: end_year)
+        def self.get(start_year:, last_year:)
+          ranges = Japan::Version.ranges_with_year(start_year: start_year, last_year: last_year)
 
           result = []
 
@@ -32,13 +32,13 @@ module Zakuro
             range_start_year = range.start_year
             range_start_year = start_year if start_year > range.start_year
 
-            range_end_year = range.end_year
-            range_end_year = end_year if end_year < range.end_year
+            range_last_year = range.last_year
+            range_last_year = last_year if last_year < range.last_year
 
             result.push(
               Range.new(
                 name: range.name, start_date: range.start_date.clone,
-                start_year: range_start_year, end_year: range_end_year
+                start_year: range_start_year, last_year: range_last_year
               )
             )
           end

data/lib/zakuro/calculation/{version → era/version}/internal/range.rb

@@ -17,7 +17,7 @@ module Zakuro
         # @return [Integer] 開始西暦年
         attr_reader :start_year
         # @return [Integer] 終了西暦年
-        attr_reader :end_year
+        attr_reader :last_year
 
         #
         # 初期化
@@ -25,13 +25,13 @@ module Zakuro
         # @param [String] name 暦名
         # @param [Western::Calendar] start_date 暦の開始日
         # @param [Integer] start_year 開始西暦年
-        # @param [Integer] end_year 終了西暦年
+        # @param [Integer] last_year 終了西暦年
         #
-        def initialize(name:, start_date:, start_year:, end_year:)
+        def initialize(name:, start_date:, start_year:, last_year:)
           @name = name
           @start_date = start_date
           @start_year = start_year
-          @end_year = end_year
+          @last_year = last_year
         end
       end
     end

data/lib/zakuro/calculation/{version → era/version}/version.rb

@@ -12,12 +12,12 @@ module Zakuro
       # 暦の範囲を取得する
       #
       # @param [Integer] start_year 開始西暦年
-      # @param [Integer] end_year 終了西暦年
+      # @param [Integer] last_year 終了西暦年
       #
       # @return [Array<Range>] 暦の範囲
       #
-      def self.get(start_year:, end_year:)
-        Crawler.get(start_year: start_year, end_year: end_year)
+      def self.get(start_year:, last_year:)
+        Crawler.get(start_year: start_year, last_year: last_year)
       end
     end
   end

data/lib/zakuro/calculation/monthly/month.rb

@@ -202,7 +202,7 @@ module Zakuro
         #
         # @return [Western::Calendar] 月の終了日
         #
-        def end_date
+        def last_date
           return Western::Calendar.new if western_date.invalid?
 
           western_date.clone + days - 1
@@ -224,7 +224,7 @@ module Zakuro
 
           return false if date < start_date
 
-          return false if date > end_date
+          return false if date > last_date
 
           true
         end

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

@@ -5,13 +5,12 @@ require_relative '../../version/context'
 require_relative '../../era/western/calendar'
 require_relative '../../output/logger'
 
-require_relative '../gengou/scroll'
+require_relative '../era/gengou/scroll'
+require_relative '../era/version/version'
 
 require_relative '../base/gengou'
 require_relative '../base/year'
 
-require_relative '../version/version'
-
 require_relative './transfer/year_boundary'
 
 require_relative './transfer/gengou_scroller'
@@ -42,7 +41,7 @@ module Zakuro
         # @return [Western::Calendar] 開始日
         attr_reader :start_date
         # @return [Western::Calendar] 終了日
-        attr_reader :end_date
+        attr_reader :last_date
         # @return [MultiGengouRoller] 改元処理
         attr_reader :scroll
 
@@ -54,16 +53,16 @@ module Zakuro
         #
         # @param [Context] context 暦コンテキスト
         # @param [Western::Calendar] start_date 開始日
-        # @param [Western::Calendar] end_date 終了日
+        # @param [Western::Calendar] last_date 終了日
         #
-        def initialize(context:, start_date: Western::Calendar.new, end_date: Western::Calendar.new)
+        def initialize(context:, start_date: Western::Calendar.new, last_date: Western::Calendar.new)
           @start_date = start_date
-          @end_date = end_date
+          @last_date = last_date
           return if invalid?
 
           # TODO: 現時点では使用していない。特定の暦を指定できるようになった状態で使用する
           @context = context
-          @scroll = Gengou::Scroll.new(start_date: start_date, end_date: end_date)
+          @scroll = Gengou::Scroll.new(start_date: start_date, last_date: last_date)
         end
 
         #
@@ -104,19 +103,19 @@ module Zakuro
           result = []
 
           start_year = @scroll.western_start_year
-          end_year = @scroll.western_end_year
+          last_year = @scroll.western_last_year
 
-          versions = Version.get(start_year: start_year, end_year: end_year)
+          versions = Version.get(start_year: start_year, last_year: last_year)
 
           versions.each_with_index do |version, index|
             context = Context.new(version_name: version.name)
             start_year = version.start_year
-            end_year = version.end_year
+            last_year = version.last_year
             # 最後の暦だけ1年足す（次の元号の開始年まで計算するケースあり）
-            end_year += 1 if (index + 1) == versions.size
+            last_year += 1 if (index + 1) == versions.size
 
             years = boundary_resolved_ranges(
-              context: context, start_year: start_year, end_year: end_year
+              context: context, start_year: start_year, last_year: last_year
             )
             result.concat(years)
           end
@@ -129,13 +128,13 @@ module Zakuro
         #
         # @param [Context] context 暦コンテキスト
         # @param [Integer] start_year 開始西暦年
-        # @param [Integer] end_year 終了西暦年
+        # @param [Integer] last_year 終了西暦年
         #
         # @return [Array<Base::Year>] 年境界解決済みの範囲
         #
-        def boundary_resolved_ranges(context:, start_year:, end_year:)
+        def boundary_resolved_ranges(context:, start_year:, last_year:)
           ranges = annual_ranges(
-            context: context, start_year: start_year, end_year: end_year
+            context: context, start_year: start_year, last_year: last_year
           )
 
           Transfer::YearBoundary.get(
@@ -148,15 +147,15 @@ module Zakuro
         #
         # @param [Context] context 暦コンテキスト
         # @param [Integer] start_year 開始西暦年
-        # @param [Integer] end_year 終了西暦年
+        # @param [Integer] last_year 終了西暦年
         #
         # @return [Array<Base::Year>] 年データ（冬至基準）
         #
-        def annual_ranges(context:, start_year:, end_year:)
+        def annual_ranges(context:, start_year:, last_year:)
           annual_range = context.resolver.annual_range
 
           years = []
-          (start_year..(end_year + 1)).each do |year|
+          (start_year..(last_year + 1)).each do |year|
             years.push(
               annual_range.get(
                 context: context, western_year: year

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

@@ -29,14 +29,14 @@ module Zakuro
         #
         # @param [Context] context 暦コンテキスト
         # @param [Western::Calendar] start_date 開始日
-        # @param [Western::Calendar] end_date 終了日
+        # @param [Western::Calendar] last_date 終了日
         # @param [Array<Year>] years 年データ（完全範囲）
         #
-        def initialize(context:, start_date: Western::Calendar.new, end_date: Western::Calendar.new,
+        def initialize(context:, start_date: Western::Calendar.new, last_date: Western::Calendar.new,
                        years: [])
           @context = context
           @years = years
-          @scroll = Gengou::Scroll.new(start_date: start_date, end_date: end_date)
+          @scroll = Gengou::Scroll.new(start_date: start_date, last_date: last_date)
           @operated_solar_terms = OperatedSolarTerms.new(context: context, years: @years)
           @operated_solar_terms.create
         end
@@ -83,7 +83,6 @@ module Zakuro
         # @param [Array<OperatedYear>] operated_years 運用結果範囲
         #
         def self.move(operated_years:)
-          # FIXME: この方式は完全ではない。範囲の1年前/1年後が必要
           move_into_next_year(operated_years: operated_years)
           move_into_last_year(operated_years: operated_years)
         end

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require_relative '../../../output/response'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Specifier
+      #
+      # 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/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

@@ -63,10 +63,10 @@ module Zakuro
         #
         # 月を特定する
         #
-        # @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

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