wareki 1.1.0 → 2.1.0

data/lib/wareki/common.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'wareki/calendar_def'
+require 'wareki/calendar'
 require 'wareki/era_def'
 require 'date'
 # Wareki module common constants definitions
@@ -9,8 +9,9 @@ module Wareki
   GREGORIAN_START_YEAR = 1873
   IMPERIAL_START = 1_480_041  # Date.new(-660, 2, 11, Date::GREGORIAN).jd
   IMPERIAL_START_YEAR = -660
+  WESTERN_ERA_NAMES = ['', '西暦', '紀元前'].freeze
+  IMPERIAL_ERA_NAMES = %w(皇紀 神武天皇即位紀元).freeze
   DATE_INFINITY = ::Date.new(280_000_000, 12, 31) # Use 280000000 for jruby limitation...
-  YEAR_BY_NUM = Hash[*YEAR_DEFS.map { |y| [y.year, y] }.flatten].freeze
   KANJI_VARIANTS = {
     '宝' => '寳',
     '霊' => '靈',
@@ -42,8 +43,8 @@ module Wareki
   NORMALIZE_KANJI_VARIANTS_HASH = KANJI_VARIANTS.each_with_object({}) { |(n, s), h| s.each_char { |c| h[c] = n } }
   NORMALIZE_KANJI_VARIANTS = ->(str) { str.gsub(NORMALIZE_KANJI_VARIANTS_REGEX, NORMALIZE_KANJI_VARIANTS_HASH) }
   ERA_BY_NAME = Hash[*(ERA_NORTH_DEFS + ERA_DEFS).flat_map { |g| [g.name, g] }]
-  ERA_BY_NAME['皇紀'] = ERA_BY_NAME['神武天皇即位紀元'] = Era.new('皇紀', -660, 1_480_041, DATE_INFINITY.jd)
-  ERA_BY_NAME['西暦'] = ERA_BY_NAME[''] = Era.new('西暦', 1, 1_721_424, DATE_INFINITY.jd)
+  ERA_BY_NAME['皇紀'] = ERA_BY_NAME['神武天皇即位紀元'] = Era.new('皇紀', -660, 1_480_041, DATE_INFINITY.jd).freeze
+  ERA_BY_NAME['西暦'] = ERA_BY_NAME[''] = Era.new('西暦', 1, 1_721_424, DATE_INFINITY.jd).freeze
   ERA_BY_NAME.default_proc = ->(hash, key) { hash.fetch(SQUARE_ERAS[key] || NORMALIZE_KANJI_VARIANTS[key], nil) }
   ERA_BY_NAME.freeze
   ERA_REGEX = Regexp.new(
@@ -58,17 +59,35 @@ module Wareki
     (?:(?<era_name>紀元前|#{ERA_REGEX})?
       (?:(?<year>[元#{NUM_CHARS}]+)年))?
     (?:(?<is_leap>閏|潤|うるう)?
-      (?:(?<month>[正#{NUM_CHARS}]+)月 |
+      (?:(?<month>[正#{NUM_CHARS}]+)(?<is_leap_post>['’])?月 |
          (?<alt_month>#{ALT_MONTH_NAME.join('|')})))?
     (?:(?<day>[元朔晦#{NUM_CHARS}]+)日|元旦)?
   }x.freeze
+  # REGEX が空でないマッチを返すには 年/月/日/元旦 か、「月」を含まない
+  # 月の別名 (弥生・師走) のいずれかが必要。それ以外は素の Date.parse に
+  # 直行させて monkey patch のオーバーヘッドを避ける。
+  PARSE_QUICK_FILTER = /[年月日]|元旦|弥生|師走/.freeze
+  TIME_REGEX = %r{
+    (?<noon>正午) |
+    (?:(?<ampm>午前|午後)[[:space:]]*)?
+    (?<hour>[#{NUM_CHARS}]+)[[:space:]]*時
+    (?:[[:space:]]*
+      (?:(?<half>半) |
+         (?<min>[#{NUM_CHARS}]+)[[:space:]]*分
+         (?:[[:space:]]*(?<sec>[#{NUM_CHARS}]+)[[:space:]]*秒)?))?
+  }x.freeze
+  # TIME_REGEX が非空マッチしうるのは「時」か「正午」を含む文字列のみ
+  TIME_PARSE_QUICK_FILTER = /時|正午/.freeze
 
   class UnsupportedDateRange < StandardError; end
+  class InvalidDate < ArgumentError; end
 
   module_function
 
   def parse_to_date(str, start = ::Date::ITALY)
     Date.parse(str).to_date(start)
+  rescue InvalidDate
+    raise
   rescue ArgumentError
     ::Date.parse(str, true, start)
   end

data/lib/wareki/date.rb

@@ -8,33 +8,25 @@ require 'wareki/kansuji'
 module Wareki
   # Wareki date handling class, main implementation.
   class Date
-    attr_accessor :year, :month, :day, :era_year, :era_name
+    include Comparable
+
+    attr_reader :year, :month, :day, :era_year, :era_name
 
     def self.today
       jd(::Date.today.jd)
     end
 
-    def self._check_invalid_date(era, year, month, day)
-      month == 12 or return true
-      day > 2 or return true
-      (era == '明治' && year == 5 ||
-       %w(皇紀 神武天皇即位紀元).member?(era) &&
-       year == GREGORIAN_START_YEAR - IMPERIAL_START_YEAR - 1) and
-        return false
-      true
-    end
-
     def self._parse(str)
       str = str.to_s.gsub(/[[:space:]]/, '')
       match = REGEX.match(str)
-      match && !match[0].empty? or
+      (match && !match[0].empty?) or
         raise ArgumentError, "Invaild Date: #{str}"
       era = match[:era_name]
       if (era.nil? || era == '') && match[:year].nil?
         year = Date.today.year
       else
-        (year = Utils.k2i(match[:year])) > 0 or
-          raise ArgumentError, "Invalid year: #{str}"
+        year = Utils.k2i(match[:year])
+        year > 0 or raise ArgumentError, "Invalid year: #{str}"
       end
       month = day = 1
 
@@ -48,20 +40,20 @@ module Wareki
       end
 
       month > 12 || month < 1 and
-        raise ArgumentError, "Invalid month: #{str}"
+        raise InvalidDate, "invalid date (month out of range): #{str}"
+
+      is_leap = !!(match[:is_leap] || match[:is_leap_post])
 
       if match[:day]
         if match[:day] == '晦'
-          day = Utils.last_day_of_month(ERA_BY_NAME[era].year + year - 1, month, match[:is_leap])
+          civil_year = Utils.era_year_to_civil(era, year)
+          day = Utils.last_day_of_era_month(era, civil_year, month, is_leap)
         else
           day = Utils.k2i(match[:day])
         end
       end
 
-      _check_invalid_date(era, year, month, day) or
-        raise ArgumentError, "Invaild Date: #{str}"
-
-      {era: era, year: year, month: month, day: day, is_leap: !!match[:is_leap]}
+      {era: era, year: year, month: month, day: day, is_leap: is_leap}
     end
 
     def self.parse(str)
@@ -87,23 +79,13 @@ module Wareki
     end
 
     def initialize(era_name, era_year, month = 1, day = 1, is_leap_month = false)
-      raise ArgumentError, "Undefined era '#{era_name}'" if
-        era_name.to_s != '' && era_name != '紀元前' && !ERA_BY_NAME[era_name]
-
+      @era_name = era_name.to_s
+      @era_year = era_year
       @month = month
       @day = day
       @is_leap_month = is_leap_month
-      @era_name = era_name
-      @era_year = era_year
-      if era_name.to_s == '' || era_name == '西暦'
-        @year = @era_year
-      elsif era_name.to_s == '紀元前'
-        @year = -@era_year
-      elsif %w(皇紀 神武天皇即位紀元).include? era_name
-        @year = era_year + IMPERIAL_START_YEAR
-      else
-        @year = ERA_BY_NAME[era_name].year + era_year - 1
-      end
+      @year = Utils.era_year_to_civil(@era_name, @era_year)
+      _validate_date!
     end
 
     def imperial_year
@@ -111,7 +93,7 @@ module Wareki
     end
 
     def imperial_year=(v)
-      @year = v - IMPERIAL_START_YEAR
+      self.year = v + IMPERIAL_START_YEAR
     end
 
     def leap_month?
@@ -119,36 +101,92 @@ module Wareki
     end
 
     def leap_month=(v)
+      @jd = nil
       @is_leap_month = v
     end
 
+    def year=(v)
+      era_year = Utils.civil_to_era_year(@era_name, v)
+      @jd = nil
+      @year = v
+      @era_year = era_year
+    end
+
+    def month=(v)
+      @jd = nil
+      @month = v
+    end
+
+    def day=(v)
+      @jd = nil
+      @day = v
+    end
+
+    def era_year=(v)
+      year = Utils.era_year_to_civil(@era_name, v)
+      @jd = nil
+      @era_year = v
+      @year = year
+    end
+
+    def era_name=(v)
+      era_name = v.to_s
+      year = Utils.era_year_to_civil(era_name, @era_year)
+      @jd = nil
+      @era_name = era_name
+      @year = year
+    end
+
     def __set_jd(v)
       @jd = v
     end
 
     def month_index
       return month - 1 if
-        ['', '西暦', '紀元前'].include?(@era_name) || @year >= GREGORIAN_START_YEAR
+        WESTERN_ERA_NAMES.include?(@era_name) || @year >= GREGORIAN_START_YEAR
 
-      yobj = YEAR_BY_NUM[@year] or
+      Calendar.covers_year?(@year) or
         raise UnsupportedDateRange, "Cannot get year info of #{inspect}"
-      idx = month - 1
-      idx += 1 if leap_month? || yobj.leap_month && month > yobj.leap_month
-      idx
+      Calendar.month_index(@year, month, leap_month?)
+    end
+
+    def last_day_of_month
+      Utils.last_day_of_era_month(@era_name, @year, month, leap_month?)
+    end
+
+    def _validate_date!
+      (month.is_a?(Integer) && month >= 1 && month <= 12) or
+        raise InvalidDate, "invalid date (month out of range): #{inspect}"
+      (day.is_a?(Integer) && day >= 1) or
+        raise InvalidDate, "invalid date (day out of range): #{inspect}"
+      if !WESTERN_ERA_NAMES.include?(@era_name) && @year < GREGORIAN_START_YEAR
+        # 暦テーブル外の年は従来どおり jd 変換時の UnsupportedDateRange に委ねる
+        Calendar.covers_year?(@year) or return
+        !leap_month? || Calendar.leap_month(@year) == month or
+          raise InvalidDate, "invalid date (no leap month): #{inspect}"
+        day <= Calendar.last_day_of_month(@year, month, leap_month?) or
+          raise InvalidDate, "invalid date (day out of range): #{inspect}"
+      else
+        leap_month? and
+          raise InvalidDate, "invalid date (no leap month): #{inspect}"
+        day <= last_day_of_month or
+          raise InvalidDate, "invalid date (day out of range): #{inspect}"
+      end
     end
 
     def jd
       @jd and return @jd
 
-      ['', '西暦', '紀元前'].include?(@era_name) and
+      _validate_date!
+      WESTERN_ERA_NAMES.include?(@era_name) and
         return @jd = ::Date.new(@year, month, day, ::Date::ITALY).jd
 
       @year >= GREGORIAN_START_YEAR and
         return @jd = ::Date.new(@year, month, day, ::Date::GREGORIAN).jd
 
-      yobj = YEAR_BY_NUM[@year] or
+      @jd = Calendar.to_jd(@year, month, day, leap_month?) or
         raise UnsupportedDateRange, "Cannot convert to jd #{inspect}"
-      @jd = yobj.month_starts[month_index] + day - 1
+      @jd
     end
 
     def to_date(start = ::Date::ITALY)
@@ -159,61 +197,72 @@ module Wareki
       to_date.to_time
     end
 
+    FORMAT_DIRECTIVE_REGEX = /%J(-|[_0]{0,2}[0-9]*|)([fFyYegGoOiImMsSlLdD][kK]?)/.freeze
+    FORMAT_EXPANSION_REGEX = /(?<!%)(?:%%)*\K#{FORMAT_DIRECTIVE_REGEX}/.freeze
+
+    def expand_wareki_format(format_str)
+      format_str.to_str.gsub(FORMAT_EXPANSION_REGEX) { format($2, $1) || $& }
+    end
+
     def strftime(format_str = '%JF')
-      ret = format_str.to_str.gsub(/%J([fFyYegGoOiImMsSlLdD][kK]?)/) { format($1) || $& }
+      ret = expand_wareki_format(format_str)
       ret.index('%') or return ret
       d = to_date
       d.respond_to?(:_wareki_strftime_orig) ? d._wareki_strftime_orig(ret) : d.strftime(ret)
     end
 
-    def format(key)
+    def _number_format(opt)
+      Utils.number_format(opt)
+    end
+
+    def format(key, opt = '')
       case key.to_sym
       when :e  then era_name
-      when :g  then era_name.to_s == '' ? '' : era_year
+      when :g  then era_name.to_s == '' ? '' : Kernel.format(_number_format(opt), era_year)
       when :G  then era_name.to_s == '' ? '' : Utils.i2z(era_year)
-      when :Gk then era_name.to_s == '' ? '' : YaKansuji.to_kan(era_year, :simple)
+      when :Gk then era_name.to_s == '' ? '' : Utils.to_simple_kan(era_year)
       when :GK
         if era_name.to_s == ''
           ''
         elsif era_year == 1
           '元'
         else
-          YaKansuji.to_kan(era_year, :simple)
+          Utils.to_simple_kan(era_year)
         end
       when :o  then year
       when :O  then Utils.i2z(year)
-      when :Ok then YaKansuji.to_kan(year, :simple)
+      when :Ok then Utils.to_simple_kan(year)
       when :i  then imperial_year
       when :I  then Utils.i2z(imperial_year)
-      when :Ik then YaKansuji.to_kan(imperial_year, :simple)
-      when :s  then month
+      when :Ik then Utils.to_simple_kan(imperial_year)
+      when :s  then Kernel.format(_number_format(opt), month)
       when :S  then Utils.i2z(month)
-      when :Sk then YaKansuji.to_kan(month, :simple)
+      when :Sk then Utils.to_simple_kan(month)
       when :SK then Utils.alt_month_name(month)
       when :l  then leap_month? ? "'" : ''
       when :L  then leap_month? ? '’' : ''
       when :Lk then leap_month? ? '閏' : ''
-      when :d  then day
+      when :d  then Kernel.format(_number_format(opt), day)
       when :D  then Utils.i2z(day)
-      when :Dk then YaKansuji.to_kan(day, :simple)
+      when :Dk then Utils.to_simple_kan(day)
       when :DK
         if month == 1 && !leap_month? && day == 1
           '元'
         elsif day == 1
           '朔'
-        elsif day == Utils.last_day_of_month(year, month, leap_month?)
+        elsif day == last_day_of_month
           '晦'
         else
-          YaKansuji.to_kan(day, :simple)
+          Utils.to_simple_kan(day)
         end
-      when :m  then "#{format(:s)}#{format(:l)}"
+      when :m  then "#{format(:s, opt)}#{format(:l)}"
       when :M  then "#{format(:Lk)}#{format(:S)}"
       when :Mk then "#{format(:Lk)}#{format(:Sk)}"
-      when :y  then "#{format(:e)}#{format(:g)}"
+      when :y  then "#{format(:e)}#{format(:g, opt)}"
       when :Y  then "#{format(:e)}#{format(:G)}"
       when :Yk then "#{format(:e)}#{format(:Gk)}"
       when :YK then "#{format(:e)}#{format(:GK)}"
-      when :f  then "#{format(:e)}#{format(:g)}年#{format(:s)}#{format(:l)}月#{format(:d)}日"
+      when :f  then "#{format(:e)}#{format(:g, opt)}年#{format(:s, opt)}#{format(:l)}月#{format(:d, opt)}日"
       when :F  then "#{format(:e)}#{format(:GK)}年#{format(:Lk)}#{format(:Sk)}月#{format(:Dk)}日"
       end
     end
@@ -239,20 +288,48 @@ module Wareki
       true
     end
 
+    def hash
+      [self.class, @era_name, @era_year, @year, @month, @day, leap_month?].hash
+    end
+
+    def <=>(other)
+      ojd = _jd_if_date_like(other)
+      ojd = other if ojd.nil? && other.is_a?(Numeric)
+      ojd.nil? and return nil
+      jd <=> ojd
+    end
+
+    def succ
+      self + 1
+    end
+
     def -(other)
-      self.class.jd jd - _to_jd_for_calc(other)
+      n = _to_days(other)
+      n.nil? or return self.class.jd(jd - n)
+      ojd = _jd_if_date_like(other)
+      ojd and return jd - ojd
+      raise TypeError, "Cannot subtract #{other.inspect} from Wareki::Date"
     end
 
     def +(other)
-      self.class.jd jd + _to_jd_for_calc(other)
+      n = _to_days(other)
+      n.nil? and raise TypeError, "Cannot add #{other.inspect} to Wareki::Date"
+      self.class.jd(jd + n)
     end
 
-    def _to_jd_for_calc(other)
-      other.class.to_s == 'ActiveSupport::Duration' and
-        raise NotImplementedError, 'Date calcration with ActiveSupport::Duration currently is not supported. Please use numeric.'
-      other.respond_to?(:to_date) and other = other.to_date
-      other.respond_to?(:jd) and other = other.jd
-      other
+    def _to_days(other)
+      # rubocop:disable Style/ClassEqualityComparison
+      return other.in_days if other.class.name == 'ActiveSupport::Duration'
+      # rubocop:enable Style/ClassEqualityComparison
+
+      other.is_a?(Numeric) ? other : nil
+    end
+
+    def _jd_if_date_like(other)
+      return other.jd if other.respond_to?(:jd)
+
+      other.respond_to?(:to_date) && !other.is_a?(Numeric) and other = other.to_date
+      other.respond_to?(:jd) ? other.jd : nil
     end
   end
 end

data/lib/wareki/era_def.rb

@@ -1,12 +1,15 @@
 # frozen_string_literal: true
 # coding: utf-8
+
+# Generated by build-util/gen-era-def.rb from manakai data-locale era-defs.json.
+# Do not edit this file directly.
 module Wareki
   DAY_MAX = 1684383730585466947585
   Era = Struct.new(:name, :year, :start, :end)
   ERA_DEFS = [
     Era.new("大化", 645, 1956842, 1958551),
-    Era.new("白雉", 650, 1958551, 1960259),
-    Era.new("朱鳥", 686, 1971845, 1971893),
+    Era.new("白雉", 650, 1958551, 1960339),
+    Era.new("朱鳥", 686, 1971845, 1972033),
     Era.new("大宝", 701, 1977221, 1978361),
     Era.new("慶雲", 704, 1978361, 1979692),
     Era.new("和銅", 708, 1979692, 1982487),
@@ -163,9 +166,9 @@ module Wareki
     Era.new("建武", 1334, 2208365, 2209133),
     Era.new("延元", 1336, 2209133, 2210638),
     Era.new("興国", 1340, 2210638, 2213069),
-    Era.new("正平", 1346, 2213069, 2221678),
-    Era.new("建徳", 1370, 2221678, 2222302),
-    Era.new("文中", 1372, 2222302, 2223453),
+    Era.new("正平", 1346, 2213069, 2221512),
+    Era.new("建徳", 1370, 2221512, 2222332),
+    Era.new("文中", 1372, 2222332, 2223453),
     Era.new("天授", 1375, 2223453, 2225533),
     Era.new("弘和", 1381, 2225533, 2226702),
     Era.new("元中", 1384, 2226702, 2229809),
@@ -252,11 +255,11 @@ module Wareki
     Era.new("昭和", 1926, 2424875, 2447534),
     Era.new("平成", 1989, 2447535, 2458604),
     Era.new("令和", 2019, 2458605, DAY_MAX),
-  ].freeze
+  ].each(&:freeze).freeze
   ERA_NORTH_DEFS = [
     Era.new("大化", 645, 1956842, 1958551),
-    Era.new("白雉", 650, 1958551, 1960259),
-    Era.new("朱鳥", 686, 1971845, 1971893),
+    Era.new("白雉", 650, 1958551, 1960339),
+    Era.new("朱鳥", 686, 1971845, 1972033),
     Era.new("大宝", 701, 1977221, 1978361),
     Era.new("慶雲", 704, 1978361, 1979692),
     Era.new("和銅", 708, 1979692, 1982487),
@@ -407,15 +410,15 @@ module Wareki
     Era.new("元亨", 1321, 2203634, 2205008),
     Era.new("正中", 1324, 2205008, 2205527),
     Era.new("嘉暦", 1326, 2205527, 2206740),
-    Era.new("元徳", 1329, 2206740, 2207459),
+    Era.new("元徳", 1329, 2206740, 2207714),
     Era.new("元弘", 1331, 2207459, 2208365),
     Era.new("正慶", 1332, 2207714, 2208124),
     Era.new("建武", 1334, 2208365, 2210046),
     Era.new("延元", 1336, 2209133, 2210638),
     Era.new("興国", 1340, 2210638, 2213069),
-    Era.new("正平", 1346, 2213069, 2221678),
-    Era.new("建徳", 1370, 2221678, 2222302),
-    Era.new("文中", 1372, 2222302, 2223453),
+    Era.new("正平", 1346, 2213069, 2221512),
+    Era.new("建徳", 1370, 2221512, 2222332),
+    Era.new("文中", 1372, 2222332, 2223453),
     Era.new("天授", 1375, 2223453, 2225533),
     Era.new("弘和", 1381, 2225533, 2226702),
     Era.new("元中", 1384, 2226702, 2229809),
@@ -502,5 +505,5 @@ module Wareki
     Era.new("昭和", 1926, 2424875, 2447534),
     Era.new("平成", 1989, 2447535, 2458604),
     Era.new("令和", 2019, 2458605, DAY_MAX),
-  ].freeze
+  ].each(&:freeze).freeze
 end

data/lib/wareki/std_ext.rb

@@ -5,8 +5,26 @@ require 'wareki/date'
 module Wareki
   # :nodoc:
   module StdExt
+    module_function
+
+    def wareki_directive?(format)
+      !!(format.to_str =~ Wareki::Date::FORMAT_EXPANSION_REGEX)
+    end
+
+    def wareki_time_directive?(format)
+      !!(format.to_str =~ Wareki::Utils::TIME_FORMAT_EXPANSION_REGEX)
+    end
+
+    # %JT 時刻トークンと %J 日付トークンの両方を展開した文字列を返す
+    def expand_all_wareki_formats(format, datetime)
+      ret = format
+      ret = Wareki::Utils.expand_time_format(ret, datetime) if wareki_time_directive?(ret)
+      ret = datetime.to_wareki_date.expand_wareki_format(ret) if wareki_directive?(ret)
+      ret
+    end
   end
 end
+
 # :nodoc:
 class Date
   JAPAN = Wareki::GREGORIAN_START
@@ -17,29 +35,59 @@ class Date
 
   alias _wareki_strftime_orig strftime
   def strftime(format = '%F')
-    if format.index('%J')
-      to_wareki_date.strftime(format)
-    else
-      _wareki_strftime_orig(format)
-    end
+    return _wareki_strftime_orig(format) unless Wareki::StdExt.wareki_directive?(format)
+
+    _wareki_strftime_orig(to_wareki_date.expand_wareki_format(format))
   end
 
   class << self
     alias _wareki_parse_orig parse
     def parse(str = '-4712-01-01', comp = true, start = ::Date::ITALY)
+      return ::Date._wareki_parse_orig(str, comp, start) if str.to_s.ascii_only?
+
+      str = Wareki::Utils.normalize_time(str)
+      str.to_s =~ Wareki::PARSE_QUICK_FILTER or
+        return ::Date._wareki_parse_orig(str, comp, start)
       Wareki::Date.parse(str).to_date(start)
-    rescue ArgumentError, Wareki::UnsupportedDateRange
+    rescue Wareki::InvalidDate
+      raise
+    rescue ArgumentError
       ::Date._wareki_parse_orig(str, comp, start)
     end
 
     alias _wareki__parse_orig _parse
     def _parse(str, comp = true)
+      return ::Date._wareki__parse_orig(str, comp) if str.to_s.ascii_only?
+
+      str = Wareki::Utils.normalize_time(str)
+      str.to_s =~ Wareki::PARSE_QUICK_FILTER or
+        return ::Date._wareki__parse_orig(str, comp)
       di = Wareki::Date._parse(str)
       wdate = Wareki::Date.new(di[:era], di[:year], di[:month], di[:day], di[:is_leap])
-    rescue ArgumentError, Wareki::UnsupportedDateRange
+    rescue ArgumentError
       ::Date._wareki__parse_orig(str, comp)
     else
       ::Date._wareki__parse_orig(str.sub(Wareki::REGEX, wdate.strftime('%F ')), comp)
     end
   end
 end
+
+# :nodoc:
+class DateTime
+  alias _wareki_strftime_orig strftime
+  def strftime(format = '%FT%T%:z')
+    _wareki_strftime_orig(Wareki::StdExt.expand_all_wareki_formats(format, self))
+  end
+end
+
+# :nodoc:
+class Time
+  def to_wareki_date
+    Wareki::Date.jd(to_date.jd)
+  end
+
+  alias _wareki_strftime_orig strftime
+  def strftime(format)
+    _wareki_strftime_orig(Wareki::StdExt.expand_all_wareki_formats(format, self))
+  end
+end