zakuro 0.2.0 → 0.6.0

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

@@ -2,7 +2,9 @@
 
 require_relative './operated_solar_terms'
 require_relative '../../operation/operation'
+require_relative '../base/operated_year'
 require_relative '../../calculation/monthly/operated_month'
+require_relative './transfer/gengou_scroller'
 
 # :nodoc:
 module Zakuro
@@ -26,11 +28,15 @@ module Zakuro
         # 初期化
         #
         # @param [Context] context 暦コンテキスト
+        # @param [Western::Calendar] start_date 開始日
+        # @param [Western::Calendar] end_date 終了日
         # @param [Array<Year>] years 年データ（完全範囲）
         #
-        def initialize(context:, years: [])
+        def initialize(context:, start_date: Western::Calendar.new, end_date: Western::Calendar.new,
+                       years: [])
           @context = context
           @years = years
+          @scroll = Gengou::Scroll.new(start_date: start_date, end_date: end_date)
           @operated_solar_terms = OperatedSolarTerms.new(context: context, years: @years)
           @operated_solar_terms.create
         end
@@ -41,20 +47,28 @@ module Zakuro
         # @return [Array<Year>] 運用結果範囲
         #
         def get
-          rewrite
+          operated_years = rewrite
+
+          OperatedRange.move(operated_years: operated_years)
+
+          OperatedRange.commit(operated_years: operated_years)
+
+          Transfer::GengouScroller.set(scroll: @scroll, years: operated_years)
+
+          operated_years
         end
 
         #
         # 運用結果に書き換える
         #
-        # @return [Array<Year>] 運用結果範囲
+        # @return [Array<OperatedYear>] 運用結果範囲
         #
         def rewrite
           operated_years = []
 
           years.each do |year|
             operated_year = OperatedRange.rewrite_year(
-              context: context, year: year,
+              year: year,
               operated_solar_terms: @operated_solar_terms
             )
             operated_years.push(operated_year)
@@ -63,19 +77,65 @@ module Zakuro
           operated_years
         end
 
+        #
+        # 運用情報で年を跨ぐ月をその年に寄せる
+        #
+        # @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
+
+        #
+        # 運用情報では来年に属する月を来年に寄せる
+        #
+        # @param [Array<OperatedYear>] operated_years 運用結果範囲
+        #
+        def self.move_into_next_year(operated_years:)
+          operated_years.each_cons(2) do |current_year, next_year|
+            months = current_year.pop_next_year_months
+
+            next_year.unshift_months(months)
+          end
+        end
+
+        #
+        # 運用情報では昨年に属する月を昨年に寄せる
+        #
+        # @param [Array<OperatedYear>] operated_years 運用結果範囲
+        #
+        def self.move_into_last_year(operated_years:)
+          rerversed_year = operated_years.reverse!
+          rerversed_year.each_cons(2) do |current_year, last_year|
+            months = current_year.shift_last_year_months
+            last_year.push_months(months)
+          end
+
+          rerversed_year.reverse!
+        end
+
+        #
+        # 年を確定させる
+        #
+        # @param [Array<OperatedYear>] operated_years 運用結果範囲
+        #
+        def self.commit(operated_years:)
+          operated_years.each(&:commit)
+        end
+
         #
         # 年を書き換える
         #
-        # @param [Context] context 暦コンテキスト
         # @param [Year] year 年
         # @param [OperatedSolarTerms] operated_solar_terms 運用時二十四節気
         #
-        # @return [Year] 年
+        # @return [OperatedYear] 年
         #
-        def self.rewrite_year(context:, year:, operated_solar_terms:)
-          result = Base::Year.new(
-            multi_gengou: year.multi_gengou, new_year_date: year.new_year_date
-          )
+        def self.rewrite_year(year:, operated_solar_terms:)
+          context = year.context
+          result = Base::OperatedYear.new(context: context)
           year.months.each do |month|
             result.push(month: resolve_month(
               context: context, month: month,
@@ -83,8 +143,6 @@ module Zakuro
             ))
           end
 
-          result.commit
-
           result
         end
 
@@ -100,8 +158,6 @@ module Zakuro
         def self.resolve_month(context:, month:, operated_solar_terms:)
           history = Operation.specify_history(western_date: month.western_date)
 
