zakuro 0.5.0 → 0.6.0

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/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

data/lib/zakuro/era/japan/calendar.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative '../../tools/typeconv'
+
+# :nodoc:
+module Zakuro
+  #
+  # Japan 和暦
+  #
+  module Japan
+    #
+    # Calendar 年月日情報（和暦）
+    #
+    class Calendar
+      # @return [Integer] 無効値
+      INVALID = -1
+      # @return [String] 空文字列
+      EMPTY = ''
+      # @return [String] 閏を示す文字列
+      LEAPED_TEXT = '閏'
+      # @return [Regexp] 和暦日フォーマット
+      FORMAT = /^([一-龥]{2,4})([0-9]+)年(#{LEAPED_TEXT})?([0-9]+)月([0-9]+)日$/.freeze
+      # @return [String] 出力用デフォルトフォーマット
+      DEFAULT_OUTPUT_FORM = '%s%02d年%s%02d月%02d日'
+
+      # @return [String] 元号
+      attr_reader :gengou
+      # @return [Integer] 元号年
+      attr_reader :year
+      # @return [True] 閏あり
+      # @return [False] 閏なし
+      attr_reader :leaped
+      # @return [Integer] 月
+      attr_reader :month
+      # @return [Integer] 日
+      attr_reader :day
+
+      #
+      # 初期化
+      #
+      # @param [String] gengou 元号
+      # @param [Integer] year 元号年
+      # @param [True, False] leaped 閏
+      # @param [Integer] month 月
+      # @param [Integer] day 日
+      #
+      def initialize(gengou: EMPTY, year: INVALID, leaped: false, month: INVALID, day: INVALID)
+        @gengou = gengou
+        @year = year
+        @leaped = leaped
+        @month = month
+        @day = day
+      end
+
+      #
+      # 無効か
+      #
+      # @return [True] 無効
+      # @return [False] 有効
+      #
+      def invalid?
+        @gengou == EMPTY || @year == INVALID || @month == INVALID || @day == INVALID
+      end
+
+      #
+      # 文字列にする
+      #
+      # @return [String] 和暦日フォーマット文字列
+      #
+      def format(form: DEFAULT_OUTPUT_FORM)
+        leaped_text = @leaped ? LEAPED_TEXT : ''
+        super(form, @gengou, @year, leaped_text, @month, @day)
+      end
+
+      #
+      # 同月か
+      #   年と日は無視する
+      #
+      # @param [True, False] leaped 閏
+      # @param [Integer] month 月
+      #
+      # @return [True] 同月
+      # @return [True] 同月ではない
+      #
+      def same_month?(leaped:, month:)
+        return false unless @leaped == leaped
+
+        @month == month
+      end
+
+      #
+      # 年月日情報（和暦）を生成する
+      #
+      # @param [Regexp] regex 正規表現
+      # @param [String] text 和暦日文字列
+      #
+      # @return [Calendar] 年月日情報（和暦）
+      #
+      def self.parse(regex: FORMAT, text: '')
+        return Calendar.new unless valid_date_string(regex: regex, text: text)
+
+        matched = text.match(regex)
+
+        Calendar.new(
+          gengou: matched[1],
+          year: Tools::Typeconv.to_i(text: matched[2], default: INVALID),
+          leaped: matched[3] ? true : false,
+          month: Tools::Typeconv.to_i(text: matched[4], default: INVALID),
+          day: Tools::Typeconv.to_i(text: matched[5], default: INVALID)
+        )
+      end
+
+      #
+      # 日付文字列を検証する
+      #
+      # @param [Regexp] regex 正規表現
+      # @param [String] text 和暦日文字列
+      #
+      # @return [True] 正しい
+      # @return [True] 正しくない
+      #
+      def self.valid_date_string(regex: FORMAT, text: '')
+        return false unless text
+
+        matched = text.match(regex)
+
+        return false unless matched
+
+        matched.size == 6
+      end
+    end
+  end
+end

data/lib/zakuro/era/japan/gengou/parser.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../../western'
+require_relative '../../western/calendar'
 require_relative './type'
 require_relative './validator'
 require 'yaml'
@@ -17,8 +17,6 @@ module Zakuro
     # Parser yaml解析
     #
     module Parser
-      # :reek:TooManyInstanceVariables { max_instance_variables: 5 }
-
       #
       # GengouParser 元号情報の検証/展開を行う
       #
@@ -27,12 +25,10 @@ module Zakuro
         attr_reader :index
         # @return [String] 元号名
         attr_reader :name
-        # @return [String] 開始日
-        attr_reader :start_date
-        # @return [String] 元旦
-        attr_reader :new_year_date
-        # @return [String] 開始年
-        attr_reader :start_year
+        # @return [Hash<String, String>] 開始年
+        attr_reader :both_start_year
+        # @return [Hash<String, String>] 開始日
+        attr_reader :both_start_date
 
         #
         # 初期化
@@ -43,9 +39,8 @@ module Zakuro
         def initialize(hash:, index:)
           @index = index
           @name = hash['name']
-          @start_date = hash['start_date']
-          @new_year_date = hash['new_year_date']
-          @start_year = hash['start_year']
+          @both_start_year = hash['start_year']
+          @both_start_date = hash['start_date']
         end
 
         #
@@ -54,12 +49,11 @@ module Zakuro
         # @return [Gengou] 元号情報
         #
         def create
-          start_date = Western::Calendar.parse(str: @start_date)
-          new_year_date = Western::Calendar.parse(str: @new_year_date)
-          start_year = @start_year || 1
+          both_start_year = Both::YearParser.new(hash: @both_start_year).create
+          both_start_date = Both::DateParser.new(hash: @both_start_date).create
 
-          Gengou.new(name: @name, start_date: start_date, new_year_date: new_year_date,
-                     year: start_year)
+          Gengou.new(name: @name, both_start_year: both_start_year,
+                     both_start_date: both_start_date)
         end
       end
 
@@ -71,8 +65,10 @@ module Zakuro
         attr_reader :id
         # @return [String] 元号セット名
         attr_reader :name
-        # @return [String] 終了日
-        attr_reader :end_date
+        # @return [Hash<String, String>] 終了年
+        attr_reader :both_end_year
+        # @return [Hash<String, String>] 終了日
+        attr_reader :both_end_date
         # @return [Array<Hash<String, String>>] 元号情報
         attr_reader :list
 
@@ -84,7 +80,8 @@ module Zakuro
         def initialize(hash:)
           @id = hash['id']
           @name = hash['name']
-          @end_date = hash['end_date']
+          @both_end_year = hash['end_year']
+          @both_end_date = hash['end_date']
           @list = hash['list']
         end
 
@@ -94,10 +91,10 @@ module Zakuro
         # @return [Set] 元号セット情報
         #
         def create
-          end_date = Western::Calendar.parse(str: @end_date)
+          both_end_date = Both::DateParser.new(hash: @both_end_date).create
           list = create_list
           Set.new(
-            id: @id, name: @name, end_date: end_date, list: list
+            id: @id, name: @name, both_end_date: both_end_date, list: list
           )
         end
 
@@ -133,18 +130,91 @@ module Zakuro
         #
         def calc_end_date_on_gengou_data(next_index:, gengou:)
           if next_index >= @list.size
-            end_date = Western::Calendar.parse(str: @end_date)
+            gengou.write_end_year(end_year: @both_end_year['western'])
+            end_date = Western::Calendar.parse(str: @both_end_date['western'])
             gengou.write_end_date(end_date: end_date)
             return gengou
           end
-          next_start_date = @list[next_index]['start_date']
+          next_item = @list[next_index]
+          gengou.convert_next_start_year_to_end_year(
+            next_start_year: next_item['start_year']['western']
+          )
           gengou.convert_next_start_date_to_end_date(
-            next_start_date_string: next_start_date
+            next_start_date: next_item['start_date']['western']
           )
           gengou
         end
       end
 
+      #
+      # 和暦/西暦
+      #
+      module Both
+        #
+        # YearParser 年
+        #
+        class YearParser
+          # @return [Integer] 和暦元号年
+          attr_reader :japan
+          # @return [Integer] 西暦年
+          attr_reader :western
+
+          #
+          # 初期化
+          #
+          # @param [Hash<String, Object>] hash 年情報
+          #
+          def initialize(hash:)
+            @japan = hash['japan']
+            @western = hash['western']
+          end
+
+          #
+          # 年情報を生成する
+          #
+          # @return [Both::Year] 年情報
+          #
+          def create
+            japan = @japan.to_i
+            western = @western.to_i
+
+            Japan::Both::Year.new(japan: japan, western: western)
+          end
+        end
+
+        #
+        # DateParser 日
+        #
+        class DateParser
+          # @return [Japan::Calendar] 和暦日
+          attr_reader :japan
+          # @return [Western::Calendar] 西暦日
+          attr_reader :western
+
+          #
+          # 初期化
+          #
+          # @param [Hash<String, Object>] hash 日情報
+          #
+          def initialize(hash:)
+            @japan = hash['japan']
+            @western = hash['western']
+          end
+
+          #
+          # 日情報を生成する
+          #
+          # @return [Both::Date] 日情報
+          #
+          def create
+            japan = Japan::Calendar.parse(text: @japan)
+            western = Western::Calendar.parse(str: @western)
+
+            Japan::Both::Date.new(japan: japan, western: western)
+          end
+        end
+      end
+
       #
       # 解析/展開する
       #