-          return month if history.invalid?
-
           OperatedRange.rewrite_month(
             context: context, month: month, history: history,
             operated_solar_terms: operated_solar_terms
@@ -121,22 +177,16 @@ module Zakuro
         # @return [Month] 月（運用結果）
         #
         def self.rewrite_month(context:, month:, history:, operated_solar_terms:)
-          return month unless month.western_date == history.western_date
-
           operated_month = Monthly::OperatedMonth.new(
             context: context,
             month_label: month.month_label, first_day: month.first_day,
-            solar_terms: month.solar_terms, history: history,
+            solar_terms: month.solar_terms, history: history, gengou: month.gengou,
             operated_solar_terms: operated_solar_terms
           )
 
-          operated_month.rewrite
+          operated_month.rewrite unless history.invalid?
 
-          Monthly::Month.new(
-            context: context,
-            month_label: operated_month.month_label, first_day: operated_month.first_day,
-            solar_terms: operated_month.solar_terms
-          )
+          operated_month
         end
       end
     end

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

@@ -57,6 +57,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 +70,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 +180,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/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,35 +45,18 @@ 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 }
 
@@ -93,14 +71,14 @@ module Zakuro
         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/stella/lunar/abstract_location.rb

@@ -46,6 +46,15 @@ module Zakuro
           # abstract
         end
 
+        #
+        # 1始まりの大余小余を取得する
+        #
+        # @return [Cycle::AbstractRemainder] 1始まりの大余小余
+        #
+        def adjusted_remainder
+          @remainder.add(Cycle::AbstractRemainder.new(day: 1, minute: 0, second: 0))
+        end
+
         private
 
         #
@@ -63,13 +72,6 @@ module Zakuro
         def decrease(limit:)
           # abstract
         end
-
-        #
-        # 1始まりにする
-        #
-        def one_based
-          @remainder.add!(Cycle::AbstractRemainder.new(day: 1, minute: 0, second: 0))
-        end
       end
     end
   end

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

@@ -30,6 +30,25 @@ module Zakuro
           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!
+
+          [adjusted.day, adjusted.minute]
+        end
+
         def self.day_only(remainder_minute:, denominator:)
           float_day = Type::OldFloat.new(remainder_minute / denominator)
           # 切り捨て（プラスマイナスに関わらず小数点以下切り捨て）

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

@@ -32,11 +32,14 @@ module Zakuro
             years: years, date: date
           )
 
-          operated_range = Calculation::Range::OperatedRange.new(context: context, years: years)
+          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_range.get, date: date
+              years: operated_years, date: date
             ),
             operation: create_operation(calc_date: calc_date)
           )

data/lib/zakuro/calculation/version/internal/crawler.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative '../../../era/japan/version'
+require_relative './range'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Version
+      #
+      # 暦検索
+      #
+      module Crawler
+        #
+        # 暦の範囲を取得する
+        #
+        # @param [Integer] start_year 開始西暦年
+        # @param [Integer] end_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)
+
+          result = []
+
+          ranges.each do |range|
+            next unless range.released
+
+            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
+
+            result.push(
+              Range.new(
+                name: range.name, start_date: range.start_date.clone,
+                start_year: range_start_year, end_year: range_end_year
+              )
+            )
+          end
+
+          result
+        end
+      end
+    end
+  end
+end

data/lib/zakuro/calculation/version/internal/range.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Version
+      #
+      # Range 暦（範囲）
+      #
+      class Range
+        # @return [String] 暦名
+        attr_reader :name
+        # @return [Western::Calendar] 暦の開始日
+        attr_reader :start_date
+        # @return [Integer] 開始西暦年
+        attr_reader :start_year
+        # @return [Integer] 終了西暦年
+        attr_reader :end_year
+
+        #
+        # 初期化
+        #
+        # @param [String] name 暦名
+        # @param [Western::Calendar] start_date 暦の開始日
+        # @param [Integer] start_year 開始西暦年
+        # @param [Integer] end_year 終了西暦年
+        #
+        def initialize(name:, start_date:, start_year:, end_year:)
+          @name = name
+          @start_date = start_date
+          @start_year = start_year
+          @end_year = end_year
+        end
+      end
+    end
+  end
+end

data/lib/zakuro/calculation/version/version.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative './internal/crawler'
+
+# :nodoc:
+module Zakuro
+  # :nodoc:
+  module Calculation
+    # :nodoc:
+    module Version
+      #
+      # 暦の範囲を取得する
+      #
+      # @param [Integer] start_year 開始西暦年
+      # @param [Integer] end_year 終了西暦年
+      #
+      # @return [Array<Range>] 暦の範囲
+      #
+      def self.get(start_year:, end_year:)
+        Crawler.get(start_year: start_year, end_year: end_year)
+      end
+    end
+  end
+end