From bae5812eab6c5e11cc11ff259a7f6f28bd95b976 Mon Sep 17 00:00:00 2001 From: jinroq Date: Wed, 11 Feb 2026 21:55:57 +0900 Subject: [PATCH 01/11] Replace Date and DateTime classes from C to Ruby. C implementation has been rewritten as faithfully as possible in pure Ruby. [Feature #21264] https://bugs.ruby-lang.org/issues/21264 --- Rakefile | 61 +- date.gemspec | 24 +- ext/date/extconf.rb | 21 +- lib/date.rb | 17 +- lib/date/constants.rb | 182 ++ lib/date/core.rb | 3693 +++++++++++++++++++++++++++++++++++++++++ lib/date/datetime.rb | 826 +++++++++ lib/date/parse.rb | 2607 +++++++++++++++++++++++++++++ lib/date/patterns.rb | 403 +++++ lib/date/strftime.rb | 600 +++++++ lib/date/strptime.rb | 769 +++++++++ lib/date/time.rb | 59 + lib/date/version.rb | 5 + lib/date/zonetab.rb | 405 +++++ 14 files changed, 9619 insertions(+), 53 deletions(-) create mode 100644 lib/date/constants.rb create mode 100644 lib/date/core.rb create mode 100644 lib/date/datetime.rb create mode 100644 lib/date/parse.rb create mode 100644 lib/date/patterns.rb create mode 100644 lib/date/strftime.rb create mode 100644 lib/date/strptime.rb create mode 100644 lib/date/time.rb create mode 100644 lib/date/version.rb create mode 100644 lib/date/zonetab.rb diff --git a/Rakefile b/Rakefile index 933384c0..06175d09 100644 --- a/Rakefile +++ b/Rakefile @@ -1,30 +1,47 @@ require "bundler/gem_tasks" require "rake/testtask" -require "shellwords" -require "rake/extensiontask" -extask = Rake::ExtensionTask.new("date") do |ext| - ext.name = "date_core" - ext.lib_dir.sub!(%r[(?=/|\z)], "/#{RUBY_VERSION}/#{ext.platform}") -end +if RUBY_VERSION >= "3.3" + # Pure Ruby — no compilation needed + Rake::TestTask.new(:test) do |t| + t.libs << "lib" + t.libs << "test/lib" + t.ruby_opts << "-rhelper" + t.test_files = FileList['test/**/test_*.rb'] + end -Rake::TestTask.new(:test) do |t| - t.libs << extask.lib_dir - t.libs << "test/lib" - t.ruby_opts << "-rhelper" - t.test_files = FileList['test/**/test_*.rb'] -end + task :compile # no-op + +else + # C extension for Ruby < 3.3 + require "shellwords" + require "rake/extensiontask" + + extask = Rake::ExtensionTask.new("date") do |ext| + ext.name = "date_core" + ext.lib_dir.sub!(%r[(?=/|\z)], "/#{RUBY_VERSION}/#{ext.platform}") + end + + Rake::TestTask.new(:test) do |t| + t.libs << extask.lib_dir + t.libs << "test/lib" + t.ruby_opts << "-rhelper" + t.test_files = FileList['test/**/test_*.rb'] + end + + task test: :compile -task compile: "ext/date/zonetab.h" -file "ext/date/zonetab.h" => "ext/date/zonetab.list" do |t| - dir, hdr = File.split(t.name) - make_program_name = - ENV['MAKE'] || ENV['make'] || - RbConfig::CONFIG['configure_args'][/with-make-prog\=\K\w+/] || - (/mswin/ =~ RUBY_PLATFORM ? 'nmake' : 'make') - make_program = Shellwords.split(make_program_name) - sh(*make_program, "-f", "prereq.mk", "top_srcdir=.."+"/.."*dir.count("/"), - hdr, chdir: dir) + task compile: "ext/date/zonetab.h" + file "ext/date/zonetab.h" => "ext/date/zonetab.list" do |t| + dir, hdr = File.split(t.name) + make_program_name = + ENV['MAKE'] || ENV['make'] || + RbConfig::CONFIG['configure_args'][/with-make-prog\=\K\w+/] || + (/mswin/ =~ RUBY_PLATFORM ? 'nmake' : 'make') + make_program = Shellwords.split(make_program_name) + sh(*make_program, "-f", "prereq.mk", "top_srcdir=.."+"/.."*dir.count("/"), + hdr, chdir: dir) + end end task :default => [:compile, :test] diff --git a/date.gemspec b/date.gemspec index cb439bd0..d8da6dd2 100644 --- a/date.gemspec +++ b/date.gemspec @@ -1,29 +1,19 @@ # frozen_string_literal: true -version = File.foreach(File.expand_path("../lib/date.rb", __FILE__)).find do |line| - /^\s*VERSION\s*=\s*["'](.*)["']/ =~ line and break $1 -end +require_relative "lib/date/version" Gem::Specification.new do |s| s.name = "date" - s.version = version + s.version = Date::VERSION s.summary = "The official date library for Ruby." s.description = "The official date library for Ruby." - if Gem::Platform === s.platform and s.platform =~ 'java' or RUBY_ENGINE == 'jruby' - s.platform = 'java' - # No files shipped, no require path, no-op for now on JRuby - else - s.require_path = %w{lib} + s.require_path = %w{lib} - s.files = [ - "README.md", "COPYING", "BSDL", - "lib/date.rb", "ext/date/date_core.c", "ext/date/date_parse.c", "ext/date/date_strftime.c", - "ext/date/date_strptime.c", "ext/date/date_tmx.h", "ext/date/extconf.rb", "ext/date/prereq.mk", - "ext/date/zonetab.h", "ext/date/zonetab.list" - ] - s.extensions = "ext/date/extconf.rb" - end + s.files = Dir["README.md", "COPYING", "BSDL", "lib/**/*.rb", + "ext/date/*.c", "ext/date/*.h", "ext/date/extconf.rb", + "ext/date/prereq.mk", "ext/date/zonetab.list"] + s.extensions = ["ext/date/extconf.rb"] s.required_ruby_version = ">= 2.6.0" diff --git a/ext/date/extconf.rb b/ext/date/extconf.rb index 8a1467df..f00d8771 100644 --- a/ext/date/extconf.rb +++ b/ext/date/extconf.rb @@ -1,13 +1,16 @@ # frozen_string_literal: true require 'mkmf' -config_string("strict_warnflags") {|w| $warnflags += " #{w}"} - -append_cflags("-Wno-compound-token-split-by-macro") if RUBY_VERSION < "2.7." -have_func("rb_category_warn") -with_werror("", {:werror => true}) do |opt, | - have_var("timezone", "time.h", opt) - have_var("altzone", "time.h", opt) +if RUBY_VERSION >= "3.3" + # Pure Ruby implementation; skip C extension build + File.write("Makefile", dummy_makefile($srcdir).join("")) +else + config_string("strict_warnflags") {|w| $warnflags += " #{w}"} + append_cflags("-Wno-compound-token-split-by-macro") if RUBY_VERSION < "2.7." + have_func("rb_category_warn") + with_werror("", {:werror => true}) do |opt, | + have_var("timezone", "time.h", opt) + have_var("altzone", "time.h", opt) + end + create_makefile('date_core') end - -create_makefile('date_core') diff --git a/lib/date.rb b/lib/date.rb index 0cb76301..3ad70c9c 100644 --- a/lib/date.rb +++ b/lib/date.rb @@ -1,11 +1,20 @@ # frozen_string_literal: true # date.rb: Written by Tadayoshi Funaba 1998-2011 -require 'date_core' +if RUBY_VERSION >= "3.3" + require_relative "date/version" + require_relative "date/constants" + require_relative "date/core" + require_relative "date/strftime" + require_relative "date/parse" + require_relative "date/strptime" + require_relative "date/time" + require_relative "date/datetime" +else + require 'date_core' +end class Date - VERSION = "3.5.1" # :nodoc: - # call-seq: # infinite? -> false # @@ -64,7 +73,5 @@ def to_f -Float::INFINITY end end - end - end diff --git a/lib/date/constants.rb b/lib/date/constants.rb new file mode 100644 index 00000000..d9db674b --- /dev/null +++ b/lib/date/constants.rb @@ -0,0 +1,182 @@ +# frozen_string_literal: true + +# Constants +class Date + HAVE_JD = 0b00000001 # 1 + HAVE_DF = 0b00000010 # 2 + HAVE_CIVIL = 0b00000100 # 4 + HAVE_TIME = 0b00001000 # 8 + COMPLEX_DAT = 0b10000000 # 128 + private_constant :HAVE_JD, :HAVE_DF, :HAVE_CIVIL, :HAVE_TIME, :COMPLEX_DAT + + MONTHNAMES = [nil, "January", "February", "March", "April", "May", "June", + "July", "August", "September", "October", "November", "December"] + .map { |s| s&.encode(Encoding::US_ASCII)&.freeze }.freeze + ABBR_MONTHNAMES = [nil, "Jan", "Feb", "Mar", "Apr", "May", "Jun", + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] + .map { |s| s&.encode(Encoding::US_ASCII)&.freeze }.freeze + DAYNAMES = %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday] + .map { |s| s.encode(Encoding::US_ASCII).freeze }.freeze + ABBR_DAYNAMES = %w[Sun Mon Tue Wed Thu Fri Sat] + .map { |s| s.encode(Encoding::US_ASCII).freeze }.freeze + + # Pattern constants for regex + ABBR_DAYS_PATTERN = 'sun|mon|tue|wed|thu|fri|sat' + DAYS_PATTERN = 'sunday|monday|tuesday|wednesday|thursday|friday|saturday' + ABBR_MONTHS_PATTERN = 'jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec' + private_constant :ABBR_DAYS_PATTERN, :DAYS_PATTERN, :ABBR_MONTHS_PATTERN + + ITALY = 2299161 # 1582-10-15 + ENGLAND = 2361222 # 1752-09-14 + JULIAN = Float::INFINITY + GREGORIAN = -Float::INFINITY + + DEFAULT_SG = ITALY + private_constant :DEFAULT_SG + + MINUTE_IN_SECONDS = 60 + HOUR_IN_SECONDS = 3600 + DAY_IN_SECONDS = 86400 + HALF_DAYS_IN_SECONDS = DAY_IN_SECONDS / 2 + SECOND_IN_MILLISECONDS = 1000 + SECOND_IN_NANOSECONDS = 1_000_000_000 + private_constant :MINUTE_IN_SECONDS, :HOUR_IN_SECONDS, :DAY_IN_SECONDS, :SECOND_IN_MILLISECONDS, :SECOND_IN_NANOSECONDS, :HALF_DAYS_IN_SECONDS + + JC_PERIOD0 = 1461 # 365.25 * 4 + GC_PERIOD0 = 146097 # 365.2425 * 400 + CM_PERIOD0 = 71149239 # (lcm 7 1461 146097) + CM_PERIOD = (0xfffffff / CM_PERIOD0) * CM_PERIOD0 + CM_PERIOD_JCY = (CM_PERIOD / JC_PERIOD0) * 4 + CM_PERIOD_GCY = (CM_PERIOD / GC_PERIOD0) * 400 + private_constant :JC_PERIOD0, :GC_PERIOD0, :CM_PERIOD0, :CM_PERIOD, :CM_PERIOD_JCY, :CM_PERIOD_GCY + + REFORM_BEGIN_YEAR = 1582 + REFORM_END_YEAR = 1930 + REFORM_BEGIN_JD = 2298874 # ns 1582-01-01 + REFORM_END_JD = 2426355 # os 1930-12-31 + private_constant :REFORM_BEGIN_YEAR, :REFORM_END_YEAR, :REFORM_BEGIN_JD, :REFORM_END_JD + + SEC_WIDTH = 6 + MIN_WIDTH = 6 + HOUR_WIDTH = 5 + MDAY_WIDTH = 5 + MON_WIDTH = 4 + private_constant :SEC_WIDTH, :MIN_WIDTH, :HOUR_WIDTH, :MDAY_WIDTH, :MON_WIDTH + + SEC_SHIFT = 0 + MIN_SHIFT = SEC_WIDTH + HOUR_SHIFT = MIN_WIDTH + SEC_WIDTH + MDAY_SHIFT = HOUR_WIDTH + MIN_WIDTH + SEC_WIDTH + MON_SHIFT = MDAY_WIDTH + HOUR_WIDTH + MIN_WIDTH + SEC_WIDTH + private_constant :SEC_SHIFT, :MIN_SHIFT, :HOUR_SHIFT, :MDAY_SHIFT, :MON_SHIFT + + PK_MASK = ->(x) { (1 << x) - 1 } + private_constant :PK_MASK + + # Days in each month (non-leap and leap year) + MONTH_DAYS = [ + [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], # non-leap + [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] # leap + ].freeze + private_constant :MONTH_DAYS + + YEARTAB = [ + [0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], # non-leap + [0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335] # leap + ].freeze + private_constant :YEARTAB + + # Neri-Schneider algorithm constants + # JDN of March 1, Year 0 in proleptic Gregorian calendar + NS_EPOCH = 1721120 + private_constant :NS_EPOCH + + # Days in a 4-year cycle (3 normal years + 1 leap year) + NS_DAYS_IN_4_YEARS = 1461 + private_constant :NS_DAYS_IN_4_YEARS + + # Days in a 400-year Gregorian cycle (97 leap years in 400 years) + NS_DAYS_IN_400_YEARS = 146097 + private_constant :NS_DAYS_IN_400_YEARS + + # Years per century + NS_YEARS_PER_CENTURY = 100 + private_constant :NS_YEARS_PER_CENTURY + + # Multiplier for extracting year within century using fixed-point arithmetic. + # This is ceil(2^32 / NS_DAYS_IN_4_YEARS) for the Euclidean affine function. + NS_YEAR_MULTIPLIER = 2939745 + private_constant :NS_YEAR_MULTIPLIER + + # Coefficients for month calculation from day-of-year. + # Maps day-of-year to month using: month = (NS_MONTH_COEFF * doy + NS_MONTH_OFFSET) >> 16 + NS_MONTH_COEFF = 2141 + NS_MONTH_OFFSET = 197913 + private_constant :NS_MONTH_COEFF, :NS_MONTH_OFFSET + + # Coefficients for civil date to JDN month contribution. + # Maps month to accumulated days: days = (NS_CIVIL_MONTH_COEFF * m - NS_CIVIL_MONTH_OFFSET) / 32 + NS_CIVIL_MONTH_COEFF = 979 + NS_CIVIL_MONTH_OFFSET = 2919 + NS_CIVIL_MONTH_DIVISOR = 32 + private_constant :NS_CIVIL_MONTH_COEFF, :NS_CIVIL_MONTH_OFFSET, :NS_CIVIL_MONTH_DIVISOR + + # Days from March 1 to December 31 (for Jan/Feb year adjustment) + NS_DAYS_BEFORE_NEW_YEAR = 306 + private_constant :NS_DAYS_BEFORE_NEW_YEAR + + # Safe bounds for Neri-Schneider algorithm to avoid integer overflow. + # These correspond to approximately years -1,000,000 to +1,000,000. + NS_JD_MIN = -364_000_000 + NS_JD_MAX = 538_000_000 + private_constant :NS_JD_MIN, :NS_JD_MAX + + JULIAN_EPOCH_DATE = "-4712-01-01" + JULIAN_EPOCH_DATETIME = "-4712-01-01T00:00:00+00:00" + JULIAN_EPOCH_DATETIME_RFC2822 = "Mon, 1 Jan -4712 00:00:00 +0000" + JULIAN_EPOCH_DATETIME_HTTPDATE = "Mon, 01 Jan -4712 00:00:00 GMT" + private_constant :JULIAN_EPOCH_DATE, :JULIAN_EPOCH_DATETIME, :JULIAN_EPOCH_DATETIME_RFC2822, :JULIAN_EPOCH_DATETIME_HTTPDATE + + JISX0301_ERA_INITIALS = 'mtshr' + JISX0301_DEFAULT_ERA = 'H' # obsolete + private_constant :JISX0301_ERA_INITIALS, :JISX0301_DEFAULT_ERA + + HAVE_ALPHA = 1 << 0 + HAVE_DIGIT = 1 << 1 + HAVE_DASH = 1 << 2 + HAVE_DOT = 1 << 3 + HAVE_SLASH = 1 << 4 + private_constant :HAVE_ALPHA, :HAVE_DIGIT, :HAVE_DASH, :HAVE_DOT, :HAVE_SLASH + + # C: default strftime format is US-ASCII + STRFTIME_DEFAULT_FMT = '%F'.encode(Encoding::US_ASCII) + private_constant :STRFTIME_DEFAULT_FMT + + # strftime spec categories + NUMERIC_SPECS = %w[Y C y m d j H I M S L N G g U W V u w s Q].freeze + SPACE_PAD_SPECS = %w[e k l].freeze + CHCASE_UPPER_SPECS = %w[A a B b h].freeze + CHCASE_LOWER_SPECS = %w[Z p].freeze + private_constant :NUMERIC_SPECS, :SPACE_PAD_SPECS, + :CHCASE_UPPER_SPECS, :CHCASE_LOWER_SPECS + + # strptime digit-consuming specs + NUM_PATTERN_SPECS = "CDdeFGgHIjkLlMmNQRrSsTUuVvWwXxYy" + private_constant :NUM_PATTERN_SPECS + + # Fragment completion table for DateTime parsing + COMPLETE_FRAGS_TABLE = [ + [:time, [:hour, :min, :sec].freeze], + [nil, [:jd].freeze], + [:ordinal, [:year, :yday, :hour, :min, :sec].freeze], + [:civil, [:year, :mon, :mday, :hour, :min, :sec].freeze], + [:commercial, [:cwyear, :cweek, :cwday, :hour, :min, :sec].freeze], + [:wday, [:wday, :hour, :min, :sec].freeze], + [:wnum0, [:year, :wnum0, :wday, :hour, :min, :sec].freeze], + [:wnum1, [:year, :wnum1, :wday, :hour, :min, :sec].freeze], + [nil, [:cwyear, :cweek, :wday, :hour, :min, :sec].freeze], + [nil, [:year, :wnum0, :cwday, :hour, :min, :sec].freeze], + [nil, [:year, :wnum1, :cwday, :hour, :min, :sec].freeze], + ].each { |a| a.freeze }.freeze + private_constant :COMPLETE_FRAGS_TABLE +end diff --git a/lib/date/core.rb b/lib/date/core.rb new file mode 100644 index 00000000..03b6d9cb --- /dev/null +++ b/lib/date/core.rb @@ -0,0 +1,3693 @@ +# frozen_string_literal: true + +# Implementation of ruby/date/ext/date/date_core.c +class Date + include Comparable + + Error = Class.new(ArgumentError) + + # Initialize method + # call-seq: + # Date.new(year = -4712, month = 1, mday = 1, start = Date::ITALY) -> date + # + # Returns a new Date object constructed from the given arguments: + # + # Date.new(2022).to_s # => "2022-01-01" + # Date.new(2022, 2).to_s # => "2022-02-01" + # Date.new(2022, 2, 4).to_s # => "2022-02-04" + # + # Argument +month+ should be in range (1..12) or range (-12..-1); + # when the argument is negative, counts backward from the end of the year: + # + # Date.new(2022, -11, 4).to_s # => "2022-02-04" + # + # Argument +mday+ should be in range (1..n) or range (-n..-1) + # where +n+ is the number of days in the month; + # when the argument is negative, counts backward from the end of the month. + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + # Related: Date.jd. + def initialize(year = -4712, month = 1, day = 1, start = DEFAULT_SG) + y = year + m = month + d = day + sg = start + fr2 = 0 + + # argument type checking + if y + raise TypeError, "invalid year (not numeric)" unless year.is_a?(Numeric) + end + if m + raise TypeError, "invalid month (not numeric)" unless month.is_a?(Numeric) + end + if d + raise TypeError, "invalid day (not numeric)" unless day.is_a?(Numeric) + # Check if there is a decimal part. + d_trunc, fr = d_trunc_with_frac(d) + d = d_trunc + fr2 = fr if fr.nonzero? + end + + sg = self.class.send(:valid_sg, sg) + style = self.class.send(:guess_style, y, sg) + + if style < 0 + # gregorian calendar only + result = self.class.send(:valid_gregorian_p, y, m, d) + raise Error unless result + + nth, ry = self.class.send(:decode_year, y, -1) + rm = result[:rm] + rd = result[:rd] + + @nth = canon(nth) + @jd = 0 + @sg = sg + @year = ry + @month = rm + @day = rd + @has_jd = false + @has_civil = true + @df = nil + @sf = nil + @of = nil + else + # full validation + result = self.class.send(:valid_civil_p, y, m, d, sg) + raise Error unless result + + nth = result[:nth] + ry = result[:ry] + rm = result[:rm] + rd = result[:rd] + rjd = result[:rjd] + + @nth = canon(nth) + @jd = rjd + @sg = sg + @year = ry + @month = rm + @day = rd + @has_jd = true + @has_civil = true + @df = nil + @sf = nil + @of = nil + end + + # Add any decimal parts. + if fr2.nonzero? + new_date = self + fr2 + @nth = new_date.instance_variable_get(:@nth) + @jd = new_date.instance_variable_get(:@jd) + @sg = new_date.instance_variable_get(:@sg) + @year = new_date.instance_variable_get(:@year) + @month = new_date.instance_variable_get(:@month) + @day = new_date.instance_variable_get(:@day) + @has_jd = new_date.instance_variable_get(:@has_jd) + @has_civil = new_date.instance_variable_get(:@has_civil) + @df = new_date.instance_variable_get(:@df) + @sf = new_date.instance_variable_get(:@sf) + @of = new_date.instance_variable_get(:@of) + end + + self + end + + # Class methods + class << self + # Same as `Date.new`. + alias_method :civil, :new + + # call-seq: + # Date.valid_civil?(year, month, mday, start = Date::ITALY) -> true or false + # + # Returns +true+ if the arguments define a valid ordinal date, + # +false+ otherwise: + # + # Date.valid_date?(2001, 2, 3) # => true + # Date.valid_date?(2001, 2, 29) # => false + # Date.valid_date?(2001, 2, -1) # => true + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + # Related: Date.jd, Date.new. + def valid_civil?(year, month, day, start = DEFAULT_SG) + return false unless numeric?(year) + return false unless numeric?(month) + return false unless numeric?(day) + + result = valid_civil_sub(year, month, day, start, 0) + + !result.nil? + end + alias_method :valid_date?, :valid_civil? + + # call-seq: + # Date.jd(jd = 0, start = Date::ITALY) -> date + # + # Returns a new \Date object formed from the arguments: + # + # Date.jd(2451944).to_s # => "2001-02-03" + # Date.jd(2451945).to_s # => "2001-02-04" + # Date.jd(0).to_s # => "-4712-01-01" + # + # The returned date is: + # + # - Gregorian, if the argument is greater than or equal to +start+: + # + # Date::ITALY # => 2299161 + # Date.jd(Date::ITALY).gregorian? # => true + # Date.jd(Date::ITALY + 1).gregorian? # => true + # + # - Julian, otherwise + # + # Date.jd(Date::ITALY - 1).julian? # => true + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + # Related: Date.new. + def jd(jd = 0, start = DEFAULT_SG) + j = 0 + fr = 0 + sg = start + + sg = valid_sg(start) if start + + if jd + raise TypeError, "invalid jd (not numeric)" unless jd.is_a?(Numeric) + + j, fr = value_trunc(jd) + end + + nth, rjd = decode_jd(j) + + ret = d_simple_new_internal(nth, rjd, sg, 0, 0, 0, HAVE_JD) + + ret = ret + fr if fr.nonzero? + + ret + end + + # call-seq: + # Date.valid_jd?(jd, start = Date::ITALY) -> true + # + # Implemented for compatibility; + # returns +true+ unless +jd+ is invalid (i.e., not a Numeric). + # + # Date.valid_jd?(2451944) # => true + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + # Related: Date.jd. + def valid_jd?(jd, start = DEFAULT_SG) + return false unless numeric?(jd) + + result = valid_jd_sub(jd, start, 0) + + !result.nil? + end + + # call-seq: + # Date.gregorian_leap?(year) -> true or false + # + # Returns +true+ if the given year is a leap year + # in the {proleptic Gregorian calendar}[https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar], +false+ otherwise: + # + # Date.gregorian_leap?(2000) # => true + # Date.gregorian_leap?(2001) # => false + # + # Related: Date.julian_leap?. + def gregorian_leap?(year) + raise TypeError, "invalid year (not numeric)" unless numeric?(year) + + _, ry = decode_year(year, -1) + + c_gregorian_leap_p?(ry) + end + alias_method :leap?, :gregorian_leap? + + # call-seq: + # Date.julian_leap?(year) -> true or false + # + # Returns +true+ if the given year is a leap year + # in the {proleptic Julian calendar}[https://en.wikipedia.org/wiki/Proleptic_Julian_calendar], +false+ otherwise: + # + # Date.julian_leap?(1900) # => true + # Date.julian_leap?(1901) # => false + # + # Related: Date.gregorian_leap?. + def julian_leap?(year) + raise TypeError, "invalid year (not numeric)" unless numeric?(year) + + _, ry = decode_year(year, +1) + + c_julian_leap_p?(ry) + end + + # call-seq: + # Date.ordinal(year = -4712, yday = 1, start = Date::ITALY) -> date + # + # Returns a new \Date object formed fom the arguments. + # + # With no arguments, returns the date for January 1, -4712: + # + # Date.ordinal.to_s # => "-4712-01-01" + # + # With argument +year+, returns the date for January 1 of that year: + # + # Date.ordinal(2001).to_s # => "2001-01-01" + # Date.ordinal(-2001).to_s # => "-2001-01-01" + # + # With positive argument +yday+ == +n+, + # returns the date for the +nth+ day of the given year: + # + # Date.ordinal(2001, 14).to_s # => "2001-01-14" + # + # With negative argument +yday+, counts backward from the end of the year: + # + # Date.ordinal(2001, -14).to_s # => "2001-12-18" + # + # Raises an exception if +yday+ is zero or out of range. + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + # Related: Date.jd, Date.new. + def ordinal(year = -4712, yday = 1, start = DEFAULT_SG) + y = year + d = yday + fr2 = 0 + sg = start + + if y + raise TypeError, "invalid year (not numeric)" unless year.is_a?(Numeric) + end + if d + raise TypeError, "invalid yday (not numeric)" unless yday.is_a?(Numeric) + d_trunc, fr = value_trunc(d) + d = d_trunc + fr2 = fr if fr.nonzero? + end + + result = valid_ordinal_p(year, yday, start) + raise Error unless result + + nth = result[:nth] + rjd = result[:rjd] + + obj = d_simple_new_internal(nth, rjd, sg, 0, 0, 0, HAVE_JD) + + obj = obj + fr2 if fr2.nonzero? + + obj + end + + # call-seq: + # Date.valid_ordinal?(year, yday, start = Date::ITALY) -> true or false + # + # Returns +true+ if the arguments define a valid ordinal date, + # +false+ otherwise: + # + # Date.valid_ordinal?(2001, 34) # => true + # Date.valid_ordinal?(2001, 366) # => false + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + # Related: Date.jd, Date.ordinal. + def valid_ordinal?(year, day, start = DEFAULT_SG) + return false unless numeric?(year) + return false unless numeric?(day) + + result = valid_ordinal_sub(year, day, start, false) + + !result.nil? + end + + # call-seq: + # Date.commercial(cwyear = -4712, cweek = 1, cwday = 1, start = Date::ITALY) -> date + # + # Returns a new \Date object constructed from the arguments. + # + # Argument +cwyear+ gives the year, and should be an integer. + # + # Argument +cweek+ gives the index of the week within the year, + # and should be in range (1..53) or (-53..-1); + # in some years, 53 or -53 will be out-of-range; + # if negative, counts backward from the end of the year: + # + # Date.commercial(2022, 1, 1).to_s # => "2022-01-03" + # Date.commercial(2022, 52, 1).to_s # => "2022-12-26" + # + # Argument +cwday+ gives the indes of the weekday within the week, + # and should be in range (1..7) or (-7..-1); + # 1 or -7 is Monday; + # if negative, counts backward from the end of the week: + # + # Date.commercial(2022, 1, 1).to_s # => "2022-01-03" + # Date.commercial(2022, 1, -7).to_s # => "2022-01-03" + # + # When +cweek+ is 1: + # + # - If January 1 is a Friday, Saturday, or Sunday, + # the first week begins in the week after: + # + # Date::ABBR_DAYNAMES[Date.new(2023, 1, 1).wday] # => "Sun" + # Date.commercial(2023, 1, 1).to_s # => "2023-01-02" + # Date.commercial(2023, 1, 7).to_s # => "2023-01-08" + # + # - Otherwise, the first week is the week of January 1, + # which may mean some of the days fall on the year before: + # + # Date::ABBR_DAYNAMES[Date.new(2020, 1, 1).wday] # => "Wed" + # Date.commercial(2020, 1, 1).to_s # => "2019-12-30" + # Date.commercial(2020, 1, 7).to_s # => "2020-01-05" + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + # Related: Date.jd, Date.new, Date.ordinal. + def commercial(cwyear = -4712, cweek = 1, cwday = 1, start = DEFAULT_SG) + y = cwyear + w = cweek + d = cwday + fr2 = 0 + sg = start + + if y + raise TypeError, "invalid year (not numeric)" unless cwyear.is_a?(Numeric) + end + if w + raise TypeError, "invalid cweek (not numeric)" unless cweek.is_a?(Numeric) + w = w.to_i + end + if d + raise TypeError, "invalid cwday (not numeric)" unless cwday.is_a?(Numeric) + d_trunc, fr = value_trunc(d) + d = d_trunc + fr2 = fr if fr.nonzero? + end + + sg = valid_sg(start) if start + + result = valid_commercial_p(y, w, d, sg) + raise Error unless result + + nth = result[:nth] + rjd = result[:rjd] + + obj = d_simple_new_internal(nth, rjd, sg, 0, 0, 0, HAVE_JD) + + obj = obj + fr2 if fr2.nonzero? + + obj + end + + # call-seq: + # Date.valid_commercial?(cwyear, cweek, cwday, start = Date::ITALY) -> true or false + # + # Returns +true+ if the arguments define a valid commercial date, + # +false+ otherwise: + # + # Date.valid_commercial?(2001, 5, 6) # => true + # Date.valid_commercial?(2001, 5, 8) # => false + # + # See Date.commercial. + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + # Related: Date.jd, Date.commercial. + def valid_commercial?(year, week, day, start = DEFAULT_SG) + return false unless numeric?(year) + return false unless numeric?(week) + return false unless numeric?(day) + + result = valid_commercial_sub(year, week, day, start, false) + + !result.nil? + end + + # call-seq: + # Date.today(start = Date::ITALY) -> date + # + # Returns a new \Date object constructed from the present date: + # + # Date.today.to_s # => "2022-07-06" + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + def today(start = DEFAULT_SG) + begin + time = Time.now + rescue + raise SystemCallError, "time" + end + + begin + y = time.year + m = time.month + d = time.day + rescue + raise SystemCallError, "localtime" + end + + nth, ry, _, _ = decode_year(y, -1) + + obj = allocate + obj.instance_variable_set(:@nth, nth) + obj.instance_variable_set(:@year, ry) + obj.instance_variable_set(:@month, m) + obj.instance_variable_set(:@day, d) + obj.instance_variable_set(:@jd, nil) + obj.instance_variable_set(:@sg, GREGORIAN) + obj.instance_variable_set(:@has_jd, false) + obj.instance_variable_set(:@has_civil, true) + + if start != GREGORIAN + obj.instance_variable_set(:@sg, start) + if obj.instance_variable_get(:@has_jd) + obj.instance_variable_set(:@jd, nil) + obj.instance_variable_set(:@has_jd, false) + end + end + + obj + end + + # :nodoc: + # C: date_s__load — for Marshal format 1.4, 1.6, 1.8 (u: prefix) + def _load(s) + a = Marshal.load(s) + obj = allocate + obj.marshal_load(a) + obj + end + + private + + # Optimized: Gregorian date -> Julian Day Number + def gregorian_civil_to_jd(year, month, day) + # Shift epoch to March 1 of year 0 (Jan/Feb belong to previous year) + j = (month < 3) ? 1 : 0 + y0 = year - j + m0 = j == 1 ? month + 12 : month + d0 = day - 1 + + # Calculate year contribution with leap year correction + q1 = y0 / NS_YEARS_PER_CENTURY + yc = (NS_DAYS_IN_4_YEARS * y0) / 4 - q1 + (q1 / 4) + + # Calculate month contribution using integer arithmetic + mc = (NS_CIVIL_MONTH_COEFF * m0 - NS_CIVIL_MONTH_OFFSET) / NS_CIVIL_MONTH_DIVISOR + + # Combine and add epoch offset to get JDN + yc + mc + d0 + NS_EPOCH + end + + def julian_civil_to_jd(y, m, d) + # Traditional Julian calendar algorithm + y2 = y + m2 = m + + if m2 <= 2 + y2 -= 1 + m2 += 12 + end + + (365.25 * (y2 + 4716)).floor + (30.6001 * (m2 + 1)).floor + d - 1524 + end + + def validate_ordinal(year, yday, sg) + # Handling negative day of year + if yday < 0 + # Counting backwards from the end of the year + last_jd, _ = c_find_ldoy(year, sg) + return nil unless last_jd + + # Recalculate the total number of days in the year from the calculated JD + adjusted_jd = last_jd + yday + 1 + y, d = jd_to_ordinal(adjusted_jd, sg) + + # Invalid if the year does not match + return nil if y != year + + yday = d + end + + # Calculate jd from the day of the year + nth, ry, _, _ = decode_year(year, sg) + first_jd, ns = c_find_fdoy(ry, sg) + + return nil unless first_jd + + jd = first_jd + yday - 1 + + # Verify that the calculated jd actually belongs to the specified year + verify_y, verify_d = jd_to_ordinal(jd, sg) + return nil if verify_y != ry || verify_d != yday + + [nth, ry, yday, jd, ns] + end + + def extract_fraction(value) + if value.is_a?(Rational) || value.is_a?(Float) + int_part = value.floor + frac_part = value - int_part + [int_part, frac_part] + else + [value.to_i, 0] + end + end + + def jd_to_ordinal(jd, sg) + year, _, _ = jd_to_civil_internal(jd, sg) + first_jd, _ = c_find_fdoy(year, sg) + yday = jd - first_jd + 1 + + [year, yday] + end + + def validate_commercial(year, week, day, sg) + if day < 0 + day += 8 # -1 -> 7 (Sun), -7 -> 1 (Mon) + end + + return nil if day < 1 || day > 7 + + if week < 0 + next_year_jd, ns = commercial_to_jd_internal(year + 1, 1, 1, sg) + return nil unless next_year_jd + + adjusted_jd = next_year_jd + week * 7 + y2, w2, _ = jd_to_commercial_internal(adjusted_jd, sg) + + return nil if y2 != year + + week = w2 + end + + # Calculate jd from ISO week date + nth, ry, _, _ = decode_year(year, sg) + jd, ns = commercial_to_jd_internal(ry, week, day, sg) + + return nil unless jd + + verify_y, verify_w, verify_d = jd_to_commercial_internal(jd, sg) + return nil if verify_y != ry || verify_w != week || verify_d != day + + [nth, ry, week, day, jd, ns] + end + + def commercial_to_jd_internal(cwyear, cweek, cwday, sg) + # Calculating ISO week date(The week containing January 4 is week 1) + jan4_jd = gregorian_civil_to_jd(cwyear, 1, 4) + + # Day of the week on which January 4th falls + # (0 = Sun, 1 = Mon, ..., 6 = Sat) + jan4_wday = (jan4_jd + 1) % 7 + + # Monday of week 1 + week1_mon = jan4_jd - jan4_wday + 1 + + # jd for a specified weekday + jd = week1_mon + (cweek - 1) * 7 + (cwday - 1) + + # If before sg, it is the Julian calendar + ns = jd >= sg ? 1 : 0 + + [jd, ns] + end + + def jd_to_commercial_internal(jd, sg) + # get date from jd + year, _, _ = jd_to_civil_internal(jd, sg) + + # calculate jd for January 4 of that year + jan4_jd = gregorian_civil_to_jd(year, 1, 4) + jan4_wday = (jan4_jd + 1) % 7 + week1_mon = jan4_jd - jan4_wday + 1 + + # If jd is before the first week, it belongs to the previous year + if jd < week1_mon + year -= 1 + jan4_jd = gregorian_civil_to_jd(year, 1, 4) + jan4_wday = (jan4_jd + 1) % 7 + week1_mon = jan4_jd - jan4_wday + 1 + end + + # check the first week of the next year + next_jan4 = gregorian_civil_to_jd(year + 1, 1, 4) + next_jan4_wday = (next_jan4 + 1) % 7 + next_week1_mon = next_jan4 - next_jan4_wday + 1 + + if jd >= next_week1_mon + year += 1 + week1_mon = next_week1_mon + end + + # Calculate the week number + week = (jd - week1_mon) / 7 + 1 + + # week(1 = mon, ..., 7 = sun） + cwday = (jd + 1) % 7 + cwday = 7 if cwday.zero? + + [year, week, cwday] + end + + def jd_to_civil_internal(jd, sg) + # Does it overlap with jd_to_civil? + # Calculate the date from jd (using existing methods) + # simple version + r0 = jd - NS_EPOCH + + n1 = 4 * r0 + 3 + q1 = n1 / NS_DAYS_IN_400_YEARS + r1 = (n1 % NS_DAYS_IN_400_YEARS) / 4 + + n2 = 4 * r1 + 3 + u2 = NS_YEAR_MULTIPLIER * n2 + q2 = u2 >> 32 + r2 = (u2 & 0xFFFFFFFF) / NS_YEAR_MULTIPLIER / 4 + + n3 = NS_MONTH_COEFF * r2 + NS_MONTH_OFFSET + q3 = n3 >> 16 + r3 = (n3 & 0xFFFF) / NS_MONTH_COEFF + + y0 = NS_YEARS_PER_CENTURY * q1 + q2 + j = (r2 >= NS_DAYS_BEFORE_NEW_YEAR) ? 1 : 0 + + year = y0 + j + month = j == 1 ? q3 - 12 : q3 + day = r3 + 1 + + [year, month, day] + end + + def valid_civil_date?(year, month, day, sg) + return false if month < 1 || month > 12 + + if sg == GREGORIAN || sg < 0 + last_day = last_day_of_month_gregorian(year, month) + elsif sg == JULIAN || sg > 0 + last_day = last_day_of_month_julian(year, month) + else + # Calculate (calendar reform period - jd) and determine + jd = gregorian_civil_to_jd(year, month, day) + + if jd < sg + last_day = last_day_of_month_julian(year, month) + else + last_day = last_day_of_month_gregorian(year, month) + end + end + + return false if day < 1 || day > last_day + + true + end + + def last_day_of_month_gregorian(y, m) + return nil if m < 1 || m > 12 + + leap_index = gregorian_leap?(y) ? 1 : 0 + MONTH_DAYS[leap_index][m] + end + + def last_day_of_month_julian(y, m) + return nil if m < 1 || m > 12 + + leap_index = julian_leap?(y) ? 1 : 0 + MONTH_DAYS[leap_index][m] + end + + def civil_to_jd_with_check(year, month, day, sg) + return nil unless valid_civil_date?(year, month, day, sg) + + jd, ns = civil_to_jd(year, month, day, sg) + + [jd, ns] + end + + def civil_to_jd(year, month, day, sg) + if sg == GREGORIAN + jd = gregorian_civil_to_jd(year, month, day) + + return [jd, 1] + end + + jd = gregorian_civil_to_jd(year, month, day) + + if jd < sg + jd = julian_civil_to_jd(year, month, day) + ns = 0 + else + ns = 1 + end + + [jd, ns] + end + + def last_day_of_month_for_sg(year, month, sg) + last_day_of_month_gregorian(year, month) + end + + def validate_civil(year, month, day, sg) + month += 13 if month < 0 + return nil if month < 1 || month > 12 + + if day < 0 + last_day = last_day_of_month_gregorian(year, month) + return nil unless last_day + day = last_day + day + 1 + end + + last_day = last_day_of_month_gregorian(year, month) + return nil if day < 1 || day > last_day + + nth, ry = decode_year(year, -1) + + jd, ns = civil_to_jd_with_style(ry, month, day, sg) + + [nth, ry, month, day, jd, ns] + end + + def civil_to_jd_with_style(year, month, day, sg) + jd = gregorian_civil_to_jd(year, month, day) + + if jd < sg + jd = julian_civil_to_jd(year, month, day) + ns = 0 + else + ns = 1 + end + + [jd, ns] + end + + def convert_to_integer(value) + if value.respond_to?(:to_int) + value.to_int + elsif value.is_a?(Numeric) + value.to_i + else + value + end + end + + def numeric?(value) + value.is_a?(Numeric) || value.respond_to?(:to_int) + end + + def valid_civil_sub(year, month, day, start, need_jd) + year = convert_to_integer(year) + month = convert_to_integer(month) + day = convert_to_integer(day) + + start = valid_sg(start) + + return nil if month < 1 || month > 12 + + leap_year = start == JULIAN ? julian_leap?(year) : gregorian_leap?(year) + + days_in_month = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] + max_day = (month == 2 && leap_year) ? 29 : days_in_month[month] + + return nil if day < 1 || day > max_day + + need_jd ? civil_to_jd(year, month, day, start) : 0 + end + + def valid_sg(start) + unless c_valid_start_p(start) + warn "invalid start is ignored" + return 0 + end + + start + end + + def c_valid_start_p(start) + return false unless start.is_a?(Numeric) + + return false if start.respond_to?(:nan?) && start.nan? + + return true if start.respond_to?(:infinite?) && start.infinite? + + return false if start < REFORM_BEGIN_JD || start > REFORM_END_JD + + true + end + + def valid_jd_sub(jd, start, need_jd) + valid_sg(start) + + jd + end + + def valid_commercial_sub(year, week, day, start, need_jd) + week = convert_to_integer(week) + day = convert_to_integer(day) + + valid_sg(start) + + result = valid_commercial_p(year, week, day, start) + + return nil unless result + + return 0 unless need_jd + + encode_jd(result[:nth], result[:rjd]) + end + + def valid_commercial_p(year, week, day, start) + style = guess_style(year, start) + + if style.zero? + int_year = year.to_i + result = c_valid_commercial_p(int_year, week, day, start) + return nil unless result + + nth, rjd = decode_jd(result[:jd]) + + if f_zero_p?(nth) + ry = int_year + else + ns = result[:ns] + _, ry = decode_year(year, ns.nonzero? ? -1 : 1) + end + + { nth: nth, ry: ry, rw: result[:rw], rd: result[:rd], rjd: rjd, ns: result[:ns] } + else + nth, ry = decode_year(year, style) + result = c_valid_commercial_p(ry, week, day, style) + return nil unless result + + { nth: nth, ry: ry, rw: result[:rw], rd: result[:rd], rjd: result[:jd], ns: result[:ns] } + end + end + + def guess_style(year, sg) + return sg if sg.infinite? + return year >= 0 ? GREGORIAN : JULIAN unless year.is_a?(Integer) && year.abs < (1 << 62) + + int_year = year.to_i + if int_year < REFORM_BEGIN_YEAR + JULIAN + elsif int_year > REFORM_END_YEAR + GREGORIAN + else + 0 + end + end + + def c_valid_commercial_p(year, week, day, sg) + day += 8 if day < 0 + + if week < 0 + rjd2, _ = c_commercial_to_jd(year + 1, 1, 1, sg) + ry2, rw2, _ = c_jd_to_commercial(rjd2 + week * 7, sg) + return nil if ry2 != year + + week = rw2 + end + + rjd, ns = c_commercial_to_jd(year, week, day, sg) + ry2, rw, rd = c_jd_to_commercial(rjd, sg) + + return nil if year != ry2 || week != rw || day != rd + + { jd: rjd, ns: ns, rw: rw, rd: rd } + end + + def c_commercial_to_jd(year, week, day, sg) + rjd2, _ = c_find_fdoy(year, sg) + rjd2 += 3 + + # Calcurate ISO week number. + rjd = (rjd2 - ((rjd2 - 1 + 1) % 7)) + 7 * (week - 1) + (day - 1) + ns = (rjd < sg) ? 0 : 1 + + [rjd, ns] + end + + def c_jd_to_commercial(jd, sg) + ry2, _, _ = c_jd_to_civil(jd - 3, sg) + a = ry2 + + rjd2, _ = c_commercial_to_jd(a + 1, 1, 1, sg) + if jd >= rjd2 + ry = a + 1 + else + rjd2, _ = c_commercial_to_jd(a, 1, 1, sg) + ry = a + end + + rw = 1 + (jd - rjd2) / 7 + rd = (jd + 1) % 7 + rd = 7 if rd.zero? + + [ry, rw, rd] + end + + def c_find_fdoy(year, sg) + if c_gregorian_only_p?(sg) + jd = c_gregorian_fdoy(year) + + return [jd, 1] + end + + # Keep existing loop for Julian/reform period + (1..30).each do |d| + result = c_valid_civil_p(year, 1, d, sg) + + return [result[:jd], result[:ns]] if result + end + + [nil, nil] + end + + def c_find_ldom(year, month, sg) + if c_gregorian_only_p?(sg) + jd = c_gregorian_ldom_jd(year, month) + + return [jd, 1] + end + + # Keep existing loop for Julian/reform period + (0..29).each do |i| + result = c_valid_civil_p(year, month, 31 - i, sg) + return [result[:jd], result[:ns]] if result + end + + nil + end + + def c_gregorian_fdoy(year) + c_gregorian_civil_to_jd(year, 1, 1) + end + + def c_jd_to_civil(jd, sg) + # Fast path: pure Gregorian or date after switchover, within safe range + if (c_gregorian_only_p?(sg) || jd >= sg) && ns_jd_in_range(jd) + return c_gregorian_jd_to_civil(jd) + end + + # Original algorithm for Julian calendar or extreme dates + if jd < sg + a = jd + else + x = ((jd - 1867216.25) / 36524.25).floor + a = jd + 1 + x - (x / 4.0).floor + end + + b = a + 1524 + c = ((b - 122.1) / 365.25).floor + d = (365.25 * c).floor + e = ((b - d) / 30.6001).floor + dom = b - d - (30.6001 * e).floor + + if e <= 13 + m = e - 1 + y = c - 4716 + else + m = e - 13 + y = c - 4715 + end + + [y.to_i, m.to_i, dom.to_i] + end + + # Optimized: Julian Day Number -> Gregorian date + def c_gregorian_jd_to_civil(jd) + # The argument jd of c_gregorian_jd_to_civil implemented in C is of type int, + # so it is converted to Integer. + jd = jd.to_i unless jd.is_a?(Integer) + + # Convert JDN to rata die (March 1, Year 0 epoch) + r0 = jd - NS_EPOCH + + # Extract century and day within 400-year cycle + # Use Euclidean (floor) division for negative values + n1 = 4 * r0 + 3 + q1 = n1 / NS_DAYS_IN_400_YEARS + r1 = (n1 % NS_DAYS_IN_400_YEARS) / 4 + + # Calculate year within century and day of year + n2 = 4 * r1 + 3 + # Use 64-bit arithmetic to avoid overflow + u2 = NS_YEAR_MULTIPLIER * n2 + q2 = u2 >> 32 + r2 = (u2 & 0xFFFFFFFF) / NS_YEAR_MULTIPLIER / 4 + + # Calculate month and day using integer arithmetic + n3 = NS_MONTH_COEFF * r2 + NS_MONTH_OFFSET + q3 = n3 >> 16 + r3 = (n3 & 0xFFFF) / NS_MONTH_COEFF + + # Combine century and year + y0 = NS_YEARS_PER_CENTURY * q1 + q2 + + # Adjust for January/February (shift from fiscal year) + j = (r2 >= NS_DAYS_BEFORE_NEW_YEAR) ? 1 : 0 + + ry = y0 + j + rm = j.nonzero? ? q3 - 12 : q3 + rd = r3 + 1 + + [ry, rm, rd] + end + + def c_gregorian_civil_to_jd(year, month, day) + j = (month < 3) ? 1 : 0 + y0 = year - j + m0 = j.nonzero? ? month + 12 : month + d0 = day - 1 + + q1 = y0 / 100 + yc = (NS_DAYS_IN_4_YEARS * y0) / 4 - q1 + q1 / 4 + + mc = (NS_DAYS_BEFORE_NEW_YEAR * m0 - 914) / 10 + + yc + mc + d0 + NS_EPOCH + end + + def valid_civil_p(y, m, d, sg) + style = guess_style(y, sg) + + if style.zero? + # If year is a Fixnum + int_year = y.to_i + + # Validate with c_valid_civil_p + result = c_valid_civil_p(int_year, m, d, sg) + return nil unless result + + # decode_jd + nth, rjd = decode_jd(result[:jd]) + + if f_zero_p?(nth) + ry = int_year + else + ns = result[:ns] + _, ry = decode_year(y, ns.nonzero? ? -1 : 1) + end + + return { nth: nth, ry: ry, rm: result[:rm], rd: result[:rd], rjd: rjd, ns: result[:ns] } + else + # If year is a large number + nth, ry = decode_year(y, style) + + result = style < 0 ? c_valid_gregorian_p(ry, m, d) : result = c_valid_julian_p(ry, m, d) + return nil unless result + + # Calculate JD from civil + rjd, ns = c_civil_to_jd(ry, result[:rm], result[:rd], style) + + return { nth: nth, ry: ry, rm: result[:rm], rd: result[:rd], rjd: rjd, ns: ns } + end + end + + def c_valid_civil_p(year, month, day, sg) + month += 13 if month < 0 + return nil if month < 1 || month > 12 + + rd = day + if rd < 0 + result = c_find_ldom(year, month, sg) + return nil unless result + + rjd2, _ = result + ry2, rm2, rd2 = c_jd_to_civil(rjd2 + rd + 1, sg) + return nil if ry2 != year || rm2 != month + + rd = rd2 + end + + rjd, ns = c_civil_to_jd(year, month, rd, sg) + ry2, rm2, rd2 = c_jd_to_civil(rjd, sg) + + return nil if ry2 != year || rm2 != month || rd2 != rd + + { jd: rjd, ns: ns, rm: rm2, rd: rd } + end + + def c_gregorian_ldom_jd(year, month) + last_day = c_gregorian_last_day_of_month(year, month) + c_gregorian_civil_to_jd(year, month, last_day) + end + + def c_gregorian_last_day_of_month(year, month) + days_in_month = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] + + if month == 2 && gregorian_leap?(year) + 29 + else + days_in_month[month] + end + end + + def c_civil_to_jd(year, month, day, sg) + if c_gregorian_only_p?(sg) + jd = c_gregorian_civil_to_jd(year, month, day) + + return [jd, 1] + end + + # Calculate Gregorian JD using optimized algorithm + jd = c_gregorian_civil_to_jd(year, month, day) + + if jd < sg + y2 = year + m2 = month + if m2 <= 2 + y2 -= 1 + m2 += 12 + end + jd = (365.25 * (y2 + 4716)).floor + (30.6001 * (m2 + 1)).floor + day - 1524 + ns = 0 + else + ns = 1 + end + + [jd, ns] + end + + def decode_jd(jd) + nth = jd / CM_PERIOD + rjd = f_zero_p?(nth) ? jd : jd % CM_PERIOD + + [nth, rjd] + end + + def encode_jd(nth, rjd) + f_zero_p?(nth) ? rjd : nth * CM_PERIOD + rjd + end + + def decode_year(year, style) + period = (style < 0) ? CM_PERIOD_GCY : CM_PERIOD_JCY + + if year.is_a?(Integer) && year.abs < (1 << 30) + shifted = year + 4712 + nth = shifted / period + + shifted = shifted % period if f_nonzero_p?(nth) + + ry = shifted - 4712 + else + shifted = year + 4712 + nth = shifted / period + + shifted = shifted % period if f_nonzero_p?(nth) + + ry = shifted.to_i - 4712 + end + + [nth, ry] + end + + # Check if using pure Gregorian calendar (sg == -Infinity) + def c_gregorian_only_p?(sg) + sg.infinite? && sg < 0 + end + + def valid_ordinal_sub(year, day, start, need_jd) + day = convert_to_integer(day) + + valid_sg(start) + + result = valid_ordinal_p(year, day, start) + + return nil unless result + + return 0 unless need_jd + + encode_jd(result[:nth], result[:rjd]) + end + + def valid_ordinal_p(year, day, start) + style = guess_style(year, start) + + if style.zero? + int_year = year.to_i + result = c_valid_ordinal_p(int_year, day, start) + + return nil unless result + + nth, rjd = decode_jd(result[:jd]) + + if f_zero_p?(nth) + ry = int_year + else + ns = result[:ns] + _, ry = decode_year(year, ns.nonzero? ? -1 : 1) + end + + return { nth: nth, ry: ry, rd: result[:rd], rjd: rjd, ns: result[:ns] } + else + nth, ry = decode_year(year, style) + result = c_valid_ordinal_p(ry, day, style) + return nil unless result + + return { nth: nth, ry: ry, rd: result[:rd], rjd: result[:jd], ns: result[:ns] } + end + end + + def c_valid_ordinal_p(year, day, sg) + rd = day + if rd < 0 + result = c_find_ldoy(year, sg) + return nil unless result + + rjd2, _ = result + ry2, rd2 = c_jd_to_ordinal(rjd2 + rd + 1, sg) + return nil if ry2 != year + + rd = rd2 + end + + rjd, ns = c_ordinal_to_jd(year, rd, sg) + ry2, rd2 = c_jd_to_ordinal(rjd, sg) + + return nil if ry2 != year || rd2 != rd + + { jd: rjd, ns: ns, rd: rd } + end + + def c_find_ldoy(year, sg) + if c_gregorian_only_p?(sg) + jd = c_gregorian_ldoy(year) + + return [jd, 1] + end + + # Keep existing loop for Julian/reform period + (0..29).each do |i| + result = c_valid_civil_p(year, 12, 31 - i, sg) + + return [result[:jd], result[:ns]] if result + end + + nil + end + + # O(1) last day of year for Gregorian calendar + def c_gregorian_ldoy(year) + c_gregorian_civil_to_jd(year, 12, 31) + end + + def c_jd_to_ordinal(jd, sg) + ry, _, _ = c_jd_to_civil(jd, sg) + rjd, _ = c_find_fdoy(ry, sg) + + rd = (jd - rjd) + 1 + + [ry, rd] + end + + def c_ordinal_to_jd(year, day, sg) + rjd, _ = c_find_fdoy(year, sg) + rjd += day - 1 + ns = (rjd < sg) ? 0 : 1 + + [rjd, ns] + end + + def f_zero_p?(x) + case x + when Integer + x.zero? + when Rational + x.numerator == 0 + else + x == 0 + end + end + + def f_nonzero_p?(x) + !f_zero_p?(x) + end + + def c_gregorian_leap_p?(year) + !!(((year % 4).zero? && (year % 100).nonzero?) || (year % 400).zero?) + end + + def c_julian_leap_p?(year) + (year % 4).zero? + end + + def new_with_jd(nth, jd, start) + new_with_jd_and_time(nth, jd, nil, nil, nil, start) + end + + def new_with_jd_and_time(nth, jd, df, sf, of, start) + obj = allocate + obj.instance_variable_set(:@nth, nth) + obj.instance_variable_set(:@jd, jd) + obj.instance_variable_set(:@sg, start) + obj.instance_variable_set(:@df, df) + obj.instance_variable_set(:@sf, sf) + obj.instance_variable_set(:@of, of) + obj.instance_variable_set(:@year, nil) + obj.instance_variable_set(:@month, nil) + obj.instance_variable_set(:@day, nil) + obj.instance_variable_set(:@has_jd, true) + obj.instance_variable_set(:@has_civil, false) + + obj + end + + def valid_gregorian_p(y, m, d) + decode_year(y, -1) + + c_valid_gregorian_p(y, m, d) + end + + def c_valid_gregorian_p(y, m, d) + m += 13 if m < 0 + return nil if m < 1 || m > 12 + + last = c_gregorian_last_day_of_month(y, m) + d = last + d + 1 if d < 0 + return nil if d < 1 || d > last + + { rm: m, rd: d } + end + + def c_valid_julian_p(y, m, d) + m += 13 if m < 0 + return nil if m < 1 || m > 12 + + last = c_julian_last_day_of_month(y, m) + d = last + d + 1 if d < 0 + return nil if d < 1 || d > last + + { rm: m, rd: d } + end + + def c_julian_last_day_of_month(y, m) + raise Error unless m >= 1 && m <= 12 + + MONTH_DAYS[julian_leap?(y) ? 1 : 0][m] + end + + # Create a simple Date object. + def d_lite_s_alloc_simple + obj = allocate + obj.instance_variable_set(:@nth, 0) + obj.instance_variable_set(:@jd, 0) + obj.instance_variable_set(:@sg, DEFAULT_SG) + obj.instance_variable_set(:@df, nil) + obj.instance_variable_set(:@sf, nil) + obj.instance_variable_set(:@of, nil) + obj.instance_variable_set(:@year, nil) + obj.instance_variable_set(:@month, nil) + obj.instance_variable_set(:@day, nil) + obj.instance_variable_set(:@has_jd, true) + obj.instance_variable_set(:@has_civil, false) + + obj + end + + # Create a complex Date object. + def d_lite_s_alloc_complex + obj = allocate + obj.instance_variable_set(:@nth, 0) + obj.instance_variable_set(:@jd, 0) + obj.instance_variable_set(:@sg, DEFAULT_SG) + obj.instance_variable_set(:@df, nil) + obj.instance_variable_set(:@sf, nil) + obj.instance_variable_set(:@of, nil) + obj.instance_variable_set(:@year, nil) + obj.instance_variable_set(:@month, nil) + obj.instance_variable_set(:@day, nil) + obj.instance_variable_set(:@hour, nil) + obj.instance_variable_set(:@min, nil) + obj.instance_variable_set(:@sec, nil) + obj.instance_variable_set(:@has_jd, true) + obj.instance_variable_set(:@has_civil, false) + + obj + end + + def value_trunc(value) + if value.is_a?(Integer) + [value, 0] + elsif value.is_a?(Float) || value.is_a?(Rational) + trunc = value.truncate + frac = value - trunc + + [trunc, frac] + else + [value.to_i, 0] + end + end + + def d_simple_new_internal(nth, jd, sg, year, mon, mday, flags) + obj = allocate + obj.instance_variable_set(:@nth, canon(nth)) + obj.instance_variable_set(:@jd, jd) + obj.instance_variable_set(:@sg, sg) + obj.instance_variable_set(:@year, year) + obj.instance_variable_set(:@month, mon) + obj.instance_variable_set(:@day, mday) + obj.instance_variable_set(:@has_jd, (flags & HAVE_JD).nonzero?) + obj.instance_variable_set(:@has_civil, (flags & HAVE_CIVIL).nonzero?) + obj.instance_variable_set(:@df, nil) + obj.instance_variable_set(:@sf, nil) + obj.instance_variable_set(:@of, nil) + + obj + end + + def canon(x) + x.is_a?(Rational) && x.denominator == 1 ? x.numerator : x + end + + def ns_jd_in_range(jd) + jd >= NS_JD_MIN && jd <= NS_JD_MAX + end + + def check_limit(str, limit) + unless str.is_a?(String) + begin + str = str.to_str + rescue NoMethodError + raise TypeError, "no implicit conversion of #{str.class} into String" + end + end + + if limit && str.length > limit + raise ArgumentError, "string length (#{str.length}) exceeds the limit #{limit}" + end + + str + end + end + + # Instance methods + + # call-seq: + # year -> integer + # + # Returns the year: + # + # Date.new(2001, 2, 3).year # => 2001 + # (Date.new(1, 1, 1) - 1).year # => 0 + def year + m_real_year + end + + # call-seq: + # mon -> integer + # + # Returns the month in range (1..12): + # + # Date.new(2001, 2, 3).mon # => 2 + def month + m_mon + end + alias mon month + + def day + m_mday + end + alias mday day + + # call-seq: + # d.jd -> integer + # + # Returns the Julian day number. This is a whole number, which is + # adjusted by the offset as the local time. + # + # DateTime.new(2001,2,3,4,5,6,'+7').jd #=> 2451944 + # DateTime.new(2001,2,3,4,5,6,'-7').jd #=> 2451944 + def jd + m_real_jd + end + + # call-seq: + # start -> float + # + # Returns the Julian start date for calendar reform; + # if not an infinity, the returned value is suitable + # for passing to Date#jd: + # + # d = Date.new(2001, 2, 3, Date::ITALY) + # s = d.start # => 2299161.0 + # Date.jd(s).to_s # => "1582-10-15" + # + # d = Date.new(2001, 2, 3, Date::ENGLAND) + # s = d.start # => 2361222.0 + # Date.jd(s).to_s # => "1752-09-14" + # + # Date.new(2001, 2, 3, Date::GREGORIAN).start # => -Infinity + # Date.new(2001, 2, 3, Date::JULIAN).start # => Infinity + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + def start + @sg + end + + # call-seq: + # self <=> other -> -1, 0, 1 or nil + # + # Compares +self+ and +other+, returning: + # + # - -1 if +other+ is larger. + # - 0 if the two are equal. + # - 1 if +other+ is smaller. + # - +nil+ if the two are incomparable. + # + # Argument +other+ may be: + # + # - Another \Date object: + # + # d = Date.new(2022, 7, 27) # => # + # prev_date = d.prev_day # => # + # next_date = d.next_day # => # + # d <=> next_date # => -1 + # d <=> d # => 0 + # d <=> prev_date # => 1 + # + # - A DateTime object: + # + # d <=> DateTime.new(2022, 7, 26) # => 1 + # d <=> DateTime.new(2022, 7, 27) # => 0 + # d <=> DateTime.new(2022, 7, 28) # => -1 + # + # - A numeric (compares self.ajd to +other+): + # + # d <=> 2459788 # => -1 + # d <=> 2459787 # => 1 + # d <=> 2459786 # => 1 + # d <=> d.ajd # => 0 + # + # - Any other object: + # + # d <=> Object.new # => nil + def <=>(other) + case other + when Date + m_canonicalize_jd + other.send(:m_canonicalize_jd) + + a_nth = m_nth + b_nth = other.send(:m_nth) + + cmp = a_nth <=> b_nth + return cmp if cmp.nonzero? + + a_jd = m_jd + b_jd = other.send(:m_jd) + + cmp = a_jd <=> b_jd + return cmp if cmp.nonzero? + + a_df = m_df + b_df = other.send(:m_df) + + cmp = a_df <=> b_df + return cmp if cmp.nonzero? + + a_sf = m_sf + b_sf = other.send(:m_sf) + + a_sf <=> b_sf + when Numeric + ajd <=> other + else + begin + l, r = other.coerce(self) + l <=> r + rescue NoMethodError + nil + end + end + end + + # call-seq: + # self === other -> true, false, or nil. + # + # Returns +true+ if +self+ and +other+ represent the same date, + # +false+ if not, +nil+ if the two are not comparable. + # + # Argument +other+ may be: + # + # - Another \Date object: + # + # d = Date.new(2022, 7, 27) # => # + # prev_date = d.prev_day # => # + # next_date = d.next_day # => # + # d === prev_date # => false + # d === d # => true + # d === next_date # => false + # + # - A DateTime object: + # + # d === DateTime.new(2022, 7, 26) # => false + # d === DateTime.new(2022, 7, 27) # => true + # d === DateTime.new(2022, 7, 28) # => false + # + # - A numeric (compares self.jd to +other+): + # + # d === 2459788 # => true + # d === 2459787 # => false + # d === 2459786 # => false + # d === d.jd # => true + # + # - An object not comparable: + # + # d === Object.new # => nil + def ===(other) + return equal_gen(other) unless other.is_a?(Date) + + # Call equal_gen even if the Gregorian calendars do not match. + return equal_gen(other) unless m_gregorian_p? == other.send(:m_gregorian_p?) + + m_canonicalize_jd + other.send(:m_canonicalize_jd) + + a_nth = m_nth + b_nth = other.send(:m_nth) + a_jd = m_local_jd + b_jd = other.send(:m_local_jd) + + a_nth == b_nth && a_jd == b_jd + end + + # call-seq: + # d >> n -> new_date + # + # Returns a new \Date object representing the date + # +n+ months later; +n+ should be a numeric: + # + # (Date.new(2001, 2, 3) >> 1).to_s # => "2001-03-03" + # (Date.new(2001, 2, 3) >> -2).to_s # => "2000-12-03" + # + # When the same day does not exist for the new month, + # the last day of that month is used instead: + # + # (Date.new(2001, 1, 31) >> 1).to_s # => "2001-02-28" + # (Date.new(2001, 1, 31) >> -4).to_s # => "2000-09-30" + # + # This results in the following, possibly unexpected, behaviors: + # + # d0 = Date.new(2001, 1, 31) + # d1 = d0 >> 1 # => # + # d2 = d1 >> 1 # => # + # + # d0 = Date.new(2001, 1, 31) + # d1 = d0 >> 1 # => # + # d2 = d1 >> -1 # => # + def >>(n) + # Calculate years and months + t = m_real_year * 12 + (m_mon - 1) + n + + if t.is_a?(Integer) && t.abs < (1 << 62) + # Fixnum + y = t / 12 + m = (t % 12) + 1 + else + # Bignum + y = t.div(12) + m = (t % 12).to_i + 1 + end + + d = m_mday + sg = m_sg + + # Decrement days until a valid date. + result = nil + loop do + result = self.class.send(:valid_civil_p, y, m, d, sg) + break if result + + d -= 1 + raise Error if d < 1 + end + + nth = result[:nth] + rjd = result[:rjd] + rjd2 = self.class.send(:encode_jd, nth, rjd) + + self + (rjd2 - m_real_local_jd) + end + + # call-seq: + # d << n -> date + # + # Returns a new \Date object representing the date + # +n+ months earlier; +n+ should be a numeric: + # + # (Date.new(2001, 2, 3) << 1).to_s # => "2001-01-03" + # (Date.new(2001, 2, 3) << -2).to_s # => "2001-04-03" + # + # When the same day does not exist for the new month, + # the last day of that month is used instead: + # + # (Date.new(2001, 3, 31) << 1).to_s # => "2001-02-28" + # (Date.new(2001, 3, 31) << -6).to_s # => "2001-09-30" + # + # This results in the following, possibly unexpected, behaviors: + # + # d0 = Date.new(2001, 3, 31) + # d0 << 2 # => # + # d0 << 1 << 1 # => # + # + # d0 = Date.new(2001, 3, 31) + # d1 = d0 << 1 # => # + # d2 = d1 << -1 # => # + def <<(n) + raise TypeError, "expected numeric" unless n.is_a?(Numeric) + + self >> (-n) + end + + def ==(other) # :nodoc: + return false unless other.is_a?(Date) + + m_canonicalize_jd + other.send(:m_canonicalize_jd) + + m_nth == other.send(:m_nth) && + m_jd == other.send(:m_jd) && + m_df == other.send(:m_df) && + m_sf == other.send(:m_sf) + end + + def eql?(other) # :nodoc: + return false unless other.is_a?(Date) + + m_canonicalize_jd + other.send(:m_canonicalize_jd) + + m_nth == other.send(:m_nth) && + m_jd == other.send(:m_jd) && + @sg == other.instance_variable_get(:@sg) + end + + def hash # :nodoc: + m_canonicalize_jd + [m_nth, m_jd, @sg].hash + end + + # call-seq: + # d + other -> date + # + # Returns a date object pointing +other+ days after self. The other + # should be a numeric value. If the other is a fractional number, + # assumes its precision is at most nanosecond. + # + # Date.new(2001,2,3) + 1 #=> # + # DateTime.new(2001,2,3) + Rational(1,2) + # #=> # + # DateTime.new(2001,2,3) + Rational(-1,2) + # #=> # + # DateTime.jd(0,12) + DateTime.new(2001,2,3).ajd + # #=> # + def +(other) + case other + when Integer + nth = m_nth + jd = m_jd + + if (other / CM_PERIOD).nonzero? + nth = nth + (other / CM_PERIOD) + other = other % CM_PERIOD + end + + if other.nonzero? + jd = jd + other + nth, jd = canonicalize_jd(nth, jd) + end + + if simple_dat_p? + self.class.send(:new_with_jd, nth, jd, @sg) + else + self.class.send(:new_with_jd_and_time, nth, jd, @df || 0, @sf || 0, @of || 0, @sg) + end + when Float + s = other >= 0 ? 1 : -1 + o = other.abs + + tmp, o = o.divmod(1.0) + + if (tmp / CM_PERIOD).floor.zero? + nth = 0 + jd = tmp.to_i + else + i, f = (tmp / CM_PERIOD).divmod(1.0) + nth = i.floor + jd = (f * CM_PERIOD).to_i + end + + o *= DAY_IN_SECONDS + df, o = o.divmod(1.0) + df = df.to_i + o *= SECOND_IN_NANOSECONDS + sf = o.round + + if s < 0 + jd = -jd + df = -df + sf = -sf + end + + if sf.nonzero? + sf = 0 + sf + if sf < 0 + df -= 1 + sf += SECOND_IN_NANOSECONDS + elsif sf >= SECOND_IN_NANOSECONDS + df += 1 + sf -= SECOND_IN_NANOSECONDS + end + end + + if df.nonzero? + df = 0 + df + if df < 0 + jd -= 1 + df += DAY_IN_SECONDS + elsif df >= DAY_IN_SECONDS + jd += 1 + df -= DAY_IN_SECONDS + end + end + + if jd.nonzero? + jd = m_jd + jd + nth, jd = canonicalize_jd(nth, jd) + else + jd = m_jd + end + + nth = nth.nonzero? ? @nth + nth : @nth + + if df.zero? && sf.zero? && (@of.nil? || @of.zero?) + self.class.send(:new_with_jd, nth, jd, @sg) + else + self.class.send(:new_with_jd_and_time, nth, jd, df, sf, @of || 0, @sg) + end + when Rational + return self + other.numerator if other.denominator == 1 + + s = other >= 0 ? 1 : -1 + other = other.abs + + nth = other.div(CM_PERIOD) + t = other % CM_PERIOD + + jd = t.div(1).to_i + t = t % 1 + + t = t * DAY_IN_SECONDS + df = t.div(1).to_i + t = t % 1 + + sf = t * SECOND_IN_NANOSECONDS + + if s < 0 + nth = -nth + jd = -jd + df = -df + sf = -sf + end + + if sf.nonzero? + sf = (@sf || 0) + sf + if sf < 0 + df -= 1 + sf += SECOND_IN_NANOSECONDS + elsif sf >= SECOND_IN_NANOSECONDS + df += 1 + sf -= SECOND_IN_NANOSECONDS + end + else + sf = @sf || 0 + end + + if df.nonzero? + df = (@df || 0) + df + if df < 0 + jd -= 1 + df += DAY_IN_SECONDS + elsif df >= DAY_IN_SECONDS + jd += 1 + df -= DAY_IN_SECONDS + end + else + df = @df || 0 + end + + if jd.nonzero? + jd = m_jd + jd + nth, jd = canonicalize_jd(nth, jd) + else + jd = m_jd + end + + nth = nth.nonzero? ? @nth + nth : @nth + + if df.zero? && sf.zero? + self.class.send(:new_with_jd, nth, jd, @sg) + else + self.class.send(:new_with_jd_and_time, nth, jd, df, sf, @of || 0, @sg) + end + else + raise TypeError, "expected numeric" unless other.is_a?(Numeric) + + other = other.to_r + raise TypeError, "expected numeric" unless other.is_a?(Rational) + + self + other + end + end + + # call-seq: + # d - other -> date or rational + # + # If the other is a date object, returns a Rational + # whose value is the difference between the two dates in days. + # If the other is a numeric value, returns a date object + # pointing +other+ days before self. + # If the other is a fractional number, + # assumes its precision is at most nanosecond. + # + # Date.new(2001,2,3) - 1 #=> # + # DateTime.new(2001,2,3) - Rational(1,2) #=> # + # Date.new(2001,2,3) - Date.new(2001) #=> (33/1) + # DateTime.new(2001,2,3) - DateTime.new(2001,2,2,12) #=> (1/2) + def -(other) + return minus_dd(other) if other.is_a?(Date) + + raise TypeError, "expected numeric" unless other.is_a?(Numeric) + + # Add a negative value for numbers. + # Works with all types: Integer, Float, Rational, Bignum, etc. + self + (-other) + end + + # call-seq: + # gregorian -> new_date + # + # Equivalent to Date#new_start with argument Date::GREGORIAN. + def gregorian + dup_obj_with_new_start(GREGORIAN) + end + + # call-seq: + # gregorian? -> true or false + # + # Returns +true+ if the date is on or after + # the date of calendar reform, +false+ otherwise: + # + # Date.new(1582, 10, 15).gregorian? # => true + # (Date.new(1582, 10, 15) - 1).gregorian? # => false + def gregorian? + m_gregorian_p? + end + + # call-seq: + # italy -> new_date + # + # Equivalent to Date#new_start with argument Date::ITALY. + def italy + dup_obj_with_new_start(ITALY) + end + + # call-seq: + # england -> new_date + # + # Equivalent to Date#new_start with argument Date::ENGLAND. + def england + dup_obj_with_new_start(ENGLAND) + end + + # call-seq: + # julian -> new_date + # + # Equivalent to Date#new_start with argument Date::JULIAN. + def julian + dup_obj_with_new_start(JULIAN) + end + + # call-seq: + # d.julian? -> true or false + # + # Returns +true+ if the date is before the date of calendar reform, + # +false+ otherwise: + # + # (Date.new(1582, 10, 15) - 1).julian? # => true + # Date.new(1582, 10, 15).julian? # => false + def julian? + m_julian_p? + end + + # call-seq: + # ld -> integer + # + # Returns the + # {Lilian day number}[https://en.wikipedia.org/wiki/Lilian_date], + # which is the number of days since the beginning of the Gregorian + # calendar, October 15, 1582. + # + # Date.new(2001, 2, 3).ld # => 152784 + def ld + m_real_local_jd - 2299160 + end + + # call-seq: + # leap? -> true or false + # + # Returns +true+ if the year is a leap year, +false+ otherwise: + # + # Date.new(2000).leap? # => true + # Date.new(2001).leap? # => false + def leap? + if gregorian? + # For the Gregorian calendar, get m_year to determine if it is a leap year. + y = m_year + + return self.class.send(:c_gregorian_leap_p?, y) + end + + # For the Julian calendar, calculate JD for March 1st. + y = m_year + sg = m_virtual_sg + rjd, _ = self.class.send(:c_civil_to_jd, y, 3, 1, sg) + + # Get the date of the day before March 1st (the last day of February). + _, _, rd = self.class.send(:c_jd_to_civil, rjd - 1, sg) + + # If February 29th exists, it is a leap year. + rd == 29 + end + + # call-seq: + # new_start(start = Date::ITALY]) -> new_date + # + # Returns a copy of +self+ with the given +start+ value: + # + # d0 = Date.new(2000, 2, 3) + # d0.julian? # => false + # d1 = d0.new_start(Date::JULIAN) + # d1.julian? # => true + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + def new_start(start = DEFAULT_SG) + sg = start ? val2sg(start) : DEFAULT_SG + + dup_obj_with_new_start(sg) + end + + # call-seq: + # next_day(n = 1) -> new_date + # + # Equivalent to Date#+ with argument +n+. + def next_day(n = 1) + self + n + end + + # call-seq: + # prev_day(n = 1) -> new_date + # + # Equivalent to Date#- with argument +n+. + def prev_day(n = 1) + self - n + end + + # call-seq: + # d.next -> new_date + # + # Returns a new \Date object representing the following day: + # + # d = Date.new(2001, 2, 3) + # d.to_s # => "2001-02-03" + # d.next.to_s # => "2001-02-04" + def next + next_day + end + alias_method :succ, :next + + # call-seq: + # next_year(n = 1) -> new_date + # + # Equivalent to #>> with argument n * 12. + def next_year(n = 1) + self >> (n * 12) + end + + # call-seq: + # prev_year(n = 1) -> new_date + # + # Equivalent to #<< with argument n * 12. + def prev_year(n = 1) + self << (n * 12) + end + + # call-seq: + # next_month(n = 1) -> new_date + # + # Equivalent to #>> with argument +n+. + def next_month(n = 1) + self >> n + end + + # call-seq: + # prev_month(n = 1) -> new_date + # + # Equivalent to #<< with argument +n+. + def prev_month(n = 1) + self << n + end + + # call-seq: + # sunday? -> true or false + # + # Returns +true+ if +self+ is a Sunday, +false+ otherwise. + def sunday? + m_wday.zero? + end + + # call-seq: + # monday? -> true or false + # + # Returns +true+ if +self+ is a Monday, +false+ otherwise. + def monday? + m_wday == 1 + end + + # call-seq: + # tuesday? -> true or false + # + # Returns +true+ if +self+ is a Tuesday, +false+ otherwise. + def tuesday? + m_wday == 2 + end + + # call-seq: + # wednesday? -> true or false + # + # Returns +true+ if +self+ is a Wednesday, +false+ otherwise. + def wednesday? + m_wday == 3 + end + + # call-seq: + # thursday? -> true or false + # + # Returns +true+ if +self+ is a Thursday, +false+ otherwise. + def thursday? + m_wday == 4 + end + + # call-seq: + # friday? -> true or false + # + # Returns +true+ if +self+ is a Friday, +false+ otherwise. + def friday? + m_wday == 5 + end + + # call-seq: + # saturday? -> true or false + # + # Returns +true+ if +self+ is a Saturday, +false+ otherwise. + def saturday? + m_wday == 6 + end + + # call-seq: + # wday -> integer + # + # Returns the day of week in range (0..6); Sunday is 0: + # + # Date.new(2001, 2, 3).wday # => 6 + def wday + m_wday + end + + # call-seq: + # yday -> integer + # + # Returns the day of the year, in range (1..366): + # + # Date.new(2001, 2, 3).yday # => 34 + def yday + m_yday + end + + # call-seq: + # deconstruct_keys(array_of_names_or_nil) -> hash + # + # Returns a hash of the name/value pairs, to use in pattern matching. + # Possible keys are: :year, :month, :day, + # :wday, :yday. + # + # Possible usages: + # + # d = Date.new(2022, 10, 5) + # + # if d in wday: 3, day: ..7 # uses deconstruct_keys underneath + # puts "first Wednesday of the month" + # end + # #=> prints "first Wednesday of the month" + # + # case d + # in year: ...2022 + # puts "too old" + # in month: ..9 + # puts "quarter 1-3" + # in wday: 1..5, month: + # puts "working day in month #{month}" + # end + # #=> prints "working day in month 10" + # + # Note that deconstruction by pattern can also be combined with class check: + # + # if d in Date(wday: 3, day: ..7) + # puts "first Wednesday of the month" + # end + def deconstruct_keys(keys) + if keys.nil? + return { + year: year, + month: month, + day: day, + yday: yday, + wday: wday + } + end + + raise TypeError, "wrong argument type #{keys.class} (expected Array or nil)" unless keys.is_a?(Array) + + h = {} + keys.each do |key| + case key + when :year then h[:year] = year + when :month then h[:month] = month + when :day then h[:day] = day + when :yday then h[:yday] = yday + when :wday then h[:wday] = wday + when :zone then h[:zone] = zone + end + end + h + end + + # call-seq: + # step(limit, step = 1){|date| ... } -> self + # + # Calls the block with specified dates; + # returns +self+. + # + # - The first +date+ is +self+. + # - Each successive +date+ is date + step, + # where +step+ is the numeric step size in days. + # - The last date is the last one that is before or equal to +limit+, + # which should be a \Date object. + # + # Example: + # + # limit = Date.new(2001, 12, 31) + # Date.new(2001).step(limit){|date| p date.to_s if date.mday == 31 } + # + # Output: + # + # "2001-01-31" + # "2001-03-31" + # "2001-05-31" + # "2001-07-31" + # "2001-08-31" + # "2001-10-31" + # "2001-12-31" + # + # Returns an Enumerator if no block is given. + def step(limit, step = 1) + raise ArgumentError, "step must be numeric" unless step.respond_to?(:<=>) + + return to_enum(:step, limit, step) unless block_given? + + date = self + cmp = step <=> 0 + + raise ArgumentError, "step must be numeric" if cmp.nil? + + case cmp + when -1 + # If step is negative (reverse order) + while (date <=> limit) >= 0 + yield date + date = date + step + end + when 0 + # If step is 0 (infinite loop) + loop do + yield date + end + else + # If step is positive (forward direction) + while (date <=> limit) <= 0 + yield date + date = date + step + end + end + + self + end + + # call-seq: + # upto(max){|date| ... } -> self + # + # Equivalent to #step with arguments +max+ and +1+. + def upto(max) + return to_enum(:upto, max) unless block_given? + + date = self + + while (date <=> max) <= 0 + yield date + date = date + 1 + end + + self + end + + # call-seq: + # downto(min){|date| ... } -> self + # + # Equivalent to #step with arguments +min+ and -1. + def downto(min) + return to_enum(:downto, min) unless block_given? + + date = self + + while (date <=> min) >= 0 + yield date + date = date - 1 + end + + self + end + + # call-seq: + # day_fraction -> rational + # + # Returns the fractional part of the day in range (Rational(0, 1)...Rational(1, 1)): + # + # DateTime.new(2001,2,3,12).day_fraction # => (1/2) + def day_fraction + simple_dat_p? ? 0 : m_fr + end + + # call-seq: + # d.mjd -> integer + # + # Returns the modified Julian day number. This is a whole number, + # which is adjusted by the offset as the local time. + # + # DateTime.new(2001,2,3,4,5,6,'+7').mjd #=> 51943 + # DateTime.new(2001,2,3,4,5,6,'-7').mjd #=> 51943 + def mjd + m_real_local_jd - 2_400_001 + end + + # call-seq: + # cwyear -> integer + # + # Returns commercial-date year for +self+ + # (see Date.commercial): + # + # Date.new(2001, 2, 3).cwyear # => 2001 + # Date.new(2000, 1, 1).cwyear # => 1999 + def cwyear + m_real_cwyear + end + + # call-seq: + # cweek -> integer + # + # Returns commercial-date week index for +self+ + # (see Date.commercial): + # + # Date.new(2001, 2, 3).cweek # => 5 + def cweek + m_cweek + end + + # call-seq: + # cwday -> integer + # + # Returns the commercial-date weekday index for +self+ + # (see Date.commercial); + # 1 is Monday: + # + # Date.new(2001, 2, 3).cwday # => 6 + def cwday + m_cwday + end + + # call-seq: + # to_time -> time + # + # Returns a new Time object with the same value as +self+; + # if +self+ is a Julian date, derives its Gregorian date + # for conversion to the \Time object: + # + # Date.new(2001, 2, 3).to_time # => 2001-02-03 00:00:00 -0600 + # Date.new(2001, 2, 3, Date::JULIAN).to_time # => 2001-02-16 00:00:00 -0600 + def to_time + # Julian calendar converted to Gregorian calendar. + date = m_julian_p? ? gregorian : self + + # Create a Time object using Time.local. + Time.local( + date.send(:m_real_year), + date.send(:m_mon), + date.send(:m_mday) + ) + end + + # call-seq: + # to_date -> self + # + # Returns +self+. + def to_date + self + end + + # call-seq: + # to_datetime -> datetime + # + # Returns a DateTime whose value is the same as +self+. + def to_datetime + # Use internal constructor to bypass validation (reform-gap safety) + nth, ry = self.class.send(:decode_year, year, -1) + rjd, _ = self.class.send(:c_civil_to_jd, ry, month, day, Date::GREGORIAN) + obj = DateTime.send(:new_with_jd_and_time, nth, rjd, 0, 0, 0, Date::GREGORIAN) + obj.send(:set_sg, start) + obj + end + + # call-seq: + # d.ajd -> rational + # + # Returns the astronomical Julian day number. This is a fractional + # number, which is not adjusted by the offset. + # + # DateTime.new(2001,2,3,4,5,6,'+7').ajd #=> (11769328217/4800) + # DateTime.new(2001,2,2,14,5,6,'-7').ajd #=> (11769328217/4800) + def ajd + m_ajd + end + + # call-seq: + # d.amjd -> rational + # + # Returns the astronomical modified Julian day number. This is + # a fractional number, which is not adjusted by the offset. + # + # DateTime.new(2001,2,3,4,5,6,'+7').amjd #=> (249325817/4800) + # DateTime.new(2001,2,2,14,5,6,'-7').amjd #=> (249325817/4800) + def amjd + m_amjd + end + + # :nodoc: + # C: d_lite_initialize_copy + def initialize_copy(other) + unless other.is_a?(Date) + raise TypeError, "initialize_copy should take same class object" + end + @nth = other.instance_variable_get(:@nth) + @jd = other.instance_variable_get(:@jd) + @sg = other.instance_variable_get(:@sg) + @df = other.instance_variable_get(:@df) + @sf = other.instance_variable_get(:@sf) + @of = other.instance_variable_get(:@of) + @year = other.instance_variable_get(:@year) + @month = other.instance_variable_get(:@month) + @day = other.instance_variable_get(:@day) + @has_jd = other.instance_variable_get(:@has_jd) + @has_civil = other.instance_variable_get(:@has_civil) + self + end + + # :nodoc: + def marshal_dump + [ + m_nth, + m_jd, + m_df, + m_sf, + m_of, + @sg + ] + end + + # :nodoc: + # C: d_lite_marshal_load + # Supports 3 historical formats: + # 2 elements (1.4/1.6): [jd_like, sg_or_bool] + # 3 elements (1.8/1.9.2): [ajd, of, sg] + # 6 elements (current): [nth, jd, df, sf, of, sg] + def marshal_load(array) + raise TypeError, "expected an array" unless array.is_a?(Array) + + case array.size + when 2 # Ruby 1.4/1.6 + # C: ajd = f_sub(a[0], half_days_in_day); vof = 0; vsg = a[1] + ajd = array[0] - Rational(1, 2) + vof = 0 + vsg = array[1] + unless vsg.is_a?(Numeric) + vsg = vsg ? -Float::INFINITY : Float::INFINITY + end + nth, jd, df, sf, of_sec, sg = old_to_new(ajd, vof, vsg) + + when 3 # Ruby 1.8 / 1.9.2 + ajd = array[0] + vof = array[1] + vsg = array[2] + nth, jd, df, sf, of_sec, sg = old_to_new(ajd, vof, vsg) + + when 6 # Current format + nth, jd, df, sf, of_sec, sg = array + + else + raise TypeError, "invalid size" + end + + @nth = nth + @jd = jd + @df = (!df || df == 0) ? nil : df + @sf = (!sf || sf == 0) ? nil : sf + @of = (!of_sec || of_sec == 0) ? nil : of_sec + @sg = sg + + @has_jd = true + @has_civil = false + @year = nil + @month = nil + @day = nil + end + + # call-seq: + # asctime -> string + # + # Equivalent to #strftime with argument '%a %b %e %T %Y' + # (or its {shorthand form}[rdoc-ref:language/strftime_formatting.rdoc@Shorthand+Conversion+Specifiers] + # '%c'): + # + # Date.new(2001, 2, 3).asctime # => "Sat Feb 3 00:00:00 2001" + # + # See {asctime}[https://linux.die.net/man/3/asctime]. + # + def asctime + strftime('%a %b %e %H:%M:%S %Y') + end + alias_method :ctime, :asctime + + # call-seq: + # iso8601 -> string + # + # Equivalent to #strftime with argument '%Y-%m-%d' + # (or its {shorthand form}[rdoc-ref:language/strftime_formatting.rdoc@Shorthand+Conversion+Specifiers] + # '%F'); + # + # Date.new(2001, 2, 3).iso8601 # => "2001-02-03" + def iso8601 + strftime('%Y-%m-%d') + end + alias_method :xmlschema, :iso8601 + + # call-seq: + # rfc3339 -> string + # + # Equivalent to #strftime with argument '%FT%T%:z'; + # see {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]: + # + # Date.new(2001, 2, 3).rfc3339 # => "2001-02-03T00:00:00+00:00" + def rfc3339 + strftime('%Y-%m-%dT%H:%M:%S%:z') + end + + # call-seq: + # rfc2822 -> string + # + # Equivalent to #strftime with argument '%a, %-d %b %Y %T %z'; + # see {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]: + # + # Date.new(2001, 2, 3).rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000" + def rfc2822 + strftime('%a, %-d %b %Y %T %z') + end + alias_method :rfc822, :rfc2822 + + # call-seq: + # httpdate -> string + # + # Equivalent to #strftime with argument '%a, %d %b %Y %T GMT'; + # see {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]: + # + # Date.new(2001, 2, 3).httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT" + # + def httpdate + # For Date objects, offset is always 0, so we can directly call strftime + strftime('%a, %d %b %Y %T GMT') + end + + # call-seq: + # jisx0301 -> string + # + # Returns a string representation of the date in +self+ + # in JIS X 0301 format. + # + # Date.new(2001, 2, 3).jisx0301 # => "H13.02.03" + # + def jisx0301 + jd = m_real_local_jd + y = m_real_year + + fmt = jisx0301_date_format(jd, y) + strftime(fmt) + end + + def to_s + s = sprintf("%04d-%02d-%02d", year, month, day) + s.force_encoding(Encoding::US_ASCII) + end + + # call-seq: + # inspect -> string + # + # Returns a string representation of +self+: + # + # Date.new(2001, 2, 3).inspect + # # => "#" + def inspect + s = if simple_dat_p? + inspect_raw + else + # In the case of complex, time information is also displayed. + strftime("%Y-%m-%d %H:%M:%S") + end + s.force_encoding(Encoding::US_ASCII) if s.ascii_only? + s + end + + # override + def freeze + # Force lazy computation before freezing so Ractor-shared objects work. + if simple_dat_p? + get_s_jd + get_s_civil + canonicalize_s_jd + else + get_c_jd + get_c_civil + get_c_df + get_c_time + canonicalize_c_jd + end + super + end + + private + + def inspect_raw + # If @sg is infinity + if @sg.infinite? + if @sg < 0 + return "#" + else + return "#" + end + end + + date_str = strftime("%Y-%m-%d") + jd_val = @jd || 0 + sg_val = @sg.infinite? ? (@sg < 0 ? "Inf" : "-Inf") : @sg.to_i + + "#" + end + + def valid_civil?(y, m, d) + return false if m < 1 || m > 12 + + last = last_day_of_month(y, m) + d >= 1 && d <= last + end + + def last_day_of_month(y, m) + last_day_of_month_gregorian(y, m) + end + + def civil_to_jd(y, m, d, sg) + self.class.send(:gregorian_civil_to_jd, y, m, d) + end + + def jd_to_civil(jd, sg) + decode_jd(jd) + self.class.send(:c_jd_to_civil, jd, sg) + end + + def extract_fraction(value) + self.class.send(:extract_fraction, value) + end + + def decode_year(year, style) + self.class.send(:decode_year, year, style) + end + + def valid_gregorian?(y, m, d) + return false if m < 1 || m > 12 + + # Handling negative months and days + m = m + 13 if m < 0 + return false if m < 1 || m > 12 + + last_day = last_day_of_month_gregorian(y, m) + d = last_day + d + 1 if d < 0 + + d >= 1 && d <= last_day + end + + def add_with_fraction(n) + int_part = n.floor + frac_part = n - int_part + + result = add_days(int_part) + + result = result.send(:add_fraction, frac_part) if frac_part.nonzero? + + result + end + + def add_days(days) + new_jd = @jd + days + new_nth = @nth + + while new_jd < 0 + new_nth -= 1 + new_jd += CM_PERIOD + end + + while new_jd >= CM_PERIOD + new_nth += 1 + new_jd -= CM_PERIOD + end + + obj = self.class.allocate + obj.instance_variable_set(:@nth, new_nth) + obj.instance_variable_set(:@jd, new_jd) + obj.instance_variable_set(:@sg, @sg) + obj.instance_variable_set(:@flags, HAVE_JD) + obj.instance_variable_set(:@year, nil) + obj.instance_variable_set(:@month, nil) + obj.instance_variable_set(:@day, nil) + + obj + end + + def add_fraction(frac) + # In the C implementation, Date.jd(2451944.5) becomes 2451945, + # so if there is a decimal point, it will be rounded up by one day. + if frac > 0 + add_days(1) + else + self + end + end + + def last_day_of_month_gregorian(y, m) + self.class.send(:last_day_of_month_gregorian, y, m) + end + + def last_day_of_month_julian(y, m) + self.class.send(:last_day_of_month_julian, y, m) + end + + def valid_civil_date?(year, month, day, sg) + self.class.send(:valid_civil_date?, year, month, day, sg) + end + + def canonicalize_jd(nth, jd) + if jd < 0 + nth = nth - 1 + jd += CM_PERIOD + end + if jd >= CM_PERIOD + nth = nth + 1 + jd -= CM_PERIOD + end + + [nth, jd] + end + + # If any of @df, @sf, or @of is not nil, it is considered complex. + def simple_dat_p? + @df.nil? && @sf.nil? && @of.nil? + end + + def complex_dat_p? + !simple_dat_p? + end + + def m_gregorian_p? + !m_julian_p? + end + + def m_julian_p? + # Divide the processing into simple and complex. + if simple_dat_p? + get_s_jd + jd = @jd + sg = s_virtual_sg + else + get_c_jd + jd = @jd + sg = c_virtual_sg + end + + return sg == JULIAN if sg.infinite? + + jd < sg + end + + def m_year + simple_dat_p? ? get_s_civil : get_c_civil + + @year + end + + def m_virtual_sg + simple_dat_p? ? s_virtual_sg : c_virtual_sg + end + + def get_s_jd + # For simple data, if JD has not yet been calculated. + return if @has_jd + + return unless simple_dat_p? + + return unless @has_civil + + # Calculate JD from civil. + jd, _ = self.class.send(:c_civil_to_jd, @year, @month, @day, s_virtual_sg) + @jd = jd + @has_jd = true + end + + def get_s_civil + # For simple data, if civil has not yet been calculated. + return if @has_civil + + # If not simple or there is no JD, do nothing. + return unless simple_dat_p? + return unless @has_jd + + # Calculate civil from JD. + y, m, d = self.class.send(:c_jd_to_civil, @jd, s_virtual_sg) + @year = y + @month = m + @day = d + @has_civil = true + end + + def get_c_jd + # For complex data, if JD has not yet been calculated. + return if @has_jd + + # Make sure you have civil data. + raise "No civil data" unless @has_civil + + # Calculate JD from civil. + jd, _ = self.class.send(:c_civil_to_jd, @year, @month, @day, c_virtual_sg) + + # Consider time data. + get_c_time + + # Convert from local to UTC. + @jd = jd_local_to_utc(jd, time_to_df(@hour || 0, @min || 0, @sec || 0), @of || 0) + @has_jd = true + end + + def get_c_civil + # For complex data, if civil has not yet been calculated. + return if @has_civil + + # Make sure you have a JD. + raise "No JD data" unless @has_jd + + get_c_df + + # Convert UTC to local. + jd = jd_utc_to_local(@jd, @df || 0, @of || 0) + + # Calculate civil from JD. + y, m, d = self.class.send(:c_jd_to_civil, jd, c_virtual_sg) + @year = y + @month = m + @day = d + @has_civil = true + end + + def get_c_df + # If df (day fraction) has not yet been calculated. + return if @df + + # Check that time data is available. + raise "No time data" if @hour.nil? && @min.nil? && @sec.nil? + + # Convert time to df + @df = df_local_to_utc(time_to_df(@hour, @min, @sec), @of || 0) + end + + def get_c_time + # If the time data has not yet been calculated. + return unless @hour.nil? + + # Make sure df exists. + raise "No df data" if @df.nil? + + # Convert df to time. + r = df_utc_to_local(@df, @of || 0) + + @hour, @min, @sec = df_to_time(r) + end + + # For SimpleDateData (effectively a common implementation) + def s_virtual_sg + return @sg if @sg.infinite? + return @sg if self.class.send(:f_zero_p?, @nth) + + @nth < 0 ? JULIAN : GREGORIAN + end + + # For ComplexDateData (effectively a common implementation) + def c_virtual_sg + return @sg if @sg.infinite? + return @sg if self.class.send(:f_zero_p?, @nth) + + @nth < 0 ? JULIAN : GREGORIAN + end + + def jd_local_to_utc(jd, df, of) + df -= of + if df < 0 + jd -= 1 + elsif df >= DAY_IN_SECONDS + jd += 1 + end + + jd + end + + def jd_utc_to_local(jd, df, of) + df += of + if df < 0 + jd -= 1 + elsif df >= DAY_IN_SECONDS + jd += 1 + end + + jd + end + + def df_local_to_utc(df, of) + df -= of + if df < 0 + df += DAY_IN_SECONDS + elsif df >= DAY_IN_SECONDS + df -= DAY_IN_SECONDS + end + + df + end + + def df_utc_to_local(df, of) + df += of + if df < 0 + df += DAY_IN_SECONDS + elsif df >= DAY_IN_SECONDS + df -= DAY_IN_SECONDS + end + + df + end + + def time_to_df(h, min, s) + h * HOUR_IN_SECONDS + min * MINUTE_IN_SECONDS + s + end + + def df_to_time(df) + h = df / HOUR_IN_SECONDS + df %= HOUR_IN_SECONDS + min = df / MINUTE_IN_SECONDS + s = df % MINUTE_IN_SECONDS + + [h, min, s] + end + + def minus_dd(other) + n = m_nth - other.send(:m_nth) + d = m_jd - other.send(:m_jd) + df = m_df - other.send(:m_df) + sf = m_sf - other.send(:m_sf) + + n, d = canonicalize_jd(n, d) + + # Canonicalize df + if df < 0 + d -= 1 + df += DAY_IN_SECONDS + elsif df >= DAY_IN_SECONDS + d += 1 + df -= DAY_IN_SECONDS + end + + # Canonicalize sf + if sf < 0 + df -= 1 + sf += SECOND_IN_NANOSECONDS + elsif sf >= SECOND_IN_NANOSECONDS + df += 1 + sf -= SECOND_IN_NANOSECONDS + end + + r = n.zero? ? 0 : n * CM_PERIOD + r = r + Rational(d, 1) if d.nonzero? + r = r + isec_to_day(df) if df.nonzero? + r = r + ns_to_day(sf) if sf.nonzero? + + r.is_a?(Rational) ? r : Rational(r, 1) + end + + def m_jd + simple_dat_p? ? get_s_jd : get_c_jd + + @jd + end + + def m_df + if simple_dat_p? + 0 + else + get_c_df + @df || 0 + end + end + + def m_sf + simple_dat_p? ? 0 : @sf || 0 + end + + def m_of + if simple_dat_p? + 0 + else + get_c_jd + @of || 0 + end + end + + def m_real_year + nth = @nth + year = m_year + + return year if self.class.send(:f_zero_p?, nth) + + encode_year(nth, year, gregorian? ? -1 : 1) + end + + def m_mon + simple_dat_p? ? get_s_civil : get_c_civil + + @month + end + + def m_mday + simple_dat_p? ? get_s_civil : get_c_civil + + @day + end + + def m_sg + get_c_jd unless simple_dat_p? + + @sg + end + + def encode_year(nth, y, style) + period = (style < 0) ? CM_PERIOD_GCY : CM_PERIOD_JCY + + self.class.send(:f_zero_p?, nth) ? y : period * nth + y + end + + def m_real_local_jd + nth = m_nth + jd = m_local_jd + + self.class.send(:encode_jd, nth, jd) + end + + def m_local_jd + if simple_dat_p? + get_s_jd + @jd + else + get_c_jd + get_c_df + local_jd + end + end + + def local_jd + jd = @jd + df = @df || 0 + of = @of || 0 + + df += of + if df < 0 + jd -= 1 + elsif df >= DAY_IN_SECONDS + jd += 1 + end + + jd + end + + def m_nth + # For complex, get civil data and then return nth. + get_c_civil unless simple_dat_p? + + @nth + end + + def equal_gen(other) + if other.is_a?(Numeric) + m_real_local_jd == other + elsif other.is_a?(Date) + m_real_local_jd == other.send(:m_real_local_jd) + else + begin + coerced = other.coerce(self) + coerced[0] == coerced[1] + rescue + false + end + end + end + + def m_canonicalize_jd + if simple_dat_p? + get_s_jd + canonicalize_s_jd + else + get_c_jd + canonicalize_c_jd + end + end + + # Simple + def canonicalize_s_jd + return if frozen? + + j = @jd + + @nth, @jd = canonicalize_jd(@nth, @jd) + + # Invalidate civil data if JD changes. + @has_civil = false if @jd != j + end + + # Complex + def canonicalize_c_jd + return if frozen? + + j = @jd + + @nth, @jd = canonicalize_jd(@nth, @jd) + + # Invalidate civil data if JD changes. + @has_civil = false if @jd != j + end + + def f_jd(other) + # Get JD from another Date object. + other.send(:m_real_local_jd) + end + + def dup_obj_with_new_start(sg) + dup = dup_obj + dup.send(:set_sg, sg) + + dup + end + + def dup_obj + if simple_dat_p? + # Simple data replication + new_obj = self.class.send(:d_lite_s_alloc_simple) + + new_obj.instance_variable_set(:@nth, canon(@nth)) + new_obj.instance_variable_set(:@jd, @jd) + new_obj.instance_variable_set(:@sg, @sg) + new_obj.instance_variable_set(:@year, @year) + new_obj.instance_variable_set(:@month, @month) + new_obj.instance_variable_set(:@day, @day) + new_obj.instance_variable_set(:@has_jd, @has_jd) + new_obj.instance_variable_set(:@has_civil, @has_civil) + new_obj.instance_variable_set(:@df, nil) + new_obj.instance_variable_set(:@sf, nil) + new_obj.instance_variable_set(:@of, nil) + + new_obj + else + # Complex data replication + new_obj = self.class.send(:d_lite_s_alloc_complex) + + new_obj.instance_variable_set(:@nth, canon(@nth)) + new_obj.instance_variable_set(:@jd, @jd) + new_obj.instance_variable_set(:@sg, @sg) + new_obj.instance_variable_set(:@year, @year) + new_obj.instance_variable_set(:@month, @month) + new_obj.instance_variable_set(:@day, @day) + new_obj.instance_variable_set(:@hour, @hour) + new_obj.instance_variable_set(:@min, @min) + new_obj.instance_variable_set(:@sec, @sec) + new_obj.instance_variable_set(:@df, @df) + new_obj.instance_variable_set(:@sf, canon(@sf)) + new_obj.instance_variable_set(:@of, @of) + new_obj.instance_variable_set(:@has_jd, @has_jd) + new_obj.instance_variable_set(:@has_civil, @has_civil) + + new_obj + end + end + + def set_sg(sg) + if simple_dat_p? + get_s_jd if @has_jd || @has_civil + else + get_c_jd + get_c_df + end + + clear_civil + + @sg = sg + end + + def clear_civil + @has_civil = false + @year = nil + @month = nil + @day = nil + end + + # If the argument is Rational and the denominator is 1, return the numerator. + def canon(x) + x.is_a?(Rational) && x.denominator == 1 ? x.numerator : x + end + + def val2sg(vsg) + # Convert to Number. + sg = vsg.to_f + + # Check for a valid start. + unless c_valid_start_p?(sg) + warn "invalid start is ignored" + sg = DEFAULT_SG + end + + sg + end + + def c_valid_start_p?(sg) + # Invalid for NaN. + return false if sg.respond_to?(:nan?) && sg.nan? + + # Valid for Infinity. + return true if sg.respond_to?(:infinite?) && sg.infinite? + + # If it is a finite value, check if it is within the range + # from REFORM_BEGIN_JD to REFORM_END_JD + return false if sg < REFORM_BEGIN_JD || sg > REFORM_END_JD + + true + end + + def m_wday + c_jd_to_wday(m_local_jd) + end + + def c_jd_to_wday(jd) + (jd + 1) % 7 + end + + def m_yday + jd = m_local_jd + sg = m_virtual_sg + + # proleptic gregorian or if more than 366 days have passed since the calendar change + return c_gregorian_to_yday(m_year, m_mon, m_mday) if m_proleptic_gregorian_p? || (jd - sg) > 366 + + # proleptic Julian + return c_julian_to_yday(m_year, m_mon, m_mday) if m_proleptic_julian_p? + + # Otherwise, convert from JD to ordinal. + _, rd = self.class.send(:c_jd_to_ordinal, jd, sg) + + rd + end + + def m_proleptic_gregorian_p? + sg = @sg + + sg.infinite? && sg < 0 + end + + def m_proleptic_julian_p? + sg = @sg + + sg.infinite? && sg > 0 + end + + def c_gregorian_to_yday(year, month, day) + leap = self.class.send(:c_gregorian_leap_p?, year) + + YEARTAB[leap ? 1 : 0][month] + day + end + + def c_julian_to_yday(year, month, day) + leap = self.class.send(:c_julian_leap_p?, year) + + YEARTAB[leap ? 1 : 0][month] + day + end + + def d_trunc_with_frac(value) + if value.is_a?(Integer) + [value, 0] + elsif value.is_a?(Float) + trunc = value.truncate + frac = value - trunc + + [trunc, frac] + elsif value.is_a?(Rational) + trunc = value.truncate + frac = value - trunc + + [trunc, frac] + else + [value.to_i, 0] + end + end + + def m_real_jd + # C: m_real_jd uses m_jd (raw/UTC JD), NOT m_local_jd + nth = m_nth + if simple_dat_p? + get_s_jd + else + get_c_jd + end + self.class.send(:encode_jd, nth, @jd) + end + + def m_fr + if simple_dat_p? + 0 + else + df = m_local_df + sf = m_sf + + fr = isec_to_day(df) + fr = fr + ns_to_day(sf) if sf.nonzero? + + fr + end + end + + def m_local_df + if simple_dat_p? + 0 + else + get_c_df + local_df + end + end + + def local_df + df_utc_to_local(@df || 0, @of || 0) + end + + def isec_to_day(s) + sec_to_day(s) + end + + def sec_to_day(s) + s.is_a?(Integer) ? Rational(s, DAY_IN_SECONDS) : s.quo(DAY_IN_SECONDS) + end + + def ns_to_day(n) + if n.is_a?(Integer) + Rational(n, DAY_IN_SECONDS * SECOND_IN_NANOSECONDS) + else + n.quo(DAY_IN_SECONDS * SECOND_IN_NANOSECONDS) + end + end + + def m_real_cwyear + nth = m_nth + year = m_cwyear + + nth.zero? ? year : encode_year(nth, year, m_gregorian_p? ? -1 : 1) + end + + def m_cwyear + jd = m_local_jd + sg = m_virtual_sg + + ry, _, _ = self.class.send(:c_jd_to_commercial, jd, sg) + + ry + end + + def m_cweek + jd = m_local_jd + sg = m_virtual_sg + + _, rw, _ = self.class.send(:c_jd_to_commercial, jd, sg) + + rw + end + + def m_cwday + w = m_wday + # ISO 8601 places Sunday at 7. + w.zero? ? 7 : w + end + + def m_ajd + if simple_dat_p? + # For simple date: + r = m_real_jd + + # Optimization: Integer operations within Fixnum range + if r.is_a?(Integer) && r <= (2**62 - 1) / 2 && r >= (-(2**62) + 1) / 2 + ir = r * 2 - 1 + return Rational(ir, 2) + else + return Rational(r * 2 - 1, 2) + end + end + + # For complex date: + r = m_real_jd + df = m_df + + # Subtract half a day (12 hours) from df. + df -= HALF_DAYS_IN_SECONDS + + # If df is not zero, add. + r = r + isec_to_day(df) if df != 0 + + # If sf is not zero, add. + sf = m_sf + r = r + ns_to_day(sf) if sf != 0 + + r + end + + def m_amjd + r = m_real_jd + + # Optimization: Integer operations within Fixnum range + if r.is_a?(Integer) && r >= (-(2**62) + 2400001) + ir = r - 2400001 + r = Rational(ir, 1) + else + r = Rational(m_real_jd - 2400001, 1) + end + + # For simple date, stop here. + return r if simple_dat_p? + + # For complex date, add df and sf. + df = m_df + r = r + isec_to_day(df) if df != 0 + + sf = m_sf + r = r + ns_to_day(sf) if sf != 0 + + r + end + + def m_wnumx(f) + _, rw, _ = c_jd_to_weeknum(m_local_jd, f, m_virtual_sg) + + rw + end + + def c_jd_to_weeknum(jd, f, sg) + ry, _, _ = self.class.send(:c_jd_to_civil, jd, sg) + rjd, _ = self.class.send(:c_find_fdoy, ry, sg) + + rjd += 6 + + mod_val = euclidean_mod((rjd - f) + 1, 7) + j = jd - (rjd - mod_val) + 7 + + rw = euclidean_div(j, 7) + rd = euclidean_mod(j, 7) + + [ry, rw, rd] + end + + # Euclidean division (equivalent to the DIV macro in C) + def euclidean_div(a, b) + q = a / b + r = a % b + # In Ruby, a remainder of a negative number is negative, so adjust it accordingly. + if r < 0 + if b > 0 + q -= 1 + else + q += 1 + end + end + + q + end + + # Euclidean modulo (equivalent to the MOD macro in C) + def euclidean_mod(a, b) + r = a % b + # In Ruby, a remainder of a negative number is negative, so adjust it accordingly. + if r < 0 + if b > 0 + r += b + else + r -= b + end + end + + r + end + + def jisx0301_date_format(jd, year) + # If jd is not a Fixnum (Integer in Ruby), use ISO format + return '%Y-%m-%d' unless jd.is_a?(Integer) + + # Determine the era based on Julian Day Number + if jd < 2405160 + # Before Meiji era (before 1868-01-25) + '%Y-%m-%d' + elsif jd < 2419614 + # Meiji era (M) 1868-01-25 to 1912-07-29 + era_char = 'M' + era_start = 1867 + format_era(era_char, year, era_start) + elsif jd < 2424875 + # Taisho era (T) 1912-07-30 to 1926-12-24 + era_char = 'T' + era_start = 1911 + format_era(era_char, year, era_start) + elsif jd < 2447535 + # Showa era (S) 1926-12-25 to 1989-01-07 + era_char = 'S' + era_start = 1925 + format_era(era_char, year, era_start) + elsif jd < 2458605 + # Heisei era (H) 1989-01-08 to 2019-04-30 + era_char = 'H' + era_start = 1988 + format_era(era_char, year, era_start) + else + # Reiwa era (R) 2019-05-01 onwards + era_char = 'R' + era_start = 2018 + format_era(era_char, year, era_start) + end + end + + def format_era(era_char, year, era_start) + era_year = year - era_start + "#{era_char}%02d.%%m.%%d" % era_year + end + + def zone + of = @parsed_offset || 0 + s = of < 0 ? '-' : '+' + a = of.abs + h = a / HOUR_IN_SECONDS + m = a % HOUR_IN_SECONDS / MINUTE_IN_SECONDS + "%c%02d:%02d" % [s, h, m] + end + + # C: old_to_new — converts old ajd/of/sg format to new nth/jd/df/sf/of/sg + def old_to_new(ajd, of, sg) + # C: decode_day(ajd + half_days_in_day, &jd, &df, &sf) + d = ajd + Rational(1, 2) + + # div_day: jd = floor(d), f = d mod 1 + jd_full = d.floor + f = d - jd_full + + # div_df: df = floor(f * DAY_IN_SECONDS), remainder + df_rational = f * 86400 + df = df_rational.floor + sf_frac = df_rational - df + + # sec_to_ns: sf = round(sf_frac * SECOND_IN_NANOSECONDS) + sf = (sf_frac * 1_000_000_000).round + + # C: day_to_sec(of) then round + of_sec = (of * 86400).round.to_i + + # C: decode_jd(jd, &nth, &rjd) + nth = jd_full.div(CM_PERIOD) + rjd = (jd_full % CM_PERIOD).to_i + + # Validations (C: old_to_new) + raise Error, "invalid day fraction" if df < 0 || df >= 86400 + if of_sec < -86400 || of_sec > 86400 + of_sec = 0 + warn "invalid offset is ignored" + end + + # Convert Infinity to Float (C: NUM2DBL(sg)) + if sg.is_a?(Infinity) + sg = case sg.send(:d) + when -1 then -Float::INFINITY + when 1 then Float::INFINITY + else DEFAULT_SG + end + end + + [nth, rjd, df, sf, of_sec, sg] + end +end diff --git a/lib/date/datetime.rb b/lib/date/datetime.rb new file mode 100644 index 00000000..844447d6 --- /dev/null +++ b/lib/date/datetime.rb @@ -0,0 +1,826 @@ +# frozen_string_literal: true + +# Implementation of DateTime from ruby/date/ext/date/date_core.c +# DateTime is a subclass of Date that includes time-of-day and timezone. +class DateTime < Date + # call-seq: + # DateTime.new(year=-4712, month=1, day=1, hour=0, minute=0, second=0, offset=0, start=Date::ITALY) -> datetime + # + # Creates a new DateTime object. + def initialize(year = -4712, month = 1, day = 1, hour = 0, minute = 0, second = 0, offset = 0, start = ITALY) + y = year + m = month + d = day + h = hour + min = minute + s = second + fr2 = 0 + + # argument type checking + raise TypeError, "invalid year (not numeric)" unless y.is_a?(Numeric) + raise TypeError, "invalid month (not numeric)" unless m.is_a?(Numeric) + raise TypeError, "invalid day (not numeric)" unless d.is_a?(Numeric) + raise TypeError, "invalid hour (not numeric)" unless h.is_a?(Numeric) + raise TypeError, "invalid minute (not numeric)" unless min.is_a?(Numeric) + raise TypeError, "invalid second (not numeric)" unless s.is_a?(Numeric) + + # Handle fractional day (C: d_trunc) + d_trunc, fr = d_trunc_with_frac(d) + d = d_trunc + fr2 = fr if fr.nonzero? + + # Handle fractional hour (C: h_trunc via num2int_with_frac) + h_int = h.to_i + h_frac = h - h_int + if h_frac.nonzero? + fr2 = fr2 + Rational(h_frac) / 24 + h = h_int + end + + # Handle fractional minute (C: min_trunc) + min_int = min.to_i + min_frac = min - min_int + if min_frac.nonzero? + fr2 = fr2 + Rational(min_frac) / 1440 + min = min_int + end + + # Handle fractional second (C: s_trunc) + # C converts sub-second fraction to day fraction: fr2 = frac / DAY_IN_SECONDS + s_int = s.to_i + s_frac = s - s_int + if s_frac.nonzero? + fr2 = fr2 + Rational(s_frac) / DAY_IN_SECONDS + s = s_int + end + + # Convert offset to integer seconds (C: val2off → offset_to_sec) + rof = offset_to_sec(offset) + + sg = self.class.send(:valid_sg, start) + style = self.class.send(:guess_style, y, sg) + + # Validate time (C: c_valid_time_p) + h, min, s = validate_time(h, min, s) + + # Handle hour 24 (C: canon24oc) + if h == 24 + h = 0 + fr2 = fr2 + 1 + end + + if style < 0 + # gregorian calendar only + result = self.class.send(:valid_gregorian_p, y, m, d) + raise Error, "invalid date" unless result + + nth, ry = self.class.send(:decode_year, y, -1) + rm = result[:rm] + rd = result[:rd] + + rjd, _ = self.class.send(:c_civil_to_jd, ry, rm, rd, GREGORIAN) + rjd2 = jd_local_to_utc(rjd, time_to_df(h, min, s), rof) + + @nth = canon(nth) + @jd = rjd2 + @sg = sg + @year = ry + @month = rm + @day = rd + @has_jd = true + @has_civil = true + @hour = h + @min = min + @sec = s + @df = df_local_to_utc(time_to_df(h, min, s), rof) + @sf = 0 + @of = rof + else + # full validation + result = self.class.send(:valid_civil_p, y, m, d, sg) + raise Error, "invalid date" unless result + + nth = result[:nth] + ry = result[:ry] + rm = result[:rm] + rd = result[:rd] + rjd = result[:rjd] + + rjd2 = jd_local_to_utc(rjd, time_to_df(h, min, s), rof) + + @nth = canon(nth) + @jd = rjd2 + @sg = sg + @year = ry + @month = rm + @day = rd + @has_jd = true + @has_civil = true + @hour = h + @min = min + @sec = s + @df = df_local_to_utc(time_to_df(h, min, s), rof) + @sf = 0 + @of = rof + end + + # Add accumulated fractional parts (C: add_frac) + if fr2.nonzero? + new_date = self + fr2 + @nth = new_date.instance_variable_get(:@nth) + @jd = new_date.instance_variable_get(:@jd) + @sg = new_date.instance_variable_get(:@sg) + @year = new_date.instance_variable_get(:@year) + @month = new_date.instance_variable_get(:@month) + @day = new_date.instance_variable_get(:@day) + @has_jd = new_date.instance_variable_get(:@has_jd) + @has_civil = new_date.instance_variable_get(:@has_civil) + @hour = new_date.instance_variable_get(:@hour) + @min = new_date.instance_variable_get(:@min) + @sec = new_date.instance_variable_get(:@sec) + @df = new_date.instance_variable_get(:@df) || @df + @sf = new_date.instance_variable_get(:@sf) || @sf + @of = new_date.instance_variable_get(:@of) || @of + end + + self + end + + # --- DateTime accessors (C: d_lite_hour etc.) --- + + # call-seq: + # hour -> integer + # + # Returns the hour in range (0..23). + def hour + if simple_dat_p? + 0 + else + get_c_time + @hour || 0 + end + end + + # call-seq: + # min -> integer + # + # Returns the minute in range (0..59). + def min + if simple_dat_p? + 0 + else + get_c_time + @min || 0 + end + end + alias minute min + + # call-seq: + # sec -> integer + # + # Returns the second in range (0..59). + def sec + if simple_dat_p? + 0 + else + get_c_time + @sec || 0 + end + end + alias second sec + + # call-seq: + # sec_fraction -> rational + # + # Returns the fractional part of the second: + # + # DateTime.new(2001, 2, 3, 4, 5, 6.5).sec_fraction # => (1/2) + # + # C: m_sf_in_sec = ns_to_sec(m_sf) + def sec_fraction + ns = m_sf + ns.zero? ? Rational(0) : Rational(ns, SECOND_IN_NANOSECONDS) + end + alias second_fraction sec_fraction + + # call-seq: + # offset -> rational + # + # Returns the offset as a fraction of day: + # + # DateTime.parse('04pm+0730').offset # => (5/16) + # + # C: m_of_in_day = isec_to_day(m_of) + def offset + of = m_of + of.zero? ? Rational(0) : Rational(of, DAY_IN_SECONDS) + end + + # call-seq: + # zone -> string + # + # Returns the timezone as a string: + # + # DateTime.parse('04pm+0730').zone # => "+07:30" + # + # C: m_zone → of2str(m_of) + def zone + if simple_dat_p? + "+00:00".encode(Encoding::US_ASCII) + else + of = m_of + s = of < 0 ? '-' : '+' + a = of < 0 ? -of : of + h = a / HOUR_IN_SECONDS + m = a % HOUR_IN_SECONDS / MINUTE_IN_SECONDS + ("%c%02d:%02d" % [s, h, m]).encode(Encoding::US_ASCII) + end + end + + STRFTIME_DATETIME_DEFAULT_FMT = '%FT%T%:z'.encode(Encoding::US_ASCII) + private_constant :STRFTIME_DATETIME_DEFAULT_FMT + + # Override Date#strftime with DateTime default format + def strftime(format = STRFTIME_DATETIME_DEFAULT_FMT) + super(format) + end + + # Override Date#jisx0301 for DateTime (includes time) + def jisx0301(n = 0) + n = n.to_i + if n == 0 + jd_val = send(:m_real_local_jd) + y = send(:m_real_year) + fmt = jisx0301_date_format(jd_val, y) + 'T%T%:z' + strftime(fmt) + else + s = jisx0301(0) + # insert fractional seconds before timezone + tz = s[-6..] # "+00:00" + base = s[0...-6] + frac = sec_fraction + if frac != 0 + f = format("%.#{n}f", frac.to_f)[1..] + base += f + else + base += '.' + '0' * n + end + base + tz + end + end + + # DateTime instance method - overrides Date#iso8601 + def iso8601(n = 0) + n = n.to_i + if n == 0 + strftime('%FT%T%:z') + else + s = strftime('%FT%T') + frac = sec_fraction + if frac != 0 + f = format("%.#{n}f", frac.to_f)[1..] + s += f + else + s += '.' + '0' * n + end + s + strftime('%:z') + end + end + alias_method :xmlschema, :iso8601 + alias_method :rfc3339, :iso8601 + + # call-seq: + # deconstruct_keys(array_of_names_or_nil) -> hash + # + # Returns name/value pairs for pattern matching. + # Includes Date keys (:year, :month, :day, :wday, :yday) + # plus DateTime keys (:hour, :min, :sec, :sec_fraction, :zone). + # + # C: dt_lite_deconstruct_keys (is_datetime=true) + def deconstruct_keys(keys) + if keys.nil? + return { + year: year, + month: month, + day: day, + yday: yday, + wday: wday, + hour: hour, + min: min, + sec: sec, + sec_fraction: sec_fraction, + zone: zone + } + end + + raise TypeError, "wrong argument type #{keys.class} (expected Array or nil)" unless keys.is_a?(Array) + + h = {} + keys.each do |key| + case key + when :year then h[:year] = year + when :month then h[:month] = month + when :day then h[:day] = day + when :yday then h[:yday] = yday + when :wday then h[:wday] = wday + when :hour then h[:hour] = hour + when :min then h[:min] = min + when :sec then h[:sec] = sec + when :sec_fraction then h[:sec_fraction] = sec_fraction + when :zone then h[:zone] = zone + end + end + h + end + + # call-seq: + # to_s -> string + # + # Returns a string in ISO 8601 DateTime format: + # + # DateTime.new(2001, 2, 3, 4, 5, 6, '+7').to_s + # # => "2001-02-03T04:05:06+07:00" + def to_s + sprintf("%04d-%02d-%02dT%02d:%02d:%02d%s".encode(Encoding::US_ASCII), year, month, day, hour, min, sec, zone) + end + + # call-seq: + # new_offset(offset = 0) -> datetime + # + # Returns a new DateTime object with the same date and time, + # but with the given +offset+. + # + # C: d_lite_new_offset + def new_offset(of = 0) + if of.is_a?(String) + of = Rational(offset_to_sec(of), DAY_IN_SECONDS) + elsif of.is_a?(Integer) && of == 0 + of = Rational(0) + end + raise TypeError, "invalid offset" unless of.is_a?(Rational) || of.is_a?(Integer) || of.is_a?(Float) + of = Rational(of) unless of.is_a?(Rational) + self.class.new(year, month, day, hour, min, sec + sec_fraction, of, start) + end + + # call-seq: + # to_date -> date + # + # Returns a Date for this DateTime (time information is discarded). + # C: dt_lite_to_date → copy civil, reset time + def to_date + nth, ry = self.class.send(:decode_year, year, -1) + Date.send(:d_simple_new_internal, + nth, 0, + @sg, + ry, month, day, + 0x04) # HAVE_CIVIL + end + + # call-seq: + # to_datetime -> self + # + # Returns self. + def to_datetime + self + end + + # call-seq: + # to_time -> time + # + # Returns a Time for this DateTime. + # C: dt_lite_to_time + def to_time + # C: dt_lite_to_time — converts Julian dates to Gregorian for Time compatibility + d = julian? ? gregorian : self + Time.new(d.year, d.month, d.day, d.hour, d.min, d.sec + d.sec_fraction, d.send(:m_of)) + end + + class << self + # Same as DateTime.new + alias_method :civil, :new + + undef_method :today + + # call-seq: + # DateTime.jd(jd=0, hour=0, minute=0, second=0, offset=0, start=Date::ITALY) -> datetime + # + # Creates a new DateTime from a Julian Day Number. + # C: dt_lite_s_jd + def jd(jd = 0, hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) + # Validate jd + raise TypeError, "invalid jd (not numeric)" unless jd.is_a?(Numeric) + raise TypeError, "invalid hour (not numeric)" unless hour.is_a?(Numeric) + raise TypeError, "invalid minute (not numeric)" unless minute.is_a?(Numeric) + raise TypeError, "invalid second (not numeric)" unless second.is_a?(Numeric) + + j, fr = value_trunc(jd) + nth, rjd = decode_jd(j) + + sg = valid_sg(start) + + # Validate time + h = hour.to_i + h_frac = hour - h + min_i = minute.to_i + min_frac = minute - min_i + s_i = second.to_i + s_frac = second - s_i + + fr2 = fr + fr2 = fr2 + Rational(h_frac) / 24 if h_frac.nonzero? + fr2 = fr2 + Rational(min_frac) / 1440 if min_frac.nonzero? + fr2 = fr2 + Rational(s_frac) / 86400 if s_frac.nonzero? + + rof = _offset_to_sec(offset) + + h += 24 if h < 0 + min_i += 60 if min_i < 0 + s_i += 60 if s_i < 0 + unless (0..24).cover?(h) && (0..59).cover?(min_i) && (0..59).cover?(s_i) && + !(h == 24 && (min_i > 0 || s_i > 0)) + raise Date::Error, "invalid date" + end + if h == 24 + h = 0 + fr2 = fr2 + 1 + end + + df = h * 3600 + min_i * 60 + s_i + df_utc = df - rof + jd_utc = rjd + if df_utc < 0 + jd_utc -= 1 + df_utc += 86400 + elsif df_utc >= 86400 + jd_utc += 1 + df_utc -= 86400 + end + + obj = new_with_jd_and_time(nth, jd_utc, df_utc, 0, rof, sg) + + obj = obj + fr2 if fr2.nonzero? + + obj + end + + # call-seq: + # DateTime.ordinal(year=-4712, yday=1, hour=0, minute=0, second=0, offset=0, start=Date::ITALY) -> datetime + # + # Creates a new DateTime from an ordinal date. + # C: dt_lite_s_ordinal + def ordinal(year = -4712, yday = 1, hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) + raise TypeError, "invalid year (not numeric)" unless year.is_a?(Numeric) + raise TypeError, "invalid yday (not numeric)" unless yday.is_a?(Numeric) + raise TypeError, "invalid hour (not numeric)" unless hour.is_a?(Numeric) + raise TypeError, "invalid minute (not numeric)" unless minute.is_a?(Numeric) + raise TypeError, "invalid second (not numeric)" unless second.is_a?(Numeric) + + # Truncate fractional yday + yday_int = yday.to_i + yday_frac = yday.is_a?(Integer) ? 0 : yday - yday_int + + result = valid_ordinal_p(year, yday_int, start) + raise Date::Error, "invalid date" unless result + + nth = result[:nth] + rjd = result[:rjd] + sg = valid_sg(start) + + rof = _offset_to_sec(offset) + + h = hour.to_i + h_frac = hour - h + min_i = minute.to_i + min_frac = minute - min_i + s_i = second.to_i + s_frac = second - s_i + + fr2 = yday_frac.nonzero? ? Rational(yday_frac) : 0 + fr2 = fr2 + Rational(h_frac) / 24 if h_frac.nonzero? + fr2 = fr2 + Rational(min_frac) / 1440 if min_frac.nonzero? + fr2 = fr2 + Rational(s_frac) / 86400 if s_frac.nonzero? + + h += 24 if h < 0 + min_i += 60 if min_i < 0 + s_i += 60 if s_i < 0 + unless (0..24).cover?(h) && (0..59).cover?(min_i) && (0..59).cover?(s_i) && + !(h == 24 && (min_i > 0 || s_i > 0)) + raise Date::Error, "invalid date" + end + if h == 24 + h = 0 + fr2 = fr2 + 1 + end + + df = h * 3600 + min_i * 60 + s_i + df_utc = df - rof + jd_utc = rjd + if df_utc < 0 + jd_utc -= 1 + df_utc += 86400 + elsif df_utc >= 86400 + jd_utc += 1 + df_utc -= 86400 + end + + obj = new_with_jd_and_time(nth, jd_utc, df_utc, 0, rof, sg) + + obj = obj + fr2 if fr2.nonzero? + + obj + end + + # call-seq: + # DateTime.commercial(cwyear=-4712, cweek=1, cwday=1, hour=0, minute=0, second=0, offset=0, start=Date::ITALY) -> datetime + # + # Creates a new DateTime from a commercial date. + # C: dt_lite_s_commercial + def commercial(cwyear = -4712, cweek = 1, cwday = 1, hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) + raise TypeError, "invalid cwyear (not numeric)" unless cwyear.is_a?(Numeric) + raise TypeError, "invalid cweek (not numeric)" unless cweek.is_a?(Numeric) + raise TypeError, "invalid cwday (not numeric)" unless cwday.is_a?(Numeric) + raise TypeError, "invalid hour (not numeric)" unless hour.is_a?(Numeric) + raise TypeError, "invalid minute (not numeric)" unless minute.is_a?(Numeric) + raise TypeError, "invalid second (not numeric)" unless second.is_a?(Numeric) + + # Truncate fractional cwday + cwday_int = cwday.to_i + cwday_frac = cwday.is_a?(Integer) ? 0 : cwday - cwday_int + + result = valid_commercial_p(cwyear, cweek, cwday_int, start) + raise Date::Error, "invalid date" unless result + + nth = result[:nth] + rjd = result[:rjd] + sg = valid_sg(start) + + rof = _offset_to_sec(offset) + + h = hour.to_i + h_frac = hour - h + min_i = minute.to_i + min_frac = minute - min_i + s_i = second.to_i + s_frac = second - s_i + + fr2 = cwday_frac.nonzero? ? Rational(cwday_frac) : 0 + fr2 = fr2 + Rational(h_frac) / 24 if h_frac.nonzero? + fr2 = fr2 + Rational(min_frac) / 1440 if min_frac.nonzero? + fr2 = fr2 + Rational(s_frac) / 86400 if s_frac.nonzero? + + h += 24 if h < 0 + min_i += 60 if min_i < 0 + s_i += 60 if s_i < 0 + unless (0..24).cover?(h) && (0..59).cover?(min_i) && (0..59).cover?(s_i) && + !(h == 24 && (min_i > 0 || s_i > 0)) + raise Date::Error, "invalid date" + end + if h == 24 + h = 0 + fr2 = fr2 + 1 + end + + df = h * 3600 + min_i * 60 + s_i + df_utc = df - rof + jd_utc = rjd + if df_utc < 0 + jd_utc -= 1 + df_utc += 86400 + elsif df_utc >= 86400 + jd_utc += 1 + df_utc -= 86400 + end + + obj = new_with_jd_and_time(nth, jd_utc, df_utc, 0, rof, sg) + + obj = obj + fr2 if fr2.nonzero? + + obj + end + + # call-seq: + # DateTime.strptime(string='-4712-01-01T00:00:00+00:00', format='%FT%T%z', start=Date::ITALY) -> datetime + # + # Parses +string+ according to +format+ and creates a DateTime. + # C: dt_lite_s_strptime + def strptime(string = '-4712-01-01T00:00:00+00:00', format = '%FT%T%z', start = Date::ITALY) + hash = _strptime(string, format) + dt_new_by_frags(hash, start) + end + + # Override Date._strptime default format for DateTime + def _strptime(string, format = '%FT%T%z') + super(string, format) + end + + # call-seq: + # DateTime.now(start = Date::ITALY) -> datetime + # + # Creates a DateTime for the current time. + # + # C: datetime_s_now + def now(start = Date::ITALY) + t = Time.now + sg = valid_sg(start) + + of = t.utc_offset # integer seconds + + new( + t.year, t.mon, t.mday, + t.hour, t.min, t.sec + Rational(t.nsec, 1_000_000_000), + Rational(of, 86400), + sg + ) + end + + # call-seq: + # DateTime.parse(string, comp = true, start = Date::ITALY, limit: 128) -> datetime + # + # Parses +string+ and creates a DateTime. + # + # C: date_parse → dt_new_by_frags + def parse(string = JULIAN_EPOCH_DATETIME, comp = true, start = Date::ITALY, limit: 128) + hash = _parse(string, comp, limit: limit) + dt_new_by_frags(hash, start) + end + + # Format-specific constructors delegate to _xxx + dt_new_by_frags + + def iso8601(string = JULIAN_EPOCH_DATETIME, start = Date::ITALY, limit: 128) + hash = _iso8601(string, limit: limit) + dt_new_by_frags(hash, start) + end + + def rfc3339(string = JULIAN_EPOCH_DATETIME, start = Date::ITALY, limit: 128) + hash = _rfc3339(string, limit: limit) + dt_new_by_frags(hash, start) + end + + def xmlschema(string = JULIAN_EPOCH_DATETIME, start = Date::ITALY, limit: 128) + hash = _xmlschema(string, limit: limit) + dt_new_by_frags(hash, start) + end + + def rfc2822(string = JULIAN_EPOCH_DATETIME_RFC2822, start = Date::ITALY, limit: 128) + hash = _rfc2822(string, limit: limit) + dt_new_by_frags(hash, start) + end + alias_method :rfc822, :rfc2822 + + def httpdate(string = JULIAN_EPOCH_DATETIME_HTTPDATE, start = Date::ITALY, limit: 128) + hash = _httpdate(string, limit: limit) + dt_new_by_frags(hash, start) + end + + def jisx0301(string = JULIAN_EPOCH_DATETIME, start = Date::ITALY, limit: 128) + hash = _jisx0301(string, limit: limit) + dt_new_by_frags(hash, start) + end + + private + + JULIAN_EPOCH_DATETIME = '-4712-01-01T00:00:00+00:00' + JULIAN_EPOCH_DATETIME_RFC2822 = 'Mon, 1 Jan -4712 00:00:00 +0000' + JULIAN_EPOCH_DATETIME_HTTPDATE = 'Mon, 01 Jan -4712 00:00:00 GMT' + + # C: offset_to_sec / val2off (class method version for use in class << self) + def _offset_to_sec(of) + case of + when Integer + of + when Rational + (of * 86400).to_i + when Float + (of * 86400).to_i + when String + if of.strip.upcase == 'Z' + 0 + elsif of =~ /\A([+-])(\d{1,2}):(\d{2})\z/ + sign = $1 == '-' ? -1 : 1 + sign * ($2.to_i * 3600 + $3.to_i * 60) + elsif of =~ /\A([+-])(\d{2})(\d{2})?\z/ + sign = $1 == '-' ? -1 : 1 + sign * ($2.to_i * 3600 + ($3 ? $3.to_i * 60 : 0)) + else + 0 + end + else + 0 + end + end + + # C: dt_new_by_frags (date_core.c:8434) + # + # Structure matches C exactly: + # 1. Fast path: year+mon+mday present, no jd/yday + # - Validate civil, default time to 0, clamp sec==60 → 59 + # 2. Slow path: rt_rewrite_frags → rt_complete_frags → rt__valid_date_frags_p + # 3. Validate time (c_valid_time_p), handle sec_fraction, offset + # 4. Construct DateTime + def dt_new_by_frags(hash, sg) + raise Date::Error, "invalid date" if hash.nil? || hash.empty? + + # --- Fast path (C: lines 8447-8466) --- + if !hash.key?(:jd) && !hash.key?(:yday) && + hash[:year] && hash[:mon] && hash[:mday] + + y = hash[:year]; m = hash[:mon]; d = hash[:mday] + raise Date::Error, "invalid date" unless valid_civil?(y, m, d, sg) + + # C: default time fields, clamp sec==60 + hash[:hour] = 0 unless hash.key?(:hour) + hash[:min] = 0 unless hash.key?(:min) + if !hash.key?(:sec) + hash[:sec] = 0 + elsif hash[:sec] == 60 + hash[:sec] = 59 + end + + # --- Slow path (C: lines 8467-8470) --- + # rt_complete_frags needs DateTime as klass for time-only fill-in. + # rt__valid_date_frags_p needs Date for validation (calls ordinal/new). + else + hash = Date.send(:rt_rewrite_frags, hash) + hash = Date.send(:rt_complete_frags, self, hash) + jd_val = Date.send(:rt__valid_date_frags_p, hash, sg) + raise Date::Error, "invalid date" unless jd_val + + # Convert JD to civil for constructor + y, m, d = Date.send(:c_jd_to_civil, jd_val, sg) + end + + # --- Time validation (C: c_valid_time_p, lines 8473-8480) --- + h = hash[:hour] || 0 + min = hash[:min] || 0 + s = hash[:sec] || 0 + + # C: c_valid_time_p normalizes negative values and validates range. + rh = h < 0 ? h + 24 : h + rmin = min < 0 ? min + 60 : min + rs = s < 0 ? s + 60 : s + unless (0..24).cover?(rh) && (0..59).cover?(rmin) && (0..59).cover?(rs) && + !(rh == 24 && (rmin > 0 || rs > 0)) + raise Date::Error, "invalid date" + end + + # --- sec_fraction (C: lines 8482-8486) --- + sf = hash[:sec_fraction] + s_with_frac = sf ? rs + sf : rs + + # --- offset (C: lines 8488-8495) --- + of_sec = hash[:offset] || 0 + if of_sec.abs > 86400 + warn "invalid offset is ignored" + of_sec = 0 + end + of = Rational(of_sec, 86400) + + # --- Construct DateTime --- + new(y, m, d, rh, rmin, s_with_frac, of, sg) + end + end + + private + + # Convert offset argument to integer seconds. + # Accepts: Integer (seconds), Rational (fraction of day), String ("+HH:MM"), 0 + # C: offset_to_sec / val2off + def offset_to_sec(of) + case of + when Integer + of + when Float + # Fraction of day to seconds + (of * DAY_IN_SECONDS).to_i + when Rational + # Fraction of day to seconds + (of * DAY_IN_SECONDS).to_i + when String + if of.strip.upcase == 'Z' + 0 + elsif of =~ /\A([+-])(\d{2}):(\d{2})\z/ + sign = $1 == '-' ? -1 : 1 + sign * ($2.to_i * HOUR_IN_SECONDS + $3.to_i * MINUTE_IN_SECONDS) + elsif of =~ /\A([+-])(\d{2})(\d{2})?\z/ + sign = $1 == '-' ? -1 : 1 + sign * ($2.to_i * HOUR_IN_SECONDS + ($3 ? $3.to_i * MINUTE_IN_SECONDS : 0)) + else + 0 + end + else + 0 + end + end + + # Validate time fields (C: c_valid_time_p) + def validate_time(h, min, s) + h += 24 if h < 0 + min += 60 if min < 0 + s += 60 if s < 0 + unless (0..24).cover?(h) && (0..59).cover?(min) && (0..59).cover?(s) && + !(h == 24 && (min > 0 || s > 0)) + raise Error, "invalid date" + end + [h, min, s] + end +end diff --git a/lib/date/parse.rb b/lib/date/parse.rb new file mode 100644 index 00000000..095a522f --- /dev/null +++ b/lib/date/parse.rb @@ -0,0 +1,2607 @@ +# frozen_string_literal: true + +require_relative "patterns" +require_relative "zonetab" + +# Implementation of ruby/date/ext/date/date_parse.c +class Date + class << self + # call-seq: + # Date.parse(string = '-4712-01-01', comp = true, start = Date::ITALY, limit: 128) -> date + # + # Returns a new \Date object with values parsed from +string+. + # + # If +comp+ is +true+ and the given year is in the range (0..99), + # the current century is supplied; otherwise, the year is taken as given. + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # See argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date._parse (returns a hash). + def parse(string = JULIAN_EPOCH_DATE, comp = true, start = DEFAULT_SG, limit: 128) + hash = _parse(string, comp, limit: limit) + new_by_frags(hash, start) + end + + # call-seq: + # Date._parse(string, comp = true, limit: 128) -> hash + # + # Returns a hash of values parsed from +string+. + # + # If +comp+ is +true+ and the given year is in the range (0..99), + # the current century is supplied; otherwise, the year is taken as given. + # + # See argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date.parse (returns a \Date object). + def _parse(string, comp = true, limit: 128) + string = string_value(string) + str = string.strip + + # Check limit + if limit && str.length > limit + raise ArgumentError, "string length (#{str.length}) exceeds the limit #{limit}" + end + + date__parse(str, comp) + end + + # call-seq: + # Date._iso8601(string, limit: 128) -> hash + # + # Returns a hash of values parsed from +string+, which should contain + # an {ISO 8601 formatted date}[rdoc-ref:language/strftime_formatting.rdoc@ISO+8601+Format+Specifications]: + # + # d = Date.new(2001, 2, 3) + # s = d.iso8601 # => "2001-02-03" + # Date._iso8601(s) # => {:mday=>3, :year=>2001, :mon=>2} + # + # See argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date.iso8601 (returns a \Date object). + def _iso8601(string, limit: 128) + return {} if string.nil? + string = string_value(string) + check_string_limit(string, limit) + + date__iso8601(string) + end + + # date__rfc3339 in date_parse.c + def _rfc3339(string, limit: 128) + return {} if string.nil? + string = string_value(string) + check_string_limit(string, limit) + + date__rfc3339(string) + end + + # date__xmlschema in date_parse.c + def _xmlschema(string, limit: 128) + return {} if string.nil? + string = string_value(string) + check_string_limit(string, limit) + + date__xmlschema(string) + end + + # date__rfc2822 in date_parse.c + def _rfc2822(string, limit: 128) + return {} if string.nil? + string = string_value(string) + check_string_limit(string, limit) + + date__rfc2822(string) + end + alias _rfc822 _rfc2822 + + # call-seq: + # Date._httpdate(string, limit: 128) -> hash + # + # Returns a hash of values parsed from +string+, which should be a valid + # {HTTP date format}[rdoc-ref:language/strftime_formatting.rdoc@HTTP+Format]: + # + # d = Date.new(2001, 2, 3) + # s = d.httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT" + # Date._httpdate(s) + # # => {:wday=>6, :mday=>3, :mon=>2, :year=>2001, :hour=>0, :min=>0, :sec=>0, :zone=>"GMT", :offset=>0} + # + # Related: Date.httpdate (returns a \Date object). + def _httpdate(string, limit: 128) + return {} if string.nil? + string = string_value(string) + check_string_limit(string, limit) + + date__httpdate(string) + end + + # call-seq: + # Date._jisx0301(string, limit: 128) -> hash + # + # Returns a hash of values parsed from +string+, which should be a valid + # {JIS X 0301 date format}[rdoc-ref:language/strftime_formatting.rdoc@JIS+X+0301+Format]: + # + # d = Date.new(2001, 2, 3) + # s = d.jisx0301 # => "H13.02.03" + # Date._jisx0301(s) # => {:year=>2001, :mon=>2, :mday=>3} + # + # See argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date.jisx0301 (returns a \Date object). + def _jisx0301(string, limit: 128) + return {} if string.nil? + string = string_value(string) + check_string_limit(string, limit) + + date__jisx0301(string) + end + + # --- Constructor methods --- + + def iso8601(string = JULIAN_EPOCH_DATE, start = DEFAULT_SG, limit: 128) + hash = _iso8601(string, limit: limit) + + new_by_frags(hash, start) + end + + def rfc3339(string = JULIAN_EPOCH_DATETIME, start = DEFAULT_SG, limit: 128) + hash = _rfc3339(string, limit: limit) + + new_by_frags(hash, start) + end + + def xmlschema(string = JULIAN_EPOCH_DATE, start = DEFAULT_SG, limit: 128) + hash = _xmlschema(string, limit: limit) + + new_by_frags(hash, start) + end + + def rfc2822(string = JULIAN_EPOCH_DATETIME_RFC2822, start = DEFAULT_SG, limit: 128) + hash = _rfc2822(string, limit: limit) + + new_by_frags(hash, start) + end + alias rfc822 rfc2822 + + def httpdate(string = JULIAN_EPOCH_DATETIME_HTTPDATE, start = DEFAULT_SG, limit: 128) + hash = _httpdate(string, limit: limit) + + new_by_frags(hash, start) + end + + def jisx0301(string = JULIAN_EPOCH_DATE, start = DEFAULT_SG, limit: 128) + hash = _jisx0301(string, limit: limit) + + new_by_frags(hash, start) + end + + private + + def date__parse(str, comp) + hash = {} + + # Preprocessing: duplicate and replace non-allowed characters. + # Non-TIGHT: Replace [^-+',./:@[:alnum:]\[\]]+ with a single space + str = str.dup.gsub(%r{[^-+',./:@[:alnum:]\[\]]+}, ' ') + + hash[:_comp] = comp + + # Parser invocation (non-TIGHT order) + # Note: C's HAVE_ELEM_P calls check_class(str) every time because + # str is modified by subx after each successful parse. + + # parse_day and parse_time always run (no goto ok). + if have_elem_p?(str, HAVE_ALPHA) + parse_day(str, hash) + end + + if have_elem_p?(str, HAVE_DIGIT) + parse_time(str, hash) + end + + # Date parsers: first success skips the rest (C's "goto ok"). + # In C, all paths converge at ok: for post-processing. + catch(:date_parsed) do + if have_elem_p?(str, HAVE_ALPHA | HAVE_DIGIT) + throw :date_parsed if parse_eu(str, hash) + throw :date_parsed if parse_us(str, hash) + end + + if have_elem_p?(str, HAVE_DIGIT | HAVE_DASH) + throw :date_parsed if parse_iso(str, hash) + end + + if have_elem_p?(str, HAVE_DIGIT | HAVE_DOT) + throw :date_parsed if parse_jis(str, hash) + end + + if have_elem_p?(str, HAVE_ALPHA | HAVE_DIGIT | HAVE_DASH) + throw :date_parsed if parse_vms(str, hash) + end + + if have_elem_p?(str, HAVE_DIGIT | HAVE_SLASH) + throw :date_parsed if parse_sla(str, hash) + end + + if have_elem_p?(str, HAVE_DIGIT | HAVE_DOT) + throw :date_parsed if parse_dot(str, hash) + end + + if have_elem_p?(str, HAVE_DIGIT) + throw :date_parsed if parse_iso2(str, hash) + end + + if have_elem_p?(str, HAVE_DIGIT) + throw :date_parsed if parse_year(str, hash) + end + + if have_elem_p?(str, HAVE_ALPHA) + throw :date_parsed if parse_mon(str, hash) + end + + if have_elem_p?(str, HAVE_DIGIT) + throw :date_parsed if parse_mday(str, hash) + end + + if have_elem_p?(str, HAVE_DIGIT) + throw :date_parsed if parse_ddd(str, hash) + end + end + + # ok: (post-processing — always runs, matching C's ok: label) + if have_elem_p?(str, HAVE_ALPHA) + parse_bc(str, hash) + end + if have_elem_p?(str, HAVE_DIGIT) + parse_frag(str, hash) + end + + apply_comp(hash) + hash + end + + # asctime format with timezone: Sat Aug 28 02:29:34 JST 1999 + def parse_asctime_with_zone(str, hash) + return false unless str =~ /\b(sun|mon|tue|wed|thu|fri|sat)[[:space:]]+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[[:space:]]+(\d{1,2})[[:space:]]+(\d{2}):(\d{2}):(\d{2})[[:space:]]+(.*?)[[:space:]]+(-?\d+)[[:space:]]*$/i + + wday_str = $1 + mon_str = $2 + mday_str = $3 + hour_str = $4 + min_str = $5 + sec_str = $6 + zone_part = $7 + year_str = $8 + + hash[:wday] = day_num(wday_str) + hash[:mon] = mon_num(mon_str) + hash[:mday] = mday_str.to_i + hash[:hour] = hour_str.to_i + hash[:min] = min_str.to_i + hash[:sec] = sec_str.to_i + + zone_part = zone_part.strip + unless zone_part.empty? + zone = zone_part.gsub(/\s+/, ' ') + hash[:zone] = zone + hash[:offset] = parse_zone_offset(zone) + end + + hash[:_year_str] = year_str + hash[:year] = year_str.to_i + apply_comp(hash) + + true + end + + # asctime format without timezone: Sat Aug 28 02:55:50 1999 + def parse_asctime(str, hash) + return false unless str =~ /\b(sun|mon|tue|wed|thu|fri|sat)\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(-?\d+)\s*$/i + + wday_str = $1 + mon_str = $2 + mday_str = $3 + hour_str = $4 + min_str = $5 + sec_str = $6 + year_str = $7 + + hash[:wday] = day_num(wday_str) + hash[:mon] = mon_num(mon_str) + hash[:mday] = mday_str.to_i + hash[:hour] = hour_str.to_i + hash[:min] = min_str.to_i + hash[:sec] = sec_str.to_i + hash[:_year_str] = year_str + hash[:year] = year_str.to_i + apply_comp(hash) + + true + end + + # HTTP date type 1: "Sat, 03 Feb 2001 00:00:00 GMT" + def httpdate_type1(str, hash) + pattern = /\A\s*(#{ABBR_DAYS_PATTERN})\s*,\s+ + (\d{2})\s+ + (#{ABBR_MONTHS_PATTERN})\s+ + (-?\d{4})\s+ + (\d{2}):(\d{2}):(\d{2})\s+ + (gmt)\s*\z/ix + + match = pattern.match(str) + return false unless match + + hash[:wday] = day_num(match[1]) + hash[:mday] = match[2].to_i + hash[:mon] = mon_num(match[3]) + hash[:year] = match[4].to_i + hash[:hour] = match[5].to_i + hash[:min] = match[6].to_i + hash[:sec] = match[7].to_i + hash[:zone] = match[8] + hash[:offset] = 0 + + true + end + + # HTTP date type 2: "Saturday, 03-Feb-01 00:00:00 GMT" + def httpdate_type2(str, hash) + pattern = /\A\s*(#{DAYS_PATTERN})\s*,\s+ + (\d{2})\s*-\s* + (#{ABBR_MONTHS_PATTERN})\s*-\s* + (\d{2})\s+ + (\d{2}):(\d{2}):(\d{2})\s+ + (gmt)\s*\z/ix + + match = pattern.match(str) + return false unless match + + hash[:wday] = day_num(match[1]) + hash[:mday] = match[2].to_i + hash[:mon] = mon_num(match[3]) + + # Year completion for 2-digit year + year = match[4].to_i + year = comp_year69(year) if year >= 0 && year <= 99 + hash[:year] = year + + hash[:hour] = match[5].to_i + hash[:min] = match[6].to_i + hash[:sec] = match[7].to_i + hash[:zone] = match[8] + hash[:offset] = 0 + + true + end + + # HTTP date type 3: "Sat Feb 3 00:00:00 2001" + def httpdate_type3(str, hash) + pattern = /\A\s*(#{ABBR_DAYS_PATTERN})\s+ + (#{ABBR_MONTHS_PATTERN})\s+ + (\d{1,2})\s+ + (\d{2}):(\d{2}):(\d{2})\s+ + (\d{4})\s*\z/ix + + match = pattern.match(str) + return false unless match + + hash[:wday] = day_num(match[1]) + hash[:mon] = mon_num(match[2]) + hash[:mday] = match[3].to_i + hash[:hour] = match[4].to_i + hash[:min] = match[5].to_i + hash[:sec] = match[6].to_i + hash[:year] = match[7].to_i + + true + end + + # parse_day in date_parse.c. + # Non-TIGHT pattern: \b(sun|mon|tue|wed|thu|fri|sat)[^-/\d\s]* + # The [^-/\d\s]* part consumes trailing characters (e.g., "urday" + # in "Saturday") so they get replaced by subx, but only the + # abbreviation in $1 is used. + def parse_day(str, hash) + m = subx(str, PARSE_DAY_PAT) + return false unless m + + hash[:wday] = day_num(m[1]) + + true + end + + # parse_time in date_parse.c. + # Uses subx to replace the matched time portion with " " so + # subsequent parsers (parse_us, etc.) won't re-match it. + def parse_time(str, hash) + m = subx(str, TIME_PAT) + return false unless m + + time_str = m[1] + zone_str = m[2] + + parse_time_detail(time_str, hash) + + if zone_str && !zone_str.empty? + hash[:zone] = zone_str + hash[:offset] = date_zone_to_diff(zone_str) + end + + true + end + + # parse_ddd in date_parse.c. + def parse_ddd(str, hash) + m = subx(str, PARSE_DDD_PAT) + return false unless m + + sign = m[1] + digits = m[2] + time_digits = m[3] + fraction = m[4] + zone = m[5] + + l = digits.length + + # Branches based on the length of the main number string. + case l + when 2 + if time_digits.nil? && !fraction.nil? + hash[:sec] = digits[-2, 2].to_i + else + hash[:mday] = digits[0, 2].to_i + end + when 4 + if time_digits.nil? && !fraction.nil? + hash[:sec] = digits[-2, 2].to_i + hash[:min] = digits[-4, 2].to_i + else + hash[:mon] = digits[0, 2].to_i + hash[:mday] = digits[2, 2].to_i + end + when 6 + if time_digits.nil? && !fraction.nil? + hash[:sec] = digits[-2, 2].to_i + hash[:min] = digits[-4, 2].to_i + hash[:hour] = digits[-6, 2].to_i + else + y = digits[0, 2].to_i + y = -y if sign == '-' + hash[:year] = y + hash[:mon] = digits[2, 2].to_i + hash[:mday] = digits[4, 2].to_i + hash[:_year_str] = digits[0, 2] # year completion + end + when 8, 10, 12, 14 + if time_digits.nil? && !fraction.nil? + # Interpreted as time + hash[:sec] = digits[-2, 2].to_i + hash[:min] = digits[-4, 2].to_i + hash[:hour] = digits[-6, 2].to_i + hash[:mday] = digits[-8, 2].to_i + hash[:mon] = digits[-10, 2].to_i if l >= 10 + if l == 12 + y = digits[-12, 2].to_i + y = -y if sign == '-' + hash[:year] = y + hash[:_year_str] = digits[-12, 2] + elsif l == 14 + y = digits[-14, 4].to_i + y = -y if sign == '-' + hash[:year] = y + hash[:_comp] = false + end + else + # Interpret as date + y = digits[0, 4].to_i + y = -y if sign == '-' + hash[:year] = y + hash[:mon] = digits[4, 2].to_i + hash[:mday] = digits[6, 2].to_i + hash[:hour] = digits[8, 2].to_i if l >= 10 + hash[:min] = digits[10, 2].to_i if l >= 12 + hash[:sec] = digits[12, 2].to_i if l >= 14 + hash[:_comp] = false + end + when 3 + if time_digits.nil? && !fraction.nil? + hash[:sec] = digits[-2, 2].to_i + hash[:min] = digits[-3, 1].to_i + else + hash[:yday] = digits[0, 3].to_i + end + when 5 + if time_digits.nil? && !fraction.nil? + hash[:sec] = digits[-2, 2].to_i + hash[:min] = digits[-4, 2].to_i + hash[:hour] = digits[-5, 1].to_i + else + y = digits[0, 2].to_i + y = -y if sign == '-' + hash[:year] = y + hash[:yday] = digits[2, 3].to_i + hash[:_year_str] = digits[0, 2] + end + when 7 + if time_digits.nil? && !fraction.nil? + hash[:sec] = digits[-2, 2].to_i + hash[:min] = digits[-4, 2].to_i + hash[:hour] = digits[-6, 2].to_i + hash[:mday] = digits[-7, 1].to_i + else + y = digits[0, 4].to_i + y = -y if sign == '-' + hash[:year] = y + hash[:yday] = digits[4, 3].to_i + # No need to complete because it is a 4-digit year + end + end + + # Processing time portion + if time_digits && !time_digits.empty? + tl = time_digits.length + if !fraction.nil? + # Interpreted as time + case tl + when 2, 4, 6 + hash[:sec] = time_digits[-2, 2].to_i + hash[:min] = time_digits[-4, 2].to_i if tl >= 4 + hash[:hour] = time_digits[-6, 2].to_i if tl >= 6 + end + else + # Interpreted as time + case tl + when 2, 4, 6 + hash[:hour] = time_digits[0, 2].to_i + hash[:min] = time_digits[2, 2].to_i if tl >= 4 + hash[:sec] = time_digits[4, 2].to_i if tl >= 6 + end + end + end + + # Handling fractional seconds + if fraction && !fraction.empty? + hash[:sec_fraction] = Rational(fraction.to_i, 10 ** fraction.length) + end + + # Handling time zone + if zone && !zone.empty? + if zone[0] == '[' + # Bracket-enclosed zone: C's parse_ddd_cb special handling. + # Strip '[' and ']', then check for ':' separator. + inner = zone[1..-2] # content between [ and ] + colon_pos = inner.index(':') + if colon_pos + # e.g., "[-5:EST]" → zone_name="EST", offset_str="-5:" + # C: zone = part after ':', s5 = part from start to after ':' + zone_name = inner[(colon_pos + 1)..] + offset_str = inner[0, colon_pos + 1] # includes ':' + else + # e.g., "[-9]" → zone_name="-9", offset_str="-9" + # e.g., "[9]" → zone_name="9", offset_str="+9" (digit→prepend '+') + zone_name = inner + if inner[0] && inner[0] =~ /\d/ + offset_str = "+" + zone_name + else + offset_str = zone_name + end + end + hash[:zone] = zone_name + hash[:offset] = date_zone_to_diff(offset_str) + else + # Non-bracket zone: just set zone. + # Offset will be resolved in apply_comp if not already set. + hash[:zone] = zone + hash[:offset] = date_zone_to_diff(zone) + end + end + + true + end + + # Parse $1 (time string) further and set hash to hour/min/sec/sec_fraction. + # + # Internal pattern: + # $1 hour + # $2 min (colon format) + # $3 sec (colon format) + # $4 frac ([,.]\d*) + # $5 min (h format) + # $6 sec (h format) + # $7 am/pm (a or p) + def parse_time_detail(time_str, hash) + return unless time_str =~ TIME_DETAIL_PAT + + hour = $1.to_i + min_colon = $2 + sec_colon = $3 + frac = $4 # "[,.] number string" or nil + min_h = $5 + sec_h = $6 + ampm = $7 + + if min_colon + # Branch A: HH:MM[:SS[.frac]] + hash[:hour] = hour + hash[:min] = min_colon.to_i + if sec_colon + hash[:sec] = sec_colon.to_i + if frac && frac.length > 1 + # Since frac is a "[,.] number string", the first character (delimiter) is omitted. + frac_digits = frac[1..] + hash[:sec_fraction] = Rational(frac_digits.to_i, 10 ** frac_digits.length) + end + end + elsif min_h + # Branch B: HHh[MMm[SSs]](with min) + hash[:hour] = hour + hash[:min] = min_h.to_i + hash[:sec] = sec_h.to_i if sec_h + elsif time_str.match?(/h/i) + # Branch B: Only HHh (no min/sec) + hash[:hour] = hour + elsif ampm + # Branch C: Only AM/PM => Set only hour (converted to AM/PM below) + hash[:hour] = hour + end + + # AM/PM conversion + if ampm + h = hash[:hour] || hour + if ampm.downcase == 'p' && h != 12 + hash[:hour] = h + 12 + elsif ampm.downcase == 'a' && h == 12 + hash[:hour] = 0 + end + end + end + + # parse_era in date_parse.c. + def parse_era(str, hash) + if str =~ ERA1_PAT + hash[:bc] = false + return true + end + + if str =~ ERA2_PAT + hash[:bc] = $1.downcase.delete('.') != 'ce' + return true + end + + false + end + + # parse_eu in date_parse.c. + def parse_eu(str, hash) + m = subx(str, PARSE_EU_PAT) + return false unless m + + mday_str = m[1] + mon_str = m[2] + era_str = m[3] + year_str = m[4] + + # Determine bc flag from era. + # AD/A.D./CE/C.E. => false, BC/B.C./BCE/B.C.E. => true + bc = if era_str + era_str.downcase.delete('.') !~ /\A(ad|ce)\z/ + else + false + end + + # Normalize y/m/d and set to hash in s3e. + # 'mon' is converted to an Integer using 'mon_num' and then passed. + s3e(hash, year_str, mon_num(mon_str), mday_str, bc) + + true + end + + # parse_us in date_parse.c. + def parse_us(str, hash) + m = subx(str, PARSE_US_PAT) + return false unless m + + mon_str = m[1] + mday_str = m[2] + era_str = m[3] + year_str = m[4] + + # Determine bc flag from era (same logic as parse_eu). + bc = if era_str + era_str.downcase.delete('.') !~ /\A(ad|ce)\z/ + else + false + end + + # Normalize y/m/d and set to hash using s3e. + # Difference from parse_eu: mon=$1, mday=$2 (only the $ numbers are swapped). + s3e(hash, year_str, mon_num(mon_str), mday_str, bc) + + true + end + + # parse_iso in date_parse.c + def parse_iso(str, hash) + m = subx(str, PARSE_ISO_PAT) + return false unless m + + # Normalize y/m/d and set to hash in s3e. + # bc is always false (there is no era symbol in ISO format). + s3e(hash, m[1], m[2], m[3], false) + + true + end + + # parse_iso2 in date_parse.c + def parse_iso2(str, hash) + return true if parse_iso21(str, hash) + return true if parse_iso22(str, hash) + return true if parse_iso23(str, hash) + return true if parse_iso24(str, hash) + return true if parse_iso25(str, hash) + return true if parse_iso26(str, hash) + + false + end + + def parse_iso21(str, hash) + m = subx(str, PARSE_ISO21_PAT) + return false unless m + + hash[:cwyear] = m[1].to_i if m[1] + hash[:cweek] = m[2].to_i + hash[:cwday] = m[3].to_i if m[3] + + true + end + + def parse_iso22(str, hash) + m = subx(str, PARSE_ISO22_PAT) + return false unless m + + hash[:cwday] = m[1].to_i + + true + end + + def parse_iso23(str, hash) + m = subx(str, PARSE_ISO23_PAT) + return false unless m + + hash[:mon] = m[1].to_i if m[1] + hash[:mday] = m[2].to_i + + true + end + + def parse_iso24(str, hash) + m = subx(str, PARSE_ISO24_PAT) + return false unless m + + hash[:mon] = m[1].to_i + hash[:mday] = m[2].to_i if m[2] + + true + end + + def parse_iso25(str, hash) + # Skip if exclude pattern matches (uses match, not subx). + return false if str =~ PARSE_ISO25_PAT0 + + m = subx(str, PARSE_ISO25_PAT) + return false unless m + + hash[:year] = m[1].to_i + hash[:yday] = m[2].to_i + + true + end + + def parse_iso26(str, hash) + # Skip if exclude pattern matches (uses match, not subx). + return false if str =~ PARSE_ISO26_PAT0 + + m = subx(str, PARSE_ISO26_PAT) + return false unless m + + hash[:yday] = m[1].to_i + + true + end + + # parse_jis in date_parse.c + def parse_jis(str, hash) + m = subx(str, PARSE_JIS_PAT) + return false unless m + + era = m[1].upcase + year = m[2].to_i + mon = m[3].to_i + mday = m[4].to_i + + # Convert the era symbol and year number to Gregorian calendar + # and set it to hash. + hash[:year] = gengo(era) + year + hash[:mon] = mon + hash[:mday] = mday + + true + end + + # parse_vms in date_parse.c + def parse_vms(str, hash) + return true if parse_vms11(str, hash) + return true if parse_vms12(str, hash) + + false + end + + def parse_vms11(str, hash) + m = subx(str, PARSE_VMS11_PAT) + return false unless m + + mday_str = m[1] + mon_str = m[2] + year_str = m[3] + + # Normalize y/m/d and set to hash in s3e. + s3e(hash, year_str, mon_num(mon_str), mday_str, false) + + true + end + + def parse_vms12(str, hash) + m = subx(str, PARSE_VMS12_PAT) + return false unless m + + mon_str = m[1] + mday_str = m[2] + year_str = m[3] + + # Normalize y/m/d and set to hash in s3e. + s3e(hash, year_str, mon_num(mon_str), mday_str, false) + + true + end + + # parse_sla in date_parse.c + def parse_sla(str, hash) + m = subx(str, PARSE_SLA_PAT) + return false unless m + + # Normalize y/m/d and set to hash in s3e. + # bc is always false. + s3e(hash, m[1], m[2], m[3], false) + + true + end + + # parse_dot in date_parse.c + def parse_dot(str, hash) + m = subx(str, PARSE_DOT_PAT) + return false unless m + + # Normalize y/m/d and set to hash in s3e. + # bc is always false. + s3e(hash, m[1], m[2], m[3], false) + + true + end + + # parse_year in date_parse.c + def parse_year(str, hash) + m = subx(str, PARSE_YEAR_PAT) + return false unless m + + hash[:year] = m[1].to_i + + true + end + + # parse_mon in date_parse.c + def parse_mon(str, hash) + m = subx(str, PARSE_MON_PAT) + return false unless m + + hash[:mon] = mon_num(m[1]) + + true + end + + # parse_mday in date_parse.c + def parse_mday(str, hash) + m = subx(str, PARSE_MDAY_PAT) + return false unless m + + hash[:mday] = m[1].to_i + + true + end + + # parse_bc in date_parse.c (non-TIGHT post-processing). + # Matches standalone BC/BCE/B.C./B.C.E. and sets _bc flag. + def parse_bc(str, hash) + m = subx(str, PARSE_BC_PAT) + return false unless m + + hash[:_bc] = true + + true + end + + # parse_frag in date_parse.c (non-TIGHT post-processing). + # If the remaining string (after all other parsers have consumed + # their portions) is a standalone 1-2 digit number: + # - If we have hour but no mday, and the number is 1-31, set mday + # - If we have mday but no hour, and the number is 0-24, set hour + def parse_frag(str, hash) + m = subx(str, PARSE_FRAG_PAT) + return false unless m + + n = m[1].to_i + + if hash.key?(:hour) && !hash.key?(:mday) + hash[:mday] = n if n >= 1 && n <= 31 + end + if hash.key?(:mday) && !hash.key?(:hour) + hash[:hour] = n if n >= 0 && n <= 24 + end + + true + end + + # Helper: Convert day name to number (0=Sunday, 6=Saturday) + def day_num(day_name) + abbr_days = %w[sun mon tue wed thu fri sat] + abbr_days.index(day_name[0, 3].downcase) || 0 + end + + # Helper: Convert month name to number (1=January, 12=December) + def mon_num(month_name) + abbr_months = %w[jan feb mar apr may jun jul aug sep oct nov dec] + (abbr_months.index(month_name[0, 3].downcase) || 0) + 1 + end + + # ISO 8601 extended datetime: 2001-02-03T04:05:06+09:00 + def iso8601_ext_datetime(str, hash) + pattern = /\A\s* + (?: + ([-+]?\d{2,}|-)-(\d{2})?(?:-(\d{2}))?| # YYYY-MM-DD or --MM-DD + ([-+]?\d{2,})?-(\d{3})| # YYYY-DDD + (\d{4}|\d{2})?-w(\d{2})-(\d)| # YYYY-Www-D + -w-(\d) # -W-D + ) + (?:t + (\d{2}):(\d{2})(?::(\d{2})(?:[,.](\d+))?)? # HH:MM:SS.fraction + (z|[-+]\d{2}(?::?\d{2})?)? # timezone + )? + \s*\z/ix + + match = pattern.match(str) + return false unless match + + # Calendar date (YYYY-MM-DD) + if match[1] + unless match[1] == '-' + year = match[1].to_i + # Complete 2-digit year + year = comp_year69(year) if match[1].length < 4 + hash[:year] = year + end + hash[:mon] = match[2].to_i if match[2] + hash[:mday] = match[3].to_i if match[3] + # Ordinal date (YYYY-DDD) + elsif match[5] + if match[4] + year = match[4].to_i + year = comp_year69(year) if match[4].length < 4 + hash[:year] = year + end + hash[:yday] = match[5].to_i + # Week date (YYYY-Www-D) + elsif match[8] + if match[6] + year = match[6].to_i + year = comp_year69(year) if match[6].length < 4 + hash[:cwyear] = year + end + hash[:cweek] = match[7].to_i + hash[:cwday] = match[8].to_i + # Week day only (-W-D) + elsif match[9] + hash[:cwday] = match[9].to_i + end + + # Time + if match[10] + hash[:hour] = match[10].to_i + hash[:min] = match[11].to_i + hash[:sec] = match[12].to_i if match[12] + hash[:sec_fraction] = parse_fraction(match[13]) if match[13] + end + + # Timezone + if match[14] + hash[:zone] = match[14] + hash[:offset] = parse_zone_offset(match[14]) + end + + true + end + + # ISO 8601 basic datetime: 20010203T040506 + def iso8601_bas_datetime(str, hash) + # Try full basic datetime: YYYYMMDD or YYMMDD + pattern = /\A\s* + ([-+]?(?:\d{4}|\d{2})|--) # Year (YYYY, YY, --, or signed) + (\d{2}|-) # Month (MM or -) + (\d{2}) # Day (DD) + (?:t? + (\d{2})(\d{2}) # Hour and minute (HHMM) + (?:(\d{2}) # Second (SS) + (?:[,.](\d+))? # Fraction + )? + (z|[-+]\d{2}(?:\d{2})?)? # Timezone + )? + \s*\z/ix + + match = pattern.match(str) + if match + # Calendar date + unless match[1] == '--' + year = match[1].to_i + year = comp_year69(year) if match[1].length == 2 && match[1] !~ /^[-+]/ + hash[:year] = year + end + hash[:mon] = match[2].to_i unless match[2] == '-' + hash[:mday] = match[3].to_i + + # Time + if match[4] + hash[:hour] = match[4].to_i + hash[:min] = match[5].to_i + hash[:sec] = match[6].to_i if match[6] + hash[:sec_fraction] = parse_fraction(match[7]) if match[7] + end + + # Timezone + if match[8] + hash[:zone] = match[8] + hash[:offset] = parse_zone_offset(match[8]) + end + + return true + end + + # Try ordinal date: YYYYDDD or YYDDD + pattern = /\A\s* + ([-+]?(?:\d{4}|\d{2})) # Year + (\d{3}) # Day of year + (?:t? + (\d{2})(\d{2}) # Hour and minute + (?:(\d{2}) # Second + (?:[,.](\d+))? # Fraction + )? + (z|[-+]\d{2}(?:\d{2})?)? # Timezone + )? + \s*\z/ix + + match = pattern.match(str) + if match + year = match[1].to_i + year = comp_year69(year) if match[1].length == 2 && match[1] !~ /^[-+]/ + hash[:year] = year + hash[:yday] = match[2].to_i + + # Time + if match[3] + hash[:hour] = match[3].to_i + hash[:min] = match[4].to_i + hash[:sec] = match[5].to_i if match[5] + hash[:sec_fraction] = parse_fraction(match[6]) if match[6] + end + + # Timezone + if match[7] + hash[:zone] = match[7] + hash[:offset] = parse_zone_offset(match[7]) + end + + return true + end + + # Try -DDD (ordinal without year) + pattern = /\A\s* + -(\d{3}) # Day of year + (?:t? + (\d{2})(\d{2}) # Hour and minute + (?:(\d{2}) # Second + (?:[,.](\d+))? # Fraction + )? + (z|[-+]\d{2}(?:\d{2})?)? # Timezone + )? + \s*\z/ix + + match = pattern.match(str) + if match + hash[:yday] = match[1].to_i + + # Time + if match[2] + hash[:hour] = match[2].to_i + hash[:min] = match[3].to_i + hash[:sec] = match[4].to_i if match[4] + hash[:sec_fraction] = parse_fraction(match[5]) if match[5] + end + + # Timezone + if match[6] + hash[:zone] = match[6] + hash[:offset] = parse_zone_offset(match[6]) + end + + return true + end + + # Try week date: YYYYWwwD or YYWwwD + pattern = /\A\s* + (\d{4}|\d{2}) # Year + w(\d{2}) # Week + (\d) # Day of week + (?:t? + (\d{2})(\d{2}) # Hour and minute + (?:(\d{2}) # Second + (?:[,.](\d+))? # Fraction + )? + (z|[-+]\d{2}(?:\d{2})?)? # Timezone + )? + \s*\z/ix + + match = pattern.match(str) + if match + year = match[1].to_i + year = comp_year69(year) if match[1].length == 2 + hash[:cwyear] = year + hash[:cweek] = match[2].to_i + hash[:cwday] = match[3].to_i + + # Time + if match[4] + hash[:hour] = match[4].to_i + hash[:min] = match[5].to_i + hash[:sec] = match[6].to_i if match[6] + hash[:sec_fraction] = parse_fraction(match[7]) if match[7] + end + + # Timezone + if match[8] + hash[:zone] = match[8] + hash[:offset] = parse_zone_offset(match[8]) + end + + return true + end + + # Try -WwwD (week date without year) + pattern = /\A\s* + -w(\d{2}) # Week + (\d) # Day of week + (?:t? + (\d{2})(\d{2}) # Hour and minute + (?:(\d{2}) # Second + (?:[,.](\d+))? # Fraction + )? + (z|[-+]\d{2}(?:\d{2})?)? # Timezone + )? + \s*\z/ix + + match = pattern.match(str) + if match + hash[:cweek] = match[1].to_i + hash[:cwday] = match[2].to_i + + # Time + if match[3] + hash[:hour] = match[3].to_i + hash[:min] = match[4].to_i + hash[:sec] = match[5].to_i if match[5] + hash[:sec_fraction] = parse_fraction(match[6]) if match[6] + end + + # Timezone + if match[7] + hash[:zone] = match[7] + hash[:offset] = parse_zone_offset(match[7]) + end + + return true + end + + # Try -W-D (day of week only) + pattern = /\A\s* + -w-(\d) # Day of week + (?:t? + (\d{2})(\d{2}) # Hour and minute + (?:(\d{2}) # Second + (?:[,.](\d+))? # Fraction + )? + (z|[-+]\d{2}(?:\d{2})?)? # Timezone + )? + \s*\z/ix + + match = pattern.match(str) + if match + hash[:cwday] = match[1].to_i + + # Time + if match[2] + hash[:hour] = match[2].to_i + hash[:min] = match[3].to_i + hash[:sec] = match[4].to_i if match[4] + hash[:sec_fraction] = parse_fraction(match[5]) if match[5] + end + + # Timezone + if match[6] + hash[:zone] = match[6] + hash[:offset] = parse_zone_offset(match[6]) + end + + return true + end + + false + end + + # ISO 8601 extended time: 04:05:06+09:00 + def iso8601_ext_time(str, hash) + # Pattern: HH:MM:SS.fraction or HH:MM:SS,fraction + pattern = /\A\s*(\d{2}):(\d{2})(?::(\d{2})(?:[,.](\d+))?)?(z|[-+]\d{2}(?::?\d{2})?)?\s*\z/ix + + match = pattern.match(str) + return false unless match + + hash[:hour] = match[1].to_i + hash[:min] = match[2].to_i + hash[:sec] = match[3].to_i if match[3] + hash[:sec_fraction] = parse_fraction(match[4]) if match[4] + + if match[5] + hash[:zone] = match[5] + hash[:offset] = parse_zone_offset(match[5]) + end + + true + end + + # ISO 8601 basic time: 040506 + def iso8601_bas_time(str, hash) + # Pattern: HHMMSS.fraction or HHMMSS,fraction + pattern = /\A\s*(\d{2})(\d{2})(?:(\d{2})(?:[,.](\d+))?)?(z|[-+]\d{2}(?:\d{2})?)?\s*\z/ix + + match = pattern.match(str) + return false unless match + + hash[:hour] = match[1].to_i + hash[:min] = match[2].to_i + hash[:sec] = match[3].to_i if match[3] + hash[:sec_fraction] = parse_fraction(match[4]) if match[4] + + if match[5] + hash[:zone] = match[5] + hash[:offset] = parse_zone_offset(match[5]) + end + + true + end + + # Parse fractional seconds + def parse_fraction(frac_str) + return nil unless frac_str + Rational(frac_str.to_i, 10 ** frac_str.length) + end + + # Parse timezone offset (Z, +09:00, -0500, etc.) + def parse_zone_offset(zone_str) + return nil if zone_str.nil? || zone_str.empty? + + zone = zone_str.strip + + # Handle [+9] or [-9] or [9 ] format (brackets around offset) + if zone =~ /^\[(.*)\]$/ + zone = $1.strip + end + + # Handle Z (UTC) + return 0 if zone.upcase == 'Z' + + # Handle unsigned numeric offset: 9, 09 (assume positive) + if zone =~ /^(\d{1,2})$/ + hours = $1.to_i + return hours * HOUR_IN_SECONDS + end + + # Handle simple numeric offsets with sign: +9, -9, +09, -05, etc. + if zone =~ /^([-+])(\d{1,2})$/ + sign = $1 == '-' ? -1 : 1 + hours = $2.to_i + return sign * (hours * HOUR_IN_SECONDS) + end + + # Handle +09:00, -05:30 format (with colon) + if zone =~ /^([-+])(\d{2}):(\d{2})$/ + sign = $1 == '-' ? -1 : 1 + hours = $2.to_i + minutes = $3.to_i + return sign * (hours * HOUR_IN_SECONDS + minutes * MINUTE_IN_SECONDS) + end + + # Handle +0900, -0500 format (4 digits, no colon) + if zone =~ /^([-+])(\d{4})$/ + sign = $1 == '-' ? -1 : 1 + hours = $2[0, 2].to_i + minutes = $2[2, 2].to_i + return sign * (hours * HOUR_IN_SECONDS + minutes * MINUTE_IN_SECONDS) + end + + # Handle +0900 format (4 digits without colon) + if zone =~ /^([-+])(\d{4})$/ + sign = $1 == '-' ? -1 : 1 + hours = $2[0, 2].to_i + minutes = $2[2, 2].to_i + return sign * (hours * HOUR_IN_SECONDS + minutes * MINUTE_IN_SECONDS) + end + + # Handle fractional hours: +9.5, -5.5 + if zone =~ /^([-+])(\d+)[.,](\d+)$/ + sign = $1 == '-' ? -1 : 1 + hours = $2.to_i + fraction = "0.#{$3}".to_f + return sign * ((hours + fraction) * HOUR_IN_SECONDS).to_i + end + + # Handle GMT+9, GMT-5, etc. + if zone =~ /^(?:gmt|utc)?([-+])(\d{1,2})(?::?(\d{2}))?(?::?(\d{2}))?$/i + sign = $1 == '-' ? -1 : 1 + hours = $2.to_i + minutes = $3 ? $3.to_i : 0 + seconds = $4 ? $4.to_i : 0 + return sign * (hours * HOUR_IN_SECONDS + minutes * MINUTE_IN_SECONDS + seconds) + end + + # Known timezone abbreviations + zone_offsets = { + 'JST' => 9 * HOUR_IN_SECONDS, + 'GMT' => 0, + 'UTC' => 0, + 'UT' => 0, + 'EST' => -5 * HOUR_IN_SECONDS, + 'EDT' => -4 * HOUR_IN_SECONDS, + 'CST' => -6 * HOUR_IN_SECONDS, + 'CDT' => -5 * HOUR_IN_SECONDS, + 'MST' => -7 * HOUR_IN_SECONDS, + 'MDT' => -6 * HOUR_IN_SECONDS, + 'PST' => -8 * HOUR_IN_SECONDS, + 'PDT' => -7 * HOUR_IN_SECONDS, + 'AEST' => 10 * HOUR_IN_SECONDS, + 'MET DST' => 2 * HOUR_IN_SECONDS, + 'GMT STANDARD TIME' => 0, + 'MOUNTAIN STANDARD TIME' => -7 * HOUR_IN_SECONDS, + 'MOUNTAIN DAYLIGHT TIME' => -6 * HOUR_IN_SECONDS, + 'MEXICO STANDARD TIME' => -6 * HOUR_IN_SECONDS, + 'E. AUSTRALIA STANDARD TIME' => 10 * HOUR_IN_SECONDS, + 'W. CENTRAL AFRICA STANDARD TIME' => 1 * HOUR_IN_SECONDS, + } + + # Handle military timezones (single letters A-Z except J) + if zone =~ /^([A-Z])$/i + letter = zone.upcase + return 0 if letter == 'Z' + return nil if letter == 'J' # J is not used + + if letter <= 'I' + # A-I: +1 to +9 + offset = letter.ord - 'A'.ord + 1 + elsif letter >= 'K' && letter <= 'M' + # K-M: +10 to +12 (skip J) + offset = letter.ord - 'A'.ord # K is 10th letter (ord-'A'=10) + elsif letter >= 'N' && letter <= 'Y' + # N-Y: -1 to -12 + offset = -(letter.ord - 'N'.ord + 1) + else + return nil + end + + return offset * HOUR_IN_SECONDS + end + + # Normalize zone string for lookup + zone_upper = zone.gsub(/\s+/, ' ').upcase + zone_offsets[zone_upper] + end + + # JIS X 0301 format: H13.02.03 or H13.02.03T04:05:06 + def parse_jisx0301_fmt(str, hash) + # Pattern: [Era]YY.MM.DD[T]HH:MM:SS[.fraction][timezone] + # Era initials: M, T, S, H, R (or none for ISO 8601 fallback) + pattern = /\A\s* + ([#{JISX0301_ERA_INITIALS}])? # Era (optional) + (\d{2})\.(\d{2})\.(\d{2}) # YY.MM.DD + (?:t # Time separator (optional) + (?: + (\d{2}):(\d{2}) # HH:MM + (?::(\d{2}) # :SS (optional) + (?:[,.](\d*))? # .fraction (optional) + )? + (z|[-+]\d{2}(?::?\d{2})?)? # timezone (optional) + )? + )? + \s*\z/ix + + match = pattern.match(str) + return false unless match + + # Parse era and year + era_char = match[1] ? match[1].upcase : JISX0301_DEFAULT_ERA + era_year = match[2].to_i + + # Convert era year to gregorian year + era_start = gengo(era_char) + hash[:year] = era_start + era_year + + # Parse month and day + hash[:mon] = match[3].to_i + hash[:mday] = match[4].to_i + + # Parse time (if present) + if match[5] + hash[:hour] = match[5].to_i + hash[:min] = match[6].to_i if match[6] + hash[:sec] = match[7].to_i if match[7] + hash[:sec_fraction] = parse_fraction(match[8]) if match[8] + end + + # Parse timezone (if present) + if match[9] + hash[:zone] = match[9] + hash[:offset] = parse_zone_offset(match[9]) + end + + true + end + + # Convert era character to year offset + def gengo(era_char) + case era_char.upcase + when 'M' then 1867 # Meiji + when 'T' then 1911 # Taisho + when 'S' then 1925 # Showa + when 'H' then 1988 # Heisei + when 'R' then 2018 # Reiwa + else 0 + end + end + + # Post-processing: matches C's date__parse post-processing after ok: label. + # + # 1. _bc handling: negate year and cwyear (year = 1 - year) + # 2. _comp handling: complete 2-digit year/cwyear to 4-digit (69-99 → 1900s, 0-68 → 2000s) + # 3. zone → offset conversion + # 4. Clean up internal keys + def apply_comp(hash) + # _bc: del_hash("_bc") — read and delete + bc = hash.delete(:_bc) + if bc + if hash.key?(:cwyear) + hash[:cwyear] = 1 - hash[:cwyear] + end + if hash.key?(:year) + hash[:year] = 1 - hash[:year] + end + end + + # _comp: del_hash("_comp") — read and delete + comp = hash.delete(:_comp) + if comp + if hash.key?(:cwyear) + y = hash[:cwyear] + if y >= 0 && y <= 99 + hash[:cwyear] = y >= 69 ? y + 1900 : y + 2000 + end + end + if hash.key?(:year) + y = hash[:year] + if y >= 0 && y <= 99 + hash[:year] = y >= 69 ? y + 1900 : y + 2000 + end + end + end + + # zone → offset conversion + if hash.key?(:zone) && !hash.key?(:offset) + hash[:offset] = date_zone_to_diff(hash[:zone]) + end + + # Clean up internal keys + hash.delete(:_year_str) + end + + # s3e in date_parse.c. + # y, m, and d are Strings or nil. m can also be an Integer (convert with to_s). + # bc is a Boolean. + # + # This method normalizes the year, mon, and mday from the combination of y, m, and + # d and writes them to a hash. + # The sorting logic operates in the following order of priority: + # + # Phase 1: Argument rotation and promotion + # - y and m are available, but d is nil => Rotate because it is a pair (mon, mday) + # - y is nil and d is long (>2 digits) or starts with an apostrophe => Promote d to y + # - If y has a leading character other than a digit, extract only the numeric portion, and if there is a remainder, add it to d + # + # Phase 2: Sort m and d + # - m starts with an apostrophe or its length is >2 => US->BE sort (y,m,d)=(m,d,y) + # - d starts with an apostrophe or its length is >2 => Swap (y,d) + # + # Phase 3: Write to hash + # - Extract the sign and digits from y and set them to year + # If signed or the number of digits is >2, write _comp = false + # - Extract the number from m and set it to mon + # - Extract the number from d and set it to mday + # - If bc is true, write _bc = true + def s3e(hash, y, m, d, bc) + # Candidates for _comp. If nil, do not write. + c = nil + + # If m is not a string, use to_s (parse_eu/parse_us passes the Integer returned by mon_num) + m = m.to_s unless m.nil? || m.is_a?(String) + + # ---------------------------------------------------------- + # Phase 1: Argument reordering + # ---------------------------------------------------------- + + # If we have y and m, but d is nil, it's actually a (mon, mday) pair, so we rotate it. + # (y, m, d) = (nil, y, m) + if !y.nil? && !m.nil? && d.nil? + y, m, d = nil, y, m + end + + # If y is nil and d exists, if d is long or begins with an apostrophe, it is promoted to y + if y.nil? + if !d.nil? && d.length > 2 + y = d + d = nil + end + if !d.nil? && d.length > 0 && d[0] == "'" + y = d + d = nil + end + end + + # If y has a leading character other than a sign or a number, skip it and + # extract only the numeric part. If there are any characters remaining after + # the extracted numeric string, swap y and d, and set the numeric part to d. + unless y.nil? + pos = 0 + pos += 1 while pos < y.length && !issign?(y[pos]) && !y[pos].match?(/\d/) + + unless pos >= y.length # no_date + bp = pos + pos += 1 if pos < y.length && issign?(y[pos]) + span = digit_span(y[pos..]) + ep = pos + span + + if ep < y.length + # There is a letter after the number string => exchange (y, d) + y, d = d, y[bp...ep] + end + end + end + + # ---------------------------------------------------------- + # Phase 2: Rearrange m and d + # ---------------------------------------------------------- + + # m starts with an apostrophe or length > 2 => US => BE sort + # (y, m, d) = (m, d, y) + if !m.nil? && (m[0] == "'" || m.length > 2) + y, m, d = m, d, y + end + + # d begins with an apostrophe or length > 2 => exchange (y, d) + if !d.nil? && (d[0] == "'" || d.length > 2) + y, d = d, y + end + + # ---------------------------------------------------------- + # Phase 3: Write to hash + # ---------------------------------------------------------- + + # year: Extract the sign and digit from y and set + unless y.nil? + pos = 0 + pos += 1 while pos < y.length && !issign?(y[pos]) && !y[pos].match?(/\d/) + + unless pos >= y.length # no_year + bp = pos + sign = false + if pos < y.length && issign?(y[pos]) + sign = true + pos += 1 + end + + c = false if sign # Signed => _comp = false + span = digit_span(y[pos..]) + c = false if span > 2 # Number of digits > 2 => _comp = false + + num_str = y[bp, (pos - bp) + span] # sign + number part + hash[:year] = num_str.to_i + end + end + + hash[:_bc] = true if bc + + # mon: Extract and set a number from m + unless m.nil? + pos = 0 + pos += 1 while pos < m.length && !m[pos].match?(/\d/) + + unless pos >= m.length # no_month + span = digit_span(m[pos..]) + hash[:mon] = m[pos, span].to_i + end + end + + # mday: Extract and set numbers from d + unless d.nil? + pos = 0 + pos += 1 while pos < d.length && !d[pos].match?(/\d/) + + unless pos >= d.length # no_mday + span = digit_span(d[pos..]) + hash[:mday] = d[pos, span].to_i + end + end + + # _comp is written only if it is explicitly false + hash[:_comp] = false unless c.nil? + end + + # issign macro in date_parse.c. + def issign?(c) + c == '-' || c == '+' + end + + # digit_span in date_parse.c. + # Returns the length of the first consecutive digit in the string 's'. + def digit_span(s) + i = 0 + i += 1 while i < s.length && s[i].match?(/\d/) + + i + end + + # date_zone_to_diff in date_parse.c. + # Returns the number of seconds since UTC from a time zone name or offset string. + # Returns nil if no match occurs. + # + # Supported input types: + # 1. Zone names: "EST", "JST", "Eastern", "Central Pacific", ... + # 2. Suffixes: "Eastern standard time", "EST dst", ... + # "standard time" => As is + # "daylight time" / "dst" => Set offset to +3600 + # 3. Numeric offset: "+09:00", "-0530", "+9", "GMT+09:00", ... + # 4. Fractional time offset: "+9.5" (=+09:30), "+5.50" (=+05:30), ... + def date_zone_to_diff(str) + return nil if str.nil? || str.empty? + + s = str.dup + dst = false + + # Suffix removal: "time", "standard", "daylight", "dst" + w = str_end_with_word(s, "time") + if w > 0 + s = s[0, s.length - w] + + w2 = str_end_with_word(s, "standard") + if w2 > 0 + s = s[0, s.length - w2] + else + w2 = str_end_with_word(s, "daylight") + if w2 > 0 + s = s[0, s.length - w2] + dst = true + else + # "time" alone is not enough, so return + s = str.dup + end + end + else + w = str_end_with_word(s, "dst") + if w > 0 + s = s[0, s.length - w] + dst = true + end + end + + # --- zonetab search --- + # Normalize consecutive spaces into a single space before searching + zn = shrink_space(s) + z_offset = ZONE_TABLE[zn.downcase] + + if z_offset + z_offset += 3600 if dst + return z_offset + end + + # --- Parse numeric offsets --- + # Remove "GMT" and "UTC" prefixes + if zn.length > 3 && zn[0, 3].downcase =~ /\A(gmt|utc)\z/ + zn = zn[3..] + end + + # If there is no sign, it is not treated as a numeric offset + return nil if zn.empty? || (zn[0] != '+' && zn[0] != '-') + + sign = zn[0] == '-' ? -1 : 1 + zn = zn[1..] + return nil if zn.empty? + + # ':' separator: HH:MM or HH:MM:SS + if zn.include?(':') + return parse_colon_offset(zn, sign) + end + + # '.' or ',' separator: HH.fraction + if zn.include?('.') || zn.include?(',') + return parse_fractional_offset(zn, sign) + end + + # Others: HH or HHMM or HHMMSS + parse_compact_offset(zn, sign) + end + + # str_end_with_word in date_parse.c. + # If the string 's' ends with "" (a word plus a space), + # Returns the length of that "" (including leading spaces). + # Otherwise, returns 0. + def str_end_with_word(s, word) + n = word.length + return 0 if s.length <= n + + # The last n characters match word (ignoring case) + return 0 unless s[-n..].casecmp?(word) + + # Is there a space just before it? + return 0 unless s[-(n + 1)].match?(/\s/) + + # Include consecutive spaces + count = n + 1 + count += 1 while count < s.length && s[-(count + 1)].match?(/\s/) + + count + end + + # shrink_space in date_parse.c. + # Combines consecutive spaces into a single space. + # If the length is the same as the original (normalization unnecessary), + # return it as is. + def shrink_space(s) + result = [] + prev_space = false + s.each_char do |ch| + if ch.match?(/\s/) + result << ' ' unless prev_space + prev_space = true + else + result << ch + prev_space = false + end + end + result.join + end + + # parse_colon_offset + # Parse "+HH:MM" or "+HH:MM:SS" and return the number of seconds. + # Range checking: hour 0-23, min 0-59, sec 0-59 + def parse_colon_offset(zn, sign) + parts = zn.split(':') + hour = parts[0].to_i + return nil if hour < 0 || hour > 23 + + min = parts.length > 1 ? parts[1].to_i : 0 + return nil if min < 0 || min > 59 + + sec = parts.length > 2 ? parts[2].to_i : 0 + return nil if sec < 0 || sec > 59 + + sign * (sec + min * 60 + hour * 3600) + end + + # Parse "+HH.fraction" or "+HH,fraction" and return the number of seconds. + # + # C logic: + # Read the fraction string up to 7 digits. + # sec = (read value) * 36 + # If n <= 2: + # If n == 1, sec *= 10 (treat HH.n as HH.n0) + # Return value = sec + hour * 3600 (Integer) + # If n > 2: + # Return value = Rational(sec, 10**(n-2)) + hour * 3600 + # Convert to an Integer if the denominator is 1. + # + # Reason for the 36 factor: + # 1 hour = 3600 seconds. Each decimal point is 1/10. Time = 360 seconds. + # However, since the implementation handles it in two-digit units, multiply + # by 36 before dividing by 10^2. + # (3600 / 100 = 36) + def parse_fractional_offset(zn, sign) + sep = zn.include?('.') ? '.' : ',' + hh_str, frac_str = zn.split(sep, 2) + hour = hh_str.to_i + return nil if hour < 0 || hour > 23 + + # Up to 7 digits (C: "no over precision for offset") + max_digits = 7 + frac_str = frac_str[0, max_digits] + n = frac_str.length + return sign * (hour * 3600) if n == 0 + + sec = frac_str.to_i * 36 # Convert to seconds by factor 36 + + if sign == -1 + hour = -hour + sec = -sec + end + + if n <= 2 + sec *= 10 if n == 1 # HH.n => HH.n0 + sec + hour * 3600 + else + # Rational for precise calculations + denom = 10 ** (n - 2) + offset = Rational(sec, denom) + (hour * 3600) + offset.denominator == 1 ? offset.to_i : offset + end + end + + # parse_compact_offset + # Parse consecutive numeric offsets without colons. + # HH (2 digits or less) + # HHM (3 digits: 1 digit for hour, 2 digits for min) + # HHMM (4 digits) + # HHMMM (5 digits: 2 digits for hour, 2 digits for min, 1 digit for sec) ... Rare in practical use + # HHMMSS (6 digits) + # + # C adjusts the leading padding width with "2 - l % 2". + # Ruby does the same calculation with length. + def parse_compact_offset(zn, sign) + l = zn.length + + # Only HH + return sign * zn.to_i * 3600 if l <= 2 + + # C: hour = scan_digits(&s[0], 2 - l % 2) + # min = scan_digits(&s[2 - l % 2], 2) + # sec = scan_digits(&s[4 - l % 2], 2) + # + # l=3 => hw=1 => hour=zn[0,1], min=zn[1,2] + # l=4 => hw=2 => hour=zn[0,2], min=zn[2,2] + # l=5 => hw=1 => hour=zn[0,1], min=zn[1,2], sec=zn[3,2] + # l=6 => hw=2 => hour=zn[0,2], min=zn[2,2], sec=zn[4,2] + hw = 2 - l % 2 # hour width: 2 for even, 1 for odd + hour = zn[0, hw].to_i + min = l >= 3 ? zn[hw, 2].to_i : 0 + sec = l >= 5 ? zn[hw + 2, 2].to_i : 0 + + sign * (sec + min * 60 + hour * 3600) + end + + # subx in date_parse.c. + # Matches pat against str. If it matches, replaces the matched + # portion of str (in-place) with rep (default: " ") and returns + # the MatchData. Returns nil on no match. + # + # This is the core mechanism C uses (via the SUBS macro) to + # prevent later parsers from re-matching already-consumed text. + def subx(str, pat, rep = " ") + m = pat.match(str) + return nil unless m + + str[m.begin(0), m.end(0) - m.begin(0)] = rep + m + end + + def check_class(str) + flags = 0 + str.each_char do |c| + flags |= HAVE_ALPHA if c =~ /[a-zA-Z]/ + flags |= HAVE_DIGIT if c =~ /\d/ + flags |= HAVE_DASH if c == '-' + flags |= HAVE_DOT if c == '.' + flags |= HAVE_SLASH if c == '/' + end + + flags + end + + # C macro HAVE_ELEM_P(x) in date_parse.c. + # Note: C calls check_class(str) every time because str is + # modified by subx. We do the same here. + def have_elem_p?(str, required) + (check_class(str) & required) == required + end + + # --- String type conversion (C's StringValue macro) --- + def string_value(str) + return str if str.is_a?(String) + if str.respond_to?(:to_str) + s = str.to_str + raise TypeError, "can't convert #{str.class} to String (#{str.class}#to_str gives #{s.class})" unless s.is_a?(String) + return s + end + raise TypeError, "no implicit conversion of #{str.class} into String" + end + + def check_string_limit(str, limit) + if limit && str.length > limit + raise ArgumentError, "string length (#{str.length}) exceeds the limit #{limit}" + end + end + + # C: d_new_by_frags + # Date-only fragment-based constructor. + # Time fields in hash are ignored — use dt_new_by_frags (in datetime.rb) for DateTime. + def new_by_frags(hash, sg) + raise Error, "invalid date" if hash.nil? || hash.empty? + + y = hash[:year] + m = hash[:mon] + d = hash[:mday] + + # Fast path: year+mon+mday present, no jd/yday + if !hash.key?(:jd) && !hash.key?(:yday) && y && m && d + raise Error, "invalid date" unless valid_civil?(y, m, d, sg) + obj = new(y, m, d, sg) + # Store parsed offset for deconstruct_keys([:zone]) without + # affecting JD calculations (don't use @of which triggers UTC conversion) + of = hash[:offset] + obj.instance_variable_set(:@parsed_offset, of) if of && of != 0 + return obj + end + + # Slow path — uses self (Date), so time-only patterns + # (e.g. '23:55') correctly fail: rt_complete_frags with Date class + # does not set :jd for :time pattern → rt__valid_date_frags_p returns nil. + hash = rt_rewrite_frags(hash) + hash = rt_complete_frags(self, hash) + jd = rt__valid_date_frags_p(hash, sg) + + raise Error, "invalid date" unless jd + + self.jd(jd, sg) + end + + # C: rt_rewrite_frags + # Converts :seconds (from %s/%Q) into jd/hour/min/sec/sec_fraction fields. + # + # C implementation (date_core.c:4033): + # seconds = del_hash("seconds"); + # if (!NIL_P(seconds)) { + # if (!NIL_P(offset)) seconds = f_add(seconds, offset); + # d = f_idiv(seconds, DAY_IN_SECONDS); + # fr = f_mod(seconds, DAY_IN_SECONDS); + # h = f_idiv(fr, HOUR_IN_SECONDS); fr = f_mod(fr, HOUR_IN_SECONDS); + # min= f_idiv(fr, MINUTE_IN_SECONDS); fr = f_mod(fr, MINUTE_IN_SECONDS); + # s = f_idiv(fr, 1); fr = f_mod(fr, 1); + # set jd = UNIX_EPOCH_IN_CJD + d, hour, min, sec, sec_fraction + # } + # + # Ruby's .div() and % match C's f_idiv (rb_intern("div")) and f_mod ('%'). + # Both use floor semantics, correctly handling negative and Rational values. + def rt_rewrite_frags(hash) + seconds = hash.delete(:seconds) + return hash unless seconds + + offset = hash[:offset] + seconds = seconds + offset if offset + + # Day count from Unix epoch + # C: d = f_idiv(seconds, DAY_IN_SECONDS) + d = seconds.div(DAY_IN_SECONDS) + fr = seconds % DAY_IN_SECONDS + + # Decompose remainder into h:min:s.frac + h = fr.div(HOUR_IN_SECONDS) + fr = fr % HOUR_IN_SECONDS + + min = fr.div(MINUTE_IN_SECONDS) + fr = fr % MINUTE_IN_SECONDS + + s = fr.div(1) + fr = fr % 1 + + # C: UNIX_EPOCH_IN_CJD = 2440588 (1970-01-01 in Chronological JD) + hash[:jd] = 2440588 + d + hash[:hour] = h + hash[:min] = min + hash[:sec] = s + hash[:sec_fraction] = fr + hash + end + + # C: rt_complete_frags (date_core.c:4071) + # + # Algorithm: + # 1. Score each of 11 field-set patterns against hash, pick highest match count. + # 2. For the winning named pattern, fill leading missing date fields from Date.today + # and set defaults for trailing date fields. + # 3. Special case: "time" pattern + DateTime class → set :jd from today. + # 4. Default :hour/:min/:sec to 0; clamp :sec to 59. + # + # Pattern table (C's static tab): + # [name, [fields...]] + # ────────────────────────── + # [:time, [:hour, :min, :sec]] + # [nil, [:jd]] + # [:ordinal, [:year, :yday, :hour, :min, :sec]] + # [:civil, [:year, :mon, :mday, :hour, :min, :sec]] + # [:commercial, [:cwyear, :cweek, :cwday, :hour, :min, :sec]] + # [:wday, [:wday, :hour, :min, :sec]] + # [:wnum0, [:year, :wnum0, :wday, :hour, :min, :sec]] + # [:wnum1, [:year, :wnum1, :wday, :hour, :min, :sec]] + # [nil, [:cwyear, :cweek, :wday, :hour, :min, :sec]] + # [nil, [:year, :wnum0, :cwday, :hour, :min, :sec]] + # [nil, [:year, :wnum1, :cwday, :hour, :min, :sec]] + # + def rt_complete_frags(klass, hash) + # Step 1: Find best matching pattern + # C: for each tab entry, count how many fields exist in hash; pick max. + # First match wins on tie (strict >). + best_key = nil + best_fields = nil + best_count = 0 + + COMPLETE_FRAGS_TABLE.each do |key, fields| + count = fields.count { |f| hash.key?(f) } + if count > best_count + best_count = count + best_key = key + best_fields = fields + end + end + + # Step 2: Complete missing fields for named patterns + # C: if (!NIL_P(k) && (RARRAY_LEN(a) > e)) + d = nil # lazy Date.today + + if best_key && best_fields && best_fields.length > best_count + case best_key + + when :ordinal + # C: fill year from today if missing, default yday=1 + unless hash.key?(:year) + d ||= today + hash[:year] = d.year + end + hash[:yday] ||= 1 + + when :civil + # C: fill leading missing fields from today, stop at first present field. + # Then default mon=1, mday=1. + # + # The loop iterates [:year, :mon, :mday, :hour, :min, :sec]. + # For each field, if it's already in hash → break. + # Otherwise fill from today via d.send(field). + # In practice, the loop only reaches date fields (:year/:mon/:mday) + # because at least one date field must be present for civil to win. + best_fields.each do |f| + break if hash.key?(f) + d ||= today + hash[f] = d.send(f) + end + hash[:mon] ||= 1 + hash[:mday] ||= 1 + + when :commercial + # C: same leading-fill pattern, then default cweek=1, cwday=1 + best_fields.each do |f| + break if hash.key?(f) + d ||= today + hash[f] = d.send(f) + end + hash[:cweek] ||= 1 + hash[:cwday] ||= 1 + + when :wday + # C: set_hash("jd", d_lite_jd(f_add(f_sub(d, d_lite_wday(d)), ref_hash("wday")))) + # → jd of (today - today.wday + parsed_wday) + d ||= today + hash[:jd] = (d - d.wday + hash[:wday]).jd + + when :wnum0 + # C: leading-fill from today, then default wnum0=0, wday=0 + best_fields.each do |f| + break if hash.key?(f) + d ||= today + # :year is the only field that can be missing before :wnum0 in practice + hash[f] = d.send(f) if d.respond_to?(f) + end + hash[:wnum0] ||= 0 + hash[:wday] ||= 0 + + when :wnum1 + # C: leading-fill from today, then default wnum1=0, wday=1 + best_fields.each do |f| + break if hash.key?(f) + d ||= today + hash[f] = d.send(f) if d.respond_to?(f) + end + hash[:wnum1] ||= 0 + hash[:wday] ||= 1 + end + end + + # Step 3: "time" pattern special case + # C: if (k == sym("time")) { if (f_le_p(klass, cDateTime)) { ... } } + # For DateTime (or subclass), time-only input gets :jd from today. + # For Date, time-only input will fail validation (no date fields). + if best_key == :time + if defined?(DateTime) && klass <= DateTime + d ||= today + hash[:jd] ||= d.jd + end + end + + # Step 4: Default time fields, clamp sec + # C: if (NIL_P(ref_hash("hour"))) set_hash("hour", 0); + # if (NIL_P(ref_hash("min"))) set_hash("min", 0); + # if (NIL_P(ref_hash("sec"))) set_hash("sec", 0); + # else if (ref_hash("sec") > 59) set_hash("sec", 59); + hash[:hour] ||= 0 + hash[:min] ||= 0 + if !hash.key?(:sec) + hash[:sec] = 0 + elsif hash[:sec] > 59 + hash[:sec] = 59 + end + + hash + end + + # C: rt__valid_date_frags_p (date_core.c:4379) + # Tries 6 strategies to produce a valid JD from hash fragments: + # jd → ordinal → civil → commercial → wnum0 → wnum1 + def rt__valid_date_frags_p(hash, sg) + # 1. Try jd (C: rt__valid_jd_p just returns jd) + if hash[:jd] + return hash[:jd] + end + + # 2. Try ordinal: year + yday + if hash[:yday] && hash[:year] + y = hash[:year] + yd = hash[:yday] + if valid_ordinal?(y, yd, sg) + return ordinal(y, yd, sg).jd + end + end + + # 3. Try civil: year + mon + mday + if hash[:mday] && hash[:mon] && hash[:year] + y = hash[:year] + m = hash[:mon] + d = hash[:mday] + if valid_civil?(y, m, d, sg) + return new(y, m, d, sg).jd + end + end + + # 4. Try commercial: cwyear + cweek + cwday/wday + # C: wday = ref_hash("cwday"); + # if (NIL_P(wday)) { wday = ref_hash("wday"); if wday==0 → wday=7; } + begin + wday = hash[:cwday] + if wday.nil? + wday = hash[:wday] + wday = 7 if wday && wday == 0 # Sunday: wday 0 → cwday 7 + end + + if wday && hash[:cweek] && hash[:cwyear] + jd = rt__valid_commercial_p(hash[:cwyear], hash[:cweek], wday, sg) + return jd if jd + end + end + + # 5. Try wnum0: year + wnum0 + wday (Sunday-first week, %U) + # C: wday = ref_hash("wday"); + # if (NIL_P(wday)) { wday = ref_hash("cwday"); if cwday==7 → wday=0; } + begin + wday = hash[:wday] + if wday.nil? + wday = hash[:cwday] + wday = 0 if wday && wday == 7 # Sunday: cwday 7 → wday 0 + end + + if wday && hash[:wnum0] && hash[:year] + jd = rt__valid_weeknum_p(hash[:year], hash[:wnum0], wday, 0, sg) + return jd if jd + end + end + + # 6. Try wnum1: year + wnum1 + wday (Monday-first week, %W) + # C: wday = ref_hash("wday"); if NIL → wday = ref_hash("cwday"); + # if wday → wday = (wday - 1) % 7 + begin + wday = hash[:wday] + wday = hash[:cwday] if wday.nil? + if wday + wday = (wday - 1) % 7 # Convert: 0(Sun)→6, 1(Mon)→0, ..., 7(Sun)→6 + end + + if wday && hash[:wnum1] && hash[:year] + jd = rt__valid_weeknum_p(hash[:year], hash[:wnum1], wday, 1, sg) + return jd if jd + end + end + + nil + end + + # C: rt__valid_commercial_p (date_core.c:4347) + # Validates commercial date and returns JD, or nil. + def rt__valid_commercial_p(y, w, d, sg) + if valid_commercial?(y, w, d, sg) + return commercial(y, w, d, sg).jd + end + nil + end + + # C: rt__valid_weeknum_p → valid_weeknum_p → c_valid_weeknum_p (date_core.c:1009) + # Validates weeknum-based date and returns JD, or nil. + # f=0 for Sunday-first (%U), f=1 for Monday-first (%W). + def rt__valid_weeknum_p(y, w, d, f, sg) + # C: if (d < 0) d += 7; + d += 7 if d < 0 + # C: if (w < 0) { ... normalize via next year ... } + if w < 0 + rjd2 = c_weeknum_to_jd(y + 1, 1, f, f, sg) + ry2, rw2, _ = c_jd_to_weeknum(rjd2 + w * 7, f, sg) + return nil if ry2 != y + w = rw2 + end + jd = c_weeknum_to_jd(y, w, d, f, sg) + ry, rw, rd = c_jd_to_weeknum(jd, f, sg) + return nil if y != ry || w != rw || d != rd + jd + end + + # C: c_weeknum_to_jd (date_core.c:663) + # Converts (year, week_number, day_in_week, first_day_flag, sg) → JD. + # + # C formula: + # c_find_fdoy(y, sg, &rjd2, &ns2); + # rjd2 += 6; + # *rjd = (rjd2 - MOD(((rjd2 - f) + 1), 7) - 7) + 7 * w + d; + def c_weeknum_to_jd(y, w, d, f, sg) + fdoy_jd, _ = c_find_fdoy(y, sg) + fdoy_jd += 6 + (fdoy_jd - ((fdoy_jd - f + 1) % 7) - 7) + 7 * w + d + end + + # C: c_jd_to_weeknum (date_core.c:674) + # Converts JD → [year, week_number, day_in_week]. + # Class-method version (the instance method in core.rb calls self.class.send). + # + # C formula: + # c_jd_to_civil(jd, sg, &ry, ...); + # c_find_fdoy(ry, sg, &rjd, ...); + # rjd += 6; + # j = jd - (rjd - MOD((rjd - f) + 1, 7)) + 7; + # rw = DIV(j, 7); + # rd = MOD(j, 7); + def c_jd_to_weeknum(jd, f, sg) + ry, _, _ = c_jd_to_civil(jd, sg) + fdoy_jd, _ = c_find_fdoy(ry, sg) + fdoy_jd += 6 + + j = jd - (fdoy_jd - ((fdoy_jd - f + 1) % 7)) + 7 + rw = j.div(7) + rd = j % 7 + + [ry, rw, rd] + end + + # --- comp_year helpers (C's comp_year69, comp_year50) --- + def comp_year69(y) + y >= 69 ? y + 1900 : y + 2000 + end + + def comp_year50(y) + y >= 50 ? y + 1900 : y + 2000 + end + + # --- sec_fraction helper --- + def sec_fraction(frac_str) + Rational(frac_str.to_i, 10 ** frac_str.length) + end + + # ================================================================ + # Format-specific parsers (date_parse.c) + # ================================================================ + + # --- ISO 8601 --- + + def date__iso8601(str) + hash = {} + return hash if str.nil? || str.empty? + + if (m = ISO8601_EXT_DATETIME_PAT.match(str)) + iso8601_ext_datetime_cb(m, hash) + elsif (m = ISO8601_BAS_DATETIME_PAT.match(str)) + iso8601_bas_datetime_cb(m, hash) + elsif (m = ISO8601_EXT_TIME_PAT.match(str)) + iso8601_time_cb(m, hash) + elsif (m = ISO8601_BAS_TIME_PAT.match(str)) + iso8601_time_cb(m, hash) + end + hash + end + + def iso8601_ext_datetime_cb(m, hash) + if m[1] + hash[:mday] = m[3].to_i if m[3] + if m[1] != '-' + y = m[1].to_i + y = comp_year69(y) if m[1].length < 4 + hash[:year] = y + end + if m[2].nil? + return false if m[1] != '-' + else + hash[:mon] = m[2].to_i + end + elsif m[5] + hash[:yday] = m[5].to_i + if m[4] + y = m[4].to_i + y = comp_year69(y) if m[4].length < 4 + hash[:year] = y + end + elsif m[8] + hash[:cweek] = m[7].to_i + hash[:cwday] = m[8].to_i + if m[6] + y = m[6].to_i + y = comp_year69(y) if m[6].length < 4 + hash[:cwyear] = y + end + elsif m[9] + hash[:cwday] = m[9].to_i + end + + if m[10] + hash[:hour] = m[10].to_i + hash[:min] = m[11].to_i + hash[:sec] = m[12].to_i if m[12] + end + hash[:sec_fraction] = sec_fraction(m[13]) if m[13] + if m[14] + hash[:zone] = m[14] + hash[:offset] = date_zone_to_diff(m[14]) + end + true + end + + def iso8601_bas_datetime_cb(m, hash) + if m[3] + hash[:mday] = m[3].to_i + if m[1] != '--' + y = m[1].to_i + y = comp_year69(y) if m[1].length < 4 + hash[:year] = y + end + if m[2][0] == '-' + return false if m[1] != '--' + else + hash[:mon] = m[2].to_i + end + elsif m[5] + hash[:yday] = m[5].to_i + y = m[4].to_i + y = comp_year69(y) if m[4].length < 4 + hash[:year] = y + elsif m[6] + hash[:yday] = m[6].to_i + elsif m[9] + hash[:cweek] = m[8].to_i + hash[:cwday] = m[9].to_i + y = m[7].to_i + y = comp_year69(y) if m[7].length < 4 + hash[:cwyear] = y + elsif m[11] + hash[:cweek] = m[10].to_i + hash[:cwday] = m[11].to_i + elsif m[12] + hash[:cwday] = m[12].to_i + end + + if m[13] + hash[:hour] = m[13].to_i + hash[:min] = m[14].to_i + hash[:sec] = m[15].to_i if m[15] + end + hash[:sec_fraction] = sec_fraction(m[16]) if m[16] + if m[17] + hash[:zone] = m[17] + hash[:offset] = date_zone_to_diff(m[17]) + end + true + end + + def iso8601_time_cb(m, hash) + hash[:hour] = m[1].to_i + hash[:min] = m[2].to_i + hash[:sec] = m[3].to_i if m[3] + hash[:sec_fraction] = sec_fraction(m[4]) if m[4] + if m[5] + hash[:zone] = m[5] + hash[:offset] = date_zone_to_diff(m[5]) + end + true + end + + # --- RFC 3339 --- + + def date__rfc3339(str) + hash = {} + return hash if str.nil? || str.empty? + + m = RFC3339_PAT.match(str) + return hash unless m + + hash[:year] = m[1].to_i + hash[:mon] = m[2].to_i + hash[:mday] = m[3].to_i + hash[:hour] = m[4].to_i + hash[:min] = m[5].to_i + hash[:sec] = m[6].to_i + hash[:zone] = m[8] + hash[:offset] = date_zone_to_diff(m[8]) + hash[:sec_fraction] = sec_fraction(m[7]) if m[7] + hash + end + + # --- XML Schema --- + + def date__xmlschema(str) + hash = {} + return hash if str.nil? || str.empty? + + if (m = XMLSCHEMA_DATETIME_PAT.match(str)) + hash[:year] = m[1].to_i + hash[:mon] = m[2].to_i if m[2] + hash[:mday] = m[3].to_i if m[3] + hash[:hour] = m[4].to_i if m[4] + hash[:min] = m[5].to_i if m[5] + hash[:sec] = m[6].to_i if m[6] + hash[:sec_fraction] = sec_fraction(m[7]) if m[7] + if m[8] + hash[:zone] = m[8] + hash[:offset] = date_zone_to_diff(m[8]) + end + elsif (m = XMLSCHEMA_TIME_PAT.match(str)) + hash[:hour] = m[1].to_i + hash[:min] = m[2].to_i + hash[:sec] = m[3].to_i if m[3] + hash[:sec_fraction] = sec_fraction(m[4]) if m[4] + if m[5] + hash[:zone] = m[5] + hash[:offset] = date_zone_to_diff(m[5]) + end + elsif (m = XMLSCHEMA_TRUNC_PAT.match(str)) + hash[:mon] = m[1].to_i if m[1] + hash[:mday] = m[2].to_i if m[2] + hash[:mday] = m[3].to_i if m[3] + if m[4] + hash[:zone] = m[4] + hash[:offset] = date_zone_to_diff(m[4]) + end + end + hash + end + + # --- RFC 2822 --- + + def date__rfc2822(str) + hash = {} + return hash if str.nil? || str.empty? + + m = PARSE_RFC2822_PAT.match(str) + return hash unless m + + hash[:wday] = day_num(m[1]) if m[1] + hash[:mday] = m[2].to_i + hash[:mon] = mon_num(m[3]) + y = m[4].to_i + y = comp_year50(y) if m[4].length < 4 + hash[:year] = y + hash[:hour] = m[5].to_i + hash[:min] = m[6].to_i + hash[:sec] = m[7].to_i if m[7] + hash[:zone] = m[8] + hash[:offset] = date_zone_to_diff(m[8]) + hash + end + + # --- HTTP date --- + + def date__httpdate(str) + hash = {} + return hash if str.nil? || str.empty? + + if (m = PARSE_HTTPDATE_TYPE1_PAT.match(str)) + hash[:wday] = day_num(m[1]) + hash[:mday] = m[2].to_i + hash[:mon] = mon_num(m[3]) + hash[:year] = m[4].to_i + hash[:hour] = m[5].to_i + hash[:min] = m[6].to_i + hash[:sec] = m[7].to_i + hash[:zone] = m[8] + hash[:offset] = 0 + elsif (m = PARSE_HTTPDATE_TYPE2_PAT.match(str)) + hash[:wday] = day_num(m[1]) + hash[:mday] = m[2].to_i + hash[:mon] = mon_num(m[3]) + y = m[4].to_i + y = comp_year69(y) if y >= 0 && y <= 99 + hash[:year] = y + hash[:hour] = m[5].to_i + hash[:min] = m[6].to_i + hash[:sec] = m[7].to_i + hash[:zone] = m[8] + hash[:offset] = 0 + elsif (m = PARSE_HTTPDATE_TYPE3_PAT.match(str)) + hash[:wday] = day_num(m[1]) + hash[:mon] = mon_num(m[2]) + hash[:mday] = m[3].to_i + hash[:hour] = m[4].to_i + hash[:min] = m[5].to_i + hash[:sec] = m[6].to_i + hash[:year] = m[7].to_i + end + hash + end + + # --- JIS X 0301 --- + + def date__jisx0301(str) + hash = {} + return hash if str.nil? || str.empty? + + m = PARSE_JISX0301_PAT.match(str) + if m + era = m[1] || JISX0301_DEFAULT_ERA + ep = gengo(era) + hash[:year] = ep + m[2].to_i + hash[:mon] = m[3].to_i + hash[:mday] = m[4].to_i + if m[5] + hash[:hour] = m[5].to_i + hash[:min] = m[6].to_i if m[6] + hash[:sec] = m[7].to_i if m[7] + end + hash[:sec_fraction] = sec_fraction(m[8]) if m[8] && !m[8].empty? + if m[9] + hash[:zone] = m[9] + hash[:offset] = date_zone_to_diff(m[9]) + end + else + # Fallback to iso8601 + hash = date__iso8601(str) + end + hash + end + end +end diff --git a/lib/date/patterns.rb b/lib/date/patterns.rb new file mode 100644 index 00000000..b8437b25 --- /dev/null +++ b/lib/date/patterns.rb @@ -0,0 +1,403 @@ +# frozen_string_literal: true + +class Date + # TIME_PAT + # Regular expression pattern for C's parse_time. + # $1: entire time portion + # $2: time zone portion (optional) + # + # In the zone portion, [A-Za-z] is used for case-sensitive alphabetic characters. + TIME_PAT = / + ( # $1: whole time + \d+\s* # hour (required) + (?: + (?: # Branch A: colon-separated + :\s*\d+ # :min + (?: + \s*:\s*\d+(?:[,.]\d*)? # :sec[.frac] + )? + | # Branch B: h m s separated + h(?:\s*\d+m? + (?:\s*\d+s?)? + )? + ) + (?: # AM PM suffix (optional) + \s*[ap](?:m\b|\.m\.) + )? + | # Branch C: Only AM PM + [ap](?:m\b|\.m\.) + ) + ) + (?: # Time Zone (optional) + \s* + ( # $2: time zone + (?:gmt|utc?)?[-+]\d+ + (?:[,.:]\d+(?::\d+)?)? + | + [[:alpha:].\s]+ + (?:standard|daylight)\stime\b + | + [[:alpha:]]+(?:\sdst)?\b + ) + )? + /xi + private_constant :TIME_PAT + + # TIME_DETAIL_PAT + # Pattern for detailed parsing of time portion + TIME_DETAIL_PAT = / + \A(\d+)\s* # $1 hour + (?: + :\s*(\d+) # $2 min (colon) + (?:\s*:\s*(\d+)([,.]\d*)?)? # $3 sec, $4 frac (colon) + | + h(?:\s*(\d+)m? # $5 min (h) + (?:\s*(\d+)s?)? # $6 sec (h) + )? + )? + (?:\s*([ap])(?:m\b|\.m\.))? # $7 am pm + /xi + private_constant :TIME_DETAIL_PAT + + # PARSE_DAY_PAT + # Non-TIGHT pattern for parse_day. + # Matches abbreviated day name and consumes trailing characters + # (e.g., "urday" in "Saturday") so they get replaced by subx. + PARSE_DAY_PAT = /\b(sun|mon|tue|wed|thu|fri|sat)[^-\/\d\s]*/i + private_constant :PARSE_DAY_PAT + + # ERA1_PAT + # Pattern for AD, A.D. + ERA1_PAT = /\b(a(?:d\b|\.d\.))(?!(? string + # + # Returns a string representation of the date in +self+, + # formatted according the given +format+: + # + # Date.new(2001, 2, 3).strftime # => "2001-02-03" + # + # For other formats, see + # {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]. + def strftime(format = STRFTIME_DEFAULT_FMT) + # If format is not a string, convert it to a string. + format = format.to_str unless format.is_a?(String) + + # Check for ASCII compatible encoding. + raise ArgumentError, "format should have ASCII compatible encoding" unless format.encoding.ascii_compatible? + + # Empty format returns empty string + return '' if format.empty? + + # What to do if format string contains a "\0". + if format.include?("\0") + result = String.new + parts = format.split("\0", -1) + + parts.each_with_index do |part, i| + result << strftime_format(part) unless part.empty? + result << "\0" if i < parts.length - 1 + end + + result.force_encoding(format.encoding) + + return result + end + + # Normal processing without "\0" in format string. + result = strftime_format(format) + result.force_encoding(format.encoding) + + result + end + + private + + def tmx_year + m_real_year + end + + def tmx_mon + mon + end + + def tmx_mday + mday + end + + def tmx_yday + yday + end + + def tmx_cwyear + m_real_cwyear + end + + def tmx_cweek + cweek + end + + def tmx_cwday + cwday + end + + def tmx_wday + wday + end + + def tmx_wnum0 + # Week number (Sunday start, 00-53) + m_wnumx(0) + end + + def tmx_wnum1 + # Week number (Monday start, 00-53) + m_wnumx(1) + end + + def tmx_hour + if simple_dat_p? + 0 + else + df = df_utc_to_local(m_df, m_of) + (df / 3600).floor + end + end + + def tmx_min + if simple_dat_p? + 0 + else + df = df_utc_to_local(m_df, m_of) + ((df % 3600) / 60).floor + end + end + + def tmx_sec + if simple_dat_p? + 0 + else + df = df_utc_to_local(m_df, m_of) + df % 60 + end + end + + def tmx_sec_fraction + if simple_dat_p? + Rational(0, 1) + else + # (Decimal part of df) + sf + df_frac = m_df - m_df.floor + sf_frac = m_sf == 0 ? 0 : Rational(m_sf, SECOND_IN_NANOSECONDS) + df_frac + sf_frac + end + end + + def tmx_secs + # C: tmx_m_secs (date_core.c:7306) + # s = day_to_sec(m_real_jd - UNIX_EPOCH_IN_CJD) + # if complex: s += m_df + s = jd_to_unix_time(m_real_jd) + return s if simple_dat_p? + df = m_df + s += df if df != 0 + s + end + + def tmx_msecs + # C: tmx_m_msecs (date_core.c:7322) + # s = tmx_m_secs * 1000 + # if complex: s += m_sf / MILLISECOND_IN_NANOSECONDS + s = tmx_secs * SECOND_IN_MILLISECONDS + return s if simple_dat_p? + sf = m_sf + s += (sf / (SECOND_IN_NANOSECONDS / SECOND_IN_MILLISECONDS)).to_i if sf != 0 + s + end + + def tmx_offset + simple_dat_p? ? 0 : m_of + end + + def tmx_zone + if simple_dat_p? || tmx_offset.zero? + "+00:00" + else + of2str(m_of) + end + end + + def of2str(of) + s, h, m = decode_offset(of) + sprintf('%c%02d:%02d', s, h, m) + end + + def decode_offset(of) + s = (of < 0) ? '-' : '+' + a = of.abs + h = a / HOUR_IN_SECONDS + m = (a % HOUR_IN_SECONDS) / MINUTE_IN_SECONDS + [s, h, m] + end + + # Processing format strings. + def strftime_format(format) + result = String.new + i = 0 + + while i < format.length + if format[i] == '%' && i + 1 < format.length + # Skip '%' + i += 1 + + # C: Parse all modifiers in a flat loop (flags, width, colons, E/O) + flags = String.new + width = String.new + modifier = nil + colons = 0 + + while i < format.length + c = format[i] + case c + when 'E', 'O' + modifier = c + i += 1 + when ':' + colons += 1 + i += 1 + when '-', '_', '^', '#' + flags << c + i += 1 + when '0' + # '0' is a flag only when width is still empty + if width.empty? + flags << c + i += 1 + else + width << c + i += 1 + end + when /[1-9]/ + width << c + i += 1 + # Continue reading remaining digits + while i < format.length && format[i] =~ /[0-9]/ + width << format[i] + i += 1 + end + else + break + end + end + + # Invalid if both E/O and colon modifiers are present. + if modifier && colons > 0 + if i < format.length + spec = format[i] + result << "%#{modifier}#{':' * colons}#{spec}" + i += 1 + end + next + end + + # Width specifier overflow check + unless width.empty? + if width.length > 10 || (width.length == 10 && width > '2147483647') + raise Errno::ERANGE, "Result too large" + end + if width.to_i >= 1024 + raise Errno::ERANGE, "Result too large" + end + end + + if i < format.length + spec = format[i] + + if modifier + # E/O modifier check must come first + valid = case modifier + when 'E' + %w[c C x X y Y].include?(spec) + when 'O' + %w[d e H k I l m M S u U V w W y].include?(spec) + else + false + end + + if valid + formatted = format_spec(spec, flags, width) + result << formatted + else + result << "%#{modifier}#{flags}#{width}#{spec}" + end + elsif spec == 'z' + # %z with any combination of colons/width/flags + formatted = format_z(tmx_offset, width, flags, colons) + result << formatted + elsif colons > 0 + # Colon modifier is only valid for 'z'. + result << "%#{':' * colons}#{flags}#{width}#{spec}" + else + formatted = format_spec(spec, flags, width) + result << formatted + end + + i += 1 + end + else + result << format[i] + i += 1 + end + end + + result.force_encoding('US-ASCII') if result.ascii_only? + + result + end + + def format_spec(spec, flags = '', width = '') + # N/L: width controls precision (number of fractional digits) + if spec == 'N' || spec == 'L' + precision = if !width.empty? + width.to_i + elsif spec == 'L' + 3 + else + 9 + end + frac = tmx_sec_fraction + digits = (frac * (10 ** precision)).floor + return sprintf("%0#{precision}d", digits) + end + + # Get basic formatting results. + base_result = get_base_format(spec, flags) + + # Apply case change flags (before width/precision) + base_result = apply_case_flags(base_result, spec, flags) + + # Apply width specifier. + if !width.empty? + width_num = width.to_i + default_pad = if NUMERIC_SPECS.include?(spec) + '0' + elsif SPACE_PAD_SPECS.include?(spec) + ' ' + else + ' ' + end + apply_width(base_result, width_num, flags, default_pad) + else + base_result + end + end + + # C: Apply ^ (UPPER) and # (CHCASE) flags + def apply_case_flags(str, spec, flags) + if flags.include?('^') + str.upcase + elsif flags.include?('#') + if CHCASE_UPPER_SPECS.include?(spec) + str.upcase + elsif CHCASE_LOWER_SPECS.include?(spec) + str.downcase + else + str.swapcase + end + else + str + end + end + + # format specifiers + def get_base_format(spec, flags = '') + case spec + when 'Y' # 4-digit year + y = tmx_year + raise Errno::ERANGE, "Result too large" if y.is_a?(Integer) && y.bit_length > 128 + # C: FMT('0', y >= 0 ? 4 : 5, "ld", y) + prec = y < 0 ? 5 : 4 + if flags.include?('-') + y.to_s + elsif flags.include?('_') + sprintf("%#{prec}d", y) + else + sprintf("%0#{prec}d", y) + end + when 'C' # Century + sprintf('%02d', tmx_year / 100) + when 'y' # Two-digit year + sprintf('%02d', tmx_year % 100) + when 'm' # Month (01-12) + sprintf('%02d', tmx_mon) + when 'B' # Full month name + MONTHNAMES[tmx_mon] || '?' + when 'b', 'h' # Abbreviated month name + (ABBR_MONTHNAMES[tmx_mon] || '?')[0, 3] + when 'd' # Day (01-31) + if flags.include?('-') + # Left-justified (no padding) + tmx_mday.to_s + elsif flags.include?('_') + # Space-padded + sprintf('%2d', tmx_mday) + else + # Zero-padded (default) + sprintf('%02d', tmx_mday) + end + when 'e' # Day (1-31) blank filled + if flags.include?('-') + tmx_mday.to_s + elsif flags.include?('0') + sprintf('%02d', tmx_mday) + else + sprintf('%2d', tmx_mday) + end + when 'j' # Day of the year (001-366) + if flags.include?('-') + tmx_yday.to_s + else + sprintf('%03d', tmx_yday) + end + when 'H' # Hour (00-23) + if flags.include?('-') + tmx_hour.to_s + elsif flags.include?('_') + sprintf('%2d', tmx_hour) + else + sprintf('%02d', tmx_hour) + end + when 'k' # Hour (0-23) blank-padded + sprintf('%2d', tmx_hour) + when 'I' # Hour (01-12) + h = tmx_hour % 12 + h = 12 if h.zero? + if flags.include?('-') + h.to_s + elsif flags.include?('_') + sprintf('%2d', h) + else + sprintf('%02d', h) + end + when 'l' # Hour (1-12) blank filled + h = tmx_hour % 12 + h = 12 if h.zero? + sprintf('%2d', h) + when 'M' # Minutes (00-59) + if flags.include?('-') + tmx_min.to_s + elsif flags.include?('_') + sprintf('%2d', tmx_min) + else + sprintf('%02d', tmx_min) + end + when 'S' # Seconds (00-59) + if flags.include?('-') + tmx_sec.to_s + elsif flags.include?('_') + sprintf('%2d', tmx_sec) + else + sprintf('%02d', tmx_sec) + end + when 'L' # Milliseconds (000-999) + sprintf('%09d', (tmx_sec_fraction * 1_000_000_000).floor) + when 'N' # Fractional seconds digits + # C: width controls precision (number of digits), default 9. + # %3N → 3 digits (milliseconds), %6N → 6 digits (microseconds), + # %9N → 9 digits (nanoseconds), %12N → 12 digits (picoseconds, zero-padded). + # The 'width' variable is handled specially in format_spec for 'N'. + sprintf('%09d', (tmx_sec_fraction * 1_000_000_000).floor) + when 'P' # am/pm + tmx_hour < 12 ? 'am' : 'pm' + when 'p' # AM/PM + tmx_hour < 12 ? 'AM' : 'PM' + when 'A' # Full name of the day of the week + DAYNAMES[tmx_wday] || '?' + when 'a' # Abbreviated day of the week + (ABBR_DAYNAMES[tmx_wday] || '?')[0, 3] + when 'w' # Day of the week (0-6, Sunday is 0) + tmx_wday.to_s + when 'u' # Day of the week (1-7, Monday is 1) + tmx_cwday.to_s + when 'U' # Week number (00-53, Sunday start) + sprintf('%02d', tmx_wnum0) + when 'W' # Week number (00-53, Monday start) + sprintf('%02d', tmx_wnum1) + when 'V' # ISO week number (01-53) + sprintf('%02d', tmx_cweek) + when 'G' # ISO week year + y = tmx_cwyear + prec = y < 0 ? 5 : 4 + if flags.include?('-') + y.to_s + elsif flags.include?('_') + sprintf("%#{prec}d", y) + else + sprintf("%0#{prec}d", y) + end + when 'g' # ISO week year (2 digits) + sprintf('%02d', tmx_cwyear % 100) + when 'z' # Time Zone Offset (+0900) — handled by format_z in format_spec + format_z(tmx_offset, '', '', 0) + when 'Z' # Time Zone Name + tmx_zone || '' + when 's' # Number of seconds since the Unix epoch + tmx_secs.to_s + when 'Q' # Milliseconds since the Unix epoch + tmx_msecs.to_s + when 'n' # Line breaks + "\n" + when 't' # Tab + "\t" + when '%' # % symbol + '%' + when 'F' # %Y-%m-%d + strftime_format('%Y-%m-%d') + when 'D' # %m/%d/%y + strftime_format('%m/%d/%y') + when 'x' # %m/%d/%y + strftime_format('%m/%d/%y') + when 'T', 'X' # %H:%M:%S + strftime_format('%H:%M:%S') + when 'R' # %H:%M + strftime_format('%H:%M') + when 'r' # %I:%M:%S %p + strftime_format('%I:%M:%S %p') + when 'c' # %a %b %e %H:%M:%S %Y + strftime_format('%a %b %e %H:%M:%S %Y') + when 'v' # %e-%^b-%Y (3-FEB-2001 format) + day_str = sprintf('%2d', tmx_mday) + month_str = (ABBR_MONTHNAMES[tmx_mon] || '?')[0, 3].upcase + year_str = sprintf('%04d', tmx_year) + "#{day_str}-#{month_str}-#{year_str}" + when '+' # %a %b %e %H:%M:%S %Z %Y + strftime_format('%a %b %e %H:%M:%S %Z %Y') + else + # Unknown specifiers are output as is. + "%#{spec}" + end + end + + def apply_width(str, width, flags, default_pad = ' ') + # '-' flag means no padding at all + return str if flags.include?('-') + return str if str.length >= width + + # Determine a padding character. + padding = + if flags.include?('0') + '0' + elsif flags.include?('_') + ' ' + else + default_pad + end + + str.rjust(width, padding) + end + + # C: format %z with width/flags/colons support + # Matches date_strftime.c case 'z' logic exactly. + def format_z(offset, width_str, flags, colons) + sign = offset < 0 ? '-' : '+' + aoff = offset.abs + hours = aoff / 3600 + minutes = (aoff % 3600) / 60 + seconds = aoff % 60 + + hl = hours < 10 ? 1 : 2 # actual digits needed for hours + hw = 2 # default hour width + hw = 1 if flags.include?('-') && hl == 1 + + precision = width_str.empty? ? -1 : width_str.to_i + + # Calculate fixed chars (everything except hour digits) per colons variant + fixed = case colons + when 0 then 3 # sign(1) + mm(2) + when 1 then 4 # sign(1) + :(1) + mm(2) + when 2 then 7 # sign(1) + :(1) + mm(2) + :(1) + ss(2) + when 3 + if (aoff % 3600).zero? + 1 # sign(1) only + elsif (aoff % 60).zero? + 4 # sign(1) + :(1) + mm(2) + else + 7 # sign(1) + :(1) + mm(2) + :(1) + ss(2) + end + else + 3 + end + + # C: hour_precision = precision <= (fixed + hw) ? hw : precision - fixed + hp = precision <= (fixed + hw) ? hw : precision - fixed + + result = String.new + + # C: space padding — print spaces before sign, reduce hour precision + if flags.include?('_') && hp > hl + result << ' ' * (hp - hl) + hp = hl + end + + result << sign + result << sprintf("%0#{hp}d", hours) + + # Append minutes/seconds based on colons + case colons + when 0 + result << sprintf('%02d', minutes) + when 1 + result << sprintf(':%02d', minutes) + when 2 + result << sprintf(':%02d:%02d', minutes, seconds) + when 3 + unless (aoff % 3600).zero? + result << sprintf(':%02d', minutes) + unless (aoff % 60).zero? + result << sprintf(':%02d', seconds) + end + end + end + + result + end + + def jd_to_unix_time(jd) + unix_epoch_jd = 2440588 + (jd - unix_epoch_jd) * DAY_IN_SECONDS + end +end diff --git a/lib/date/strptime.rb b/lib/date/strptime.rb new file mode 100644 index 00000000..e73bfc55 --- /dev/null +++ b/lib/date/strptime.rb @@ -0,0 +1,769 @@ +# frozen_string_literal: true + +# Implementation of ruby/date/ext/date/date_strptime.c +class Date + class << self + # call-seq: + # Date._strptime(string, format = '%F') -> hash + # + # Returns a hash of values parsed from +string+ + # according to the given +format+: + # + # Date._strptime('2001-02-03', '%Y-%m-%d') # => {:year=>2001, :mon=>2, :mday=>3} + # + # For other formats, see + # {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]. + # (Unlike Date.strftime, does not support flags and width.) + # + # See also {strptime(3)}[https://man7.org/linux/man-pages/man3/strptime.3.html]. + # + # Related: Date.strptime (returns a \Date object). + def _strptime(string, format = '%F') + str = string.dup + pos = 0 + hash = {} + + i = 0 + while i < format.length + if format[i] == '%' && i + 1 < format.length + i += 1 + + # Parse modifier (E, O) + modifier = nil + if i < format.length && (format[i] == 'E' || format[i] == 'O') + modifier = format[i] + i += 1 + end + + # Parse colons for %:z, %::z, %:::z + colons = 0 + while i < format.length && format[i] == ':' + colons += 1 + i += 1 + end + + # Parse width + width_str = String.new + while i < format.length && format[i] =~ /[0-9]/ + width_str << format[i] + i += 1 + end + + break if i >= format.length + + spec = format[i] + i += 1 + + # Handle E/O modifier validity + if modifier + valid = case modifier + when 'E' + %w[c C x X y Y].include?(spec) + when 'O' + %w[d e H I m M S u U V w W y].include?(spec) + else + false + end + unless valid + # Invalid modifier - try to match literal + literal = "%#{modifier}#{':' * colons}#{width_str}#{spec}" + if str[pos, literal.length] == literal + pos += literal.length + else + return nil + end + next + end + end + + # Handle colon+z + if colons > 0 && spec == 'z' + result = _strptime_zone_colon(str, pos, colons) + return nil unless result + pos = result[:pos] + hash[:zone] = result[:zone] + hash[:offset] = result[:offset] + next + elsif colons > 0 + # Invalid colon usage + return nil + end + + # Determine field width + field_width = width_str.empty? ? nil : width_str.to_i + + # C: NUM_PATTERN_P() - check if next format element is a digit-consuming pattern. + # Used by %C, %G, %L, %N, %Y to limit digit consumption when adjacent. + next_is_num = num_pattern_p(format, i) + + result = _strptime_spec(str, pos, spec, field_width, hash, next_is_num) + return nil unless result + pos = result[:pos] + hash.merge!(result[:hash]) if result[:hash] + elsif format[i] == '%' && i + 1 == format.length + # Trailing % - match literal + if pos < str.length && str[pos] == '%' + pos += 1 + else + return nil + end + i += 1 + elsif format[i] =~ /\s/ + # Whitespace in format matches zero or more whitespace in input + i += 1 + pos += 1 while pos < str.length && str[pos] =~ /\s/ + else + # Literal match + if pos < str.length && str[pos] == format[i] + pos += 1 + else + return nil + end + i += 1 + end + end + + # Store leftover if any + if pos < str.length + hash[:leftover] = str[pos..] + end + + # --- Post-processing (C: date__strptime, date_strptime.c:524-546) --- + + # C: cent = del_hash("_cent"); + # Apply _cent to both cwyear and year. + # Note: The inline _century approach in %C/%y/%g handlers covers most + # cases, but this post-processing ensures correctness for all orderings + # and applies century to both year and cwyear simultaneously. + # We delete _century and _century_set here to keep the hash clean, + # matching C's del_hash("_cent") behavior. + hash.delete(:_century) + hash.delete(:_century_set) + + # C: merid = del_hash("_merid"); + # Apply _merid to hour: hour = (hour % 12) + merid + # This handles both %I (12-hour) and %H (24-hour) correctly: + # %I=12 + AM(0) → (12 % 12) + 0 = 0 + # %I=12 + PM(12) → (12 % 12) + 12 = 12 + # %I=4 + PM(12) → (4 % 12) + 12 = 16 + # %I=4 + AM(0) → (4 % 12) + 0 = 4 + merid = hash.delete(:_merid) + if merid + hour = hash[:hour] + if hour + hash[:hour] = (hour % 12) + merid + end + end + + hash + end + + # call-seq: + # Date.strptime(string = '-4712-01-01', format = '%F', start = Date::ITALY) -> date + # + # Returns a new \Date object with values parsed from +string+, + # according to the given +format+: + # + # Date.strptime('2001-02-03', '%Y-%m-%d') # => # + # Date.strptime('03-02-2001', '%d-%m-%Y') # => # + # Date.strptime('2001-034', '%Y-%j') # => # + # Date.strptime('2001-W05-6', '%G-W%V-%u') # => # + # Date.strptime('2001 04 6', '%Y %U %w') # => # + # Date.strptime('2001 05 6', '%Y %W %u') # => # + # Date.strptime('sat3feb01', '%a%d%b%y') # => # + # + # For other formats, see + # {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]. + # (Unlike Date.strftime, does not support flags and width.) + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + # See also {strptime(3)}[https://man7.org/linux/man-pages/man3/strptime.3.html]. + # + # Related: Date._strptime (returns a hash). + def strptime(string = JULIAN_EPOCH_DATE, format = '%F', start = DEFAULT_SG) + hash = _strptime(string, format) + raise Error, "invalid strptime format - `#{format}'" unless hash + + # Apply comp for 2-digit year + if hash[:year] && !hash[:_century_set] + # If year came from %y (2-digit), comp_year69 was already applied + end + + new_by_frags(hash, start) + end + + private + + # C: num_pattern_p (date_strptime.c:48) + # Returns true if the format string at position `i` starts with a + # digit-consuming pattern (a literal digit or a %-specifier that reads digits). + def num_pattern_p(format, i) + return false if i >= format.length + c = format[i] + return true if c =~ /\d/ + if c == '%' + i += 1 + return false if i >= format.length + # Skip E/O modifier + if format[i] == 'E' || format[i] == 'O' + i += 1 + return false if i >= format.length + end + s = format[i] + return true if s =~ /\d/ || NUM_PATTERN_SPECS.include?(s) + end + false + end + + def _strptime_spec(str, pos, spec, width, context_hash, next_is_num = false) + h = {} + + case spec + when 'Y' # Full year (possibly negative) + # C: if (NUM_PATTERN_P()) READ_DIGITS(n, 4); else READ_DIGITS_MAX(n); + if width + w = width + elsif next_is_num + w = 4 + else + w = 40 # effectively unlimited + end + m = str[pos..].match(/\A([+-]?\d{1,#{w}})/) + return nil unless m + h[:year] = m[1].to_i + { pos: pos + m[0].length, hash: h } + + when 'C' # Century + # C: if (NUM_PATTERN_P()) READ_DIGITS(n, 2); else READ_DIGITS_MAX(n); + if width + w = width + elsif next_is_num + w = 2 + else + w = 40 + end + m = str[pos..].match(/\A([+-]?\d{1,#{w}})/) + return nil unless m + century = m[1].to_i + h[:_century] = century + if context_hash[:year] && !context_hash[:_century_set] + h[:year] = century * 100 + (context_hash[:year] % 100) + h[:_century_set] = true + end + { pos: pos + m[0].length, hash: h } + + when 'y' # 2-digit year + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + y = m[1].to_i + if context_hash[:_century] + h[:year] = context_hash[:_century] * 100 + y + h[:_century_set] = true + else + h[:year] = y >= 69 ? y + 1900 : y + 2000 + end + { pos: pos + m[0].length, hash: h } + + when 'm' # Month (01-12) + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + mon = m[1].to_i + return nil if mon < 1 || mon > 12 + h[:mon] = mon + { pos: pos + m[0].length, hash: h } + + when 'd', 'e' # Day of month + # C: if (str[si] == ' ') { si++; READ_DIGITS(n, 1); } else { READ_DIGITS(n, 2); } + if str[pos] == ' ' + m = str[pos + 1..].match(/\A(\d)/) + return nil unless m + day = m[1].to_i + return nil if day < 1 || day > 31 + h[:mday] = day + { pos: pos + 1 + m[0].length, hash: h } + else + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + day = m[1].to_i + return nil if day < 1 || day > 31 + h[:mday] = day + { pos: pos + m[0].length, hash: h } + end + + when 'j' # Day of year (001-366) + w = width || 3 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + yday = m[1].to_i + return nil if yday < 1 || yday > 366 + h[:yday] = yday + { pos: pos + m[0].length, hash: h } + + when 'H', 'k' # Hour (00-24) + # C: if (str[si] == ' ') { si++; READ_DIGITS(n, 1); } else { READ_DIGITS(n, 2); } + if str[pos] == ' ' + m = str[pos + 1..].match(/\A(\d)/) + return nil unless m + hour = m[1].to_i + return nil if hour > 24 + h[:hour] = hour + { pos: pos + 1 + m[0].length, hash: h } + else + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + hour = m[1].to_i + return nil if hour > 24 + h[:hour] = hour + { pos: pos + m[0].length, hash: h } + end + + when 'I', 'l' # Hour (01-12) + # C: if (str[si] == ' ') { si++; READ_DIGITS(n, 1); } else { READ_DIGITS(n, 2); } + if str[pos] == ' ' + m = str[pos + 1..].match(/\A(\d)/) + return nil unless m + hour = m[1].to_i + return nil if hour < 1 || hour > 12 + h[:hour] = hour + { pos: pos + 1 + m[0].length, hash: h } + else + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + hour = m[1].to_i + return nil if hour < 1 || hour > 12 + h[:hour] = hour # C stores raw value; _merid post-processing applies % 12 + { pos: pos + m[0].length, hash: h } + end + + when 'M' # Minute (00-59) + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + min = m[1].to_i + return nil if min > 59 + h[:min] = min + { pos: pos + m[0].length, hash: h } + + when 'S' # Second (00-60) + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + sec = m[1].to_i + return nil if sec > 60 + h[:sec] = sec + { pos: pos + m[0].length, hash: h } + + when 'L' # Milliseconds + # C: if (NUM_PATTERN_P()) READ_DIGITS(n, 3); else READ_DIGITS_MAX(n); + if width + w = width + elsif next_is_num + w = 3 + else + w = 40 + end + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + frac_str = m[1].ljust(3, '0')[0, 3] + h[:sec_fraction] = Rational(frac_str.to_i, 1000) + { pos: pos + m[0].length, hash: h } + + when 'N' # Nanoseconds + # C: if (NUM_PATTERN_P()) READ_DIGITS(n, 9); else READ_DIGITS_MAX(n); + if width + w = width + elsif next_is_num + w = 9 + else + w = 40 + end + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + frac_str = m[1].ljust(9, '0')[0, 9] + h[:sec_fraction] = Rational(frac_str.to_i, 1_000_000_000) + { pos: pos + m[0].length, hash: h } + + when 'p', 'P' # AM/PM + # C: set_hash("_merid", INT2FIX(hour)); + # Store _merid value (0 for AM, 12 for PM) for post-processing. + # This avoids order-dependency: %p can appear before or after %I/%H. + m = str[pos..].match(/\A(a\.?m\.?|p\.?m\.?)/i) + return nil unless m + ampm = m[1].delete('.').upcase + h[:_merid] = (ampm == 'PM') ? 12 : 0 + { pos: pos + m[0].length, hash: h } + + when 'A', 'a' # Day name (full or abbreviated) + DAYNAMES.each_with_index do |name, idx| + next unless name + # Try full name first, then abbreviated + [name, ABBR_DAYNAMES[idx]].each do |n| + next unless n + if str[pos, n.length]&.downcase == n.downcase + h[:wday] = idx + return { pos: pos + n.length, hash: h } + end + end + end + return nil + + when 'B', 'b', 'h' # Month name (full or abbreviated) + MONTHNAMES.each_with_index do |name, idx| + next unless name + # Try full name first, then abbreviated + [name, ABBR_MONTHNAMES[idx]].each do |n| + next unless n + if str[pos, n.length]&.downcase == n.downcase + h[:mon] = idx + return { pos: pos + n.length, hash: h } + end + end + end + return nil + + when 'w' # Weekday number (0-6, Sunday=0) + m = str[pos..].match(/\A(\d)/) + return nil unless m + wday = m[1].to_i + return nil if wday > 6 + h[:wday] = wday + { pos: pos + m[0].length, hash: h } + + when 'u' # Weekday number (1-7, Monday=1) + m = str[pos..].match(/\A(\d)/) + return nil unless m + cwday = m[1].to_i + return nil if cwday < 1 || cwday > 7 + h[:cwday] = cwday + { pos: pos + m[0].length, hash: h } + + when 'U' # Week number (Sunday start, 00-53) + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + wnum = m[1].to_i + return nil if wnum > 53 + h[:wnum0] = wnum + { pos: pos + m[0].length, hash: h } + + when 'W' # Week number (Monday start, 00-53) + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + wnum = m[1].to_i + return nil if wnum > 53 + h[:wnum1] = wnum + { pos: pos + m[0].length, hash: h } + + when 'V' # ISO week number (01-53) + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + cweek = m[1].to_i + return nil if cweek < 1 || cweek > 53 + h[:cweek] = cweek + { pos: pos + m[0].length, hash: h } + + when 'G' # ISO week year + # C: if (NUM_PATTERN_P()) READ_DIGITS(n, 4); else READ_DIGITS_MAX(n); + if width + w = width + elsif next_is_num + w = 4 + else + w = 40 + end + m = str[pos..].match(/\A([+-]?\d{1,#{w}})/) + return nil unless m + h[:cwyear] = m[1].to_i + { pos: pos + m[0].length, hash: h } + + when 'g' # ISO week year (2-digit) + w = width || 2 + m = str[pos..].match(/\A(\d{1,#{w}})/) + return nil unless m + y = m[1].to_i + if context_hash[:_century] + h[:cwyear] = context_hash[:_century] * 100 + y + h[:_century_set] = true + else + h[:cwyear] = y >= 69 ? y + 1900 : y + 2000 + end + { pos: pos + m[0].length, hash: h } + + when 'Z', 'z' # Timezone + result = _strptime_zone(str, pos) + return nil unless result + h[:zone] = result[:zone] + h[:offset] = result[:offset] unless result[:offset].nil? + { pos: result[:pos], hash: h } + + when 's' # Seconds since epoch + m = str[pos..].match(/\A([+-]?\d+)/) + return nil unless m + h[:seconds] = m[1].to_i + { pos: pos + m[0].length, hash: h } + + when 'Q' # Milliseconds since epoch + m = str[pos..].match(/\A([+-]?\d+)/) + return nil unless m + h[:seconds] = Rational(m[1].to_i, 1000) + { pos: pos + m[0].length, hash: h } + + when 'n' # Newline + m = str[pos..].match(/\A\s+/) + if m + { pos: pos + m[0].length, hash: h } + else + { pos: pos, hash: h } + end + + when 't' # Tab + m = str[pos..].match(/\A\s+/) + if m + { pos: pos + m[0].length, hash: h } + else + { pos: pos, hash: h } + end + + when '%' # Literal % + if pos < str.length && str[pos] == '%' + { pos: pos + 1, hash: h } + else + return nil + end + + when 'F' # %Y-%m-%d + result = _strptime_composite(str, pos, '%Y-%m-%d', context_hash) + return nil unless result + { pos: result[:pos], hash: result[:hash] } + + when 'D', 'x' # %m/%d/%y + result = _strptime_composite(str, pos, '%m/%d/%y', context_hash) + return nil unless result + { pos: result[:pos], hash: result[:hash] } + + when 'T', 'X' # %H:%M:%S + result = _strptime_composite(str, pos, '%H:%M:%S', context_hash) + return nil unless result + { pos: result[:pos], hash: result[:hash] } + + when 'R' # %H:%M + result = _strptime_composite(str, pos, '%H:%M', context_hash) + return nil unless result + { pos: result[:pos], hash: result[:hash] } + + when 'r' # %I:%M:%S %p + result = _strptime_composite(str, pos, '%I:%M:%S %p', context_hash) + return nil unless result + { pos: result[:pos], hash: result[:hash] } + + when 'c' # %a %b %e %H:%M:%S %Y + result = _strptime_composite(str, pos, '%a %b %e %H:%M:%S %Y', context_hash) + return nil unless result + { pos: result[:pos], hash: result[:hash] } + + when 'v' # %e-%b-%Y + result = _strptime_composite(str, pos, '%e-%b-%Y', context_hash) + return nil unless result + { pos: result[:pos], hash: result[:hash] } + + when '+' # %a %b %e %H:%M:%S %Z %Y + result = _strptime_composite(str, pos, '%a %b %e %H:%M:%S %Z %Y', context_hash) + return nil unless result + { pos: result[:pos], hash: result[:hash] } + + else + # Unknown specifier - try to match literal + literal = "%#{spec}" + if str[pos, literal.length] == literal + { pos: pos + literal.length, hash: h } + else + return nil + end + end + end + + def _strptime_composite(str, pos, format, context_hash) + merged_hash = context_hash.dup + i = 0 + while i < format.length + if format[i] == '%' && i + 1 < format.length + i += 1 + spec = format[i] + i += 1 + result = _strptime_spec(str, pos, spec, nil, merged_hash) + return nil unless result + pos = result[:pos] + merged_hash.merge!(result[:hash]) if result[:hash] + elsif format[i] =~ /\s/ + i += 1 + pos += 1 while pos < str.length && str[pos] =~ /\s/ + else + if pos < str.length && str[pos] == format[i] + pos += 1 + else + return nil + end + i += 1 + end + end + # Return only newly parsed keys + new_hash = {} + merged_hash.each { |k, v| new_hash[k] = v unless context_hash.key?(k) && context_hash[k] == v } + # Ensure updated values are included + merged_hash.each { |k, v| new_hash[k] = v if context_hash[k] != v } + { pos: pos, hash: new_hash } + end + + def _strptime_zone(str, pos) + remaining = str[pos..] + return nil if remaining.nil? || remaining.empty? + + # Try numeric timezone: +HH:MM, -HH:MM, +HH:MM:SS, -HH:MM:SS, +HHMM, -HHMM, +HH, -HH + # Also: GMT+HH, GMT-HH:MM, etc. and decimal offsets + # Colon-separated pattern (requires colon) tried first, then plain digits. + m = remaining.match(/\A( + (?:GMT|UTC)? + [+-] + (?:\d{1,2}:\d{2}(?::\d{2})? + | + \d+(?:[.,]\d+)?) + )/xi) + + if m + zone_str = m[1] + offset = _parse_zone_offset(zone_str) + return { pos: pos + zone_str.length, zone: zone_str, offset: offset } + end + + # Try named timezone (multi-word: "E. Australia Standard Time", "Mountain Daylight Time") + # Match alphabetic words with dots and spaces + m = remaining.match(/\A([A-Za-z][A-Za-z.]*(?:\s+[A-Za-z][A-Za-z.]*)*)/i) + if m + zone_candidate = m[1] + # Try progressively shorter matches (longest first) + words = zone_candidate.split(/\s+/) + (words.length).downto(1) do |n| + try_zone = words[0, n].join(' ') + offset = _zone_name_to_offset(try_zone) + if offset + # Compute actual consumed length preserving original spacing + if n == words.length + actual_zone = zone_candidate + else + # Find end of nth word in original string + end_pos = 0 + n.times do |wi| + end_pos = zone_candidate.index(words[wi], end_pos) + end_pos += words[wi].length + end + actual_zone = zone_candidate[0, end_pos] + end + return { pos: pos + actual_zone.length, zone: actual_zone, offset: offset } + end + end + # Unknown timezone - return full match with nil offset + # (Military single-letter zones like 'z' are already in ZONE_TABLE + # and handled by the loop above) + return { pos: pos + zone_candidate.length, zone: zone_candidate, offset: nil } + end + + nil + end + + def _strptime_zone_colon(str, pos, colons) + remaining = str[pos..] + return nil if remaining.nil? || remaining.empty? + + case colons + when 1 # %:z -> +HH:MM + m = remaining.match(/\A([+-])(\d{2}):(\d{2})/) + return nil unless m + sign = m[1] == '-' ? -1 : 1 + offset = sign * (m[2].to_i * 3600 + m[3].to_i * 60) + zone = m[0] + { pos: pos + zone.length, zone: zone, offset: offset } + when 2 # %::z -> +HH:MM:SS + m = remaining.match(/\A([+-])(\d{2}):(\d{2}):(\d{2})/) + return nil unless m + sign = m[1] == '-' ? -1 : 1 + offset = sign * (m[2].to_i * 3600 + m[3].to_i * 60 + m[4].to_i) + zone = m[0] + { pos: pos + zone.length, zone: zone, offset: offset } + when 3 # %:::z -> +HH[:MM[:SS]] + m = remaining.match(/\A([+-])(\d{2})(?::(\d{2})(?::(\d{2}))?)?/) + return nil unless m + sign = m[1] == '-' ? -1 : 1 + offset = sign * (m[2].to_i * 3600 + (m[3] ? m[3].to_i * 60 : 0) + (m[4] ? m[4].to_i : 0)) + zone = m[0] + { pos: pos + zone.length, zone: zone, offset: offset } + else + nil + end + end + + def _parse_zone_offset(zone_str) + # Strip GMT/UTC prefix + s = zone_str.sub(/\A(?:GMT|UTC)/i, '') + return 0 if s.empty? + + m = s.match(/\A([+-])(\d+(?:[.,]\d+)?)$/) + if m + sign = m[1] == '-' ? -1 : 1 + num = m[2].tr(',', '.') + if num.include?('.') + # Decimal hours + hours = num.to_f + return nil if hours.abs >= 24 + return sign * (hours * 3600).to_i + else + # Could be HH, HHMM, or HHMMSS + digits = num + case digits.length + when 1, 2 + h = digits.to_i + return nil if h >= 24 + return sign * h * 3600 + when 3, 4 + h = digits[0, 2].to_i + min = digits[2, 2].to_i + return nil if h >= 24 || min >= 60 + return sign * (h * 3600 + min * 60) + when 5, 6 + h = digits[0, 2].to_i + min = digits[2, 2].to_i + sec = digits[4, 2].to_i + return nil if h >= 24 || min >= 60 || sec >= 60 + return sign * (h * 3600 + min * 60 + sec) + else + return nil + end + end + end + + # +HH:MM or +HH:MM:SS + m = s.match(/\A([+-])(\d{1,2}):(\d{2})(?::(\d{2}))?$/) + if m + sign = m[1] == '-' ? -1 : 1 + h = m[2].to_i + min = m[3].to_i + sec = m[4] ? m[4].to_i : 0 + return nil if h >= 24 || min >= 60 || sec >= 60 + return sign * (h * 3600 + min * 60 + sec) + end + + nil + end + + def _zone_name_to_offset(name) + ZONE_TABLE[name.downcase.gsub(/\s+/, ' ')] + end + end +end diff --git a/lib/date/time.rb b/lib/date/time.rb new file mode 100644 index 00000000..3b73236b --- /dev/null +++ b/lib/date/time.rb @@ -0,0 +1,59 @@ +# frozen_string_literal: true + +class Time + def to_time + self + end unless method_defined?(:to_time) + + def to_date + y = year + m = month + d = day + + nth, ry = Date.send(:decode_year, y, -1) + + # First, create it in GREGORIAN (dates during the reform period are also valid). + obj = Date.send(:d_simple_new_internal, + nth, 0, + Date::GREGORIAN, + ry, m, d, + 0x04) # Date::HAVE_CIVIL + + # Then change to DEFAULT_SG. + obj.send(:set_sg, Date::ITALY) + + obj + end unless method_defined?(:to_date) + + def to_datetime + y = year + m = month + d = day + h = hour + mi = min + s = sec + of_sec = utc_offset + sf = nsec + + nth, ry = Date.send(:decode_year, y, -1) + rjd, _ = Date.send(:c_civil_to_jd, ry, m, d, Date::GREGORIAN) + + df = h * 3600 + mi * 60 + s + + # Convert local to UTC + df_utc = df - of_sec + jd_utc = rjd + if df_utc < 0 + jd_utc -= 1 + df_utc += 86400 + elsif df_utc >= 86400 + jd_utc += 1 + df_utc -= 86400 + end + + obj = DateTime.send(:new_with_jd_and_time, nth, jd_utc, df_utc, sf, of_sec, Date::GREGORIAN) + obj.send(:set_sg, Date::ITALY) + + obj + end unless method_defined?(:to_datetime) +end diff --git a/lib/date/version.rb b/lib/date/version.rb new file mode 100644 index 00000000..063fe245 --- /dev/null +++ b/lib/date/version.rb @@ -0,0 +1,5 @@ +# frozen_string_literal: true + +class Date + VERSION = "3.5.1" # :nodoc: +end diff --git a/lib/date/zonetab.rb b/lib/date/zonetab.rb new file mode 100644 index 00000000..c26262f0 --- /dev/null +++ b/lib/date/zonetab.rb @@ -0,0 +1,405 @@ +# frozen_string_literal: true + +# Timezone name => UTC offset (seconds) mapping table +# Converted C's zonetab.h (gperf-generated hash table) to a Ruby hash. +# 316 zones in total. +# Search ignores case (.downcase on the caller before searching). +# +# Original data source: zonetab.h #included in date_parse.c +# gperf --ignore-case -L ANSI-C -C -c -P -p -j1 -i 1 -g -o -t \ +# -N zonetab zonetab.list +# The complete static hash table generated by was converted equivalently to a Ruby hash. +class Date + ZONE_TABLE = { + "a" => 3600, + "acdt" => 37800, + "acst" => 34200, + "act" => -18000, + "acwst" => 31500, + "adt" => -10800, + "aedt" => 39600, + "aest" => 36000, + "afghanistan" => 16200, + "aft" => 16200, + "ahst" => -36000, + "akdt" => -28800, + "akst" => -32400, + "alaskan" => -32400, + "almt" => 21600, + "anast" => 43200, + "anat" => 43200, + "aoe" => -43200, + "aqtt" => 18000, + "arab" => 10800, + "arabian" => 14400, + "arabic" => 10800, + "art" => -10800, + "ast" => -14400, + "at" => -7200, + "atlantic" => -14400, + "aus central" => 34200, + "aus eastern" => 36000, + "awdt" => 32400, + "awst" => 28800, + "azores" => -3600, + "azost" => 0, + "azot" => -3600, + "azst" => 18000, + "azt" => 14400, + "b" => 7200, + "bnt" => 28800, + "bot" => -14400, + "brst" => -7200, + "brt" => -10800, + "bst" => 3600, + "bt" => 10800, + "btt" => 21600, + "c" => 10800, + "canada central" => -21600, + "cape verde" => -3600, + "cast" => 28800, + "cat" => 7200, + "caucasus" => 14400, + "cct" => 23400, + "cdt" => -18000, + "cen. australia" => 34200, + "central" => -21600, + "central america" => -21600, + "central asia" => 21600, + "central europe" => 3600, + "central european" => 3600, + "central pacific" => 39600, + "cest" => 7200, + "cet" => 3600, + "chadt" => 49500, + "chast" => 45900, + "china" => 28800, + "chost" => 32400, + "chot" => 28800, + "chst" => 36000, + "chut" => 36000, + "cidst" => -14400, + "cist" => -18000, + "ckt" => -36000, + "clst" => -10800, + "clt" => -14400, + "cot" => -18000, + "cst" => -21600, + "cvt" => -3600, + "cxt" => 25200, + "d" => 14400, + "dateline" => -43200, + "davt" => 25200, + "ddut" => 36000, + "e" => 18000, + "e. africa" => 10800, + "e. australia" => 36000, + "e. europe" => 7200, + "e. south america" => -10800, + "eadt" => 39600, + "easst" => -18000, + "east" => -21600, + "eastern" => -18000, + "eat" => 10800, + "ect" => -18000, + "edt" => -14400, + "eest" => 10800, + "eet" => 7200, + "egst" => 0, + "egt" => -3600, + "egypt" => 7200, + "ekaterinburg" => 18000, + "est" => -18000, + "f" => 21600, + "fet" => 10800, + "fiji" => 43200, + "fjst" => 46800, + "fjt" => 43200, + "fkst" => -10800, + "fkt" => -14400, + "fle" => 7200, + "fnt" => -7200, + "fst" => 7200, + "fwt" => 3600, + "g" => 25200, + "galt" => -21600, + "gamt" => -32400, + "get" => 14400, + "gft" => -10800, + "gilt" => 43200, + "gmt" => 0, + "greenland" => -10800, + "greenwich" => 0, + "gst" => 36000, + "gtb" => 7200, + "gyt" => -14400, + "h" => 28800, + "hadt" => -32400, + "hast" => -36000, + "hawaiian" => -36000, + "hdt" => -32400, + "hkt" => 28800, + "hovst" => 28800, + "hovt" => 25200, + "hst" => -36000, + "i" => 32400, + "ict" => 25200, + "idle" => 43200, + "idlw" => -43200, + "idt" => 10800, + "india" => 19800, + "iot" => 21600, + "iran" => 12600, + "irdt" => 16200, + "irkst" => 32400, + "irkt" => 28800, + "irst" => 12600, + "ist" => 19800, + "jerusalem" => 7200, + "jst" => 32400, + "k" => 36000, + "kgt" => 21600, + "korea" => 32400, + "kost" => 39600, + "krast" => 28800, + "krat" => 25200, + "kst" => 32400, + "kuyt" => 14400, + "l" => 39600, + "lhdt" => 39600, + "lhst" => 37800, + "lint" => 50400, + "m" => 43200, + "magst" => 43200, + "magt" => 39600, + "malay peninsula" => 28800, + "mart" => -30600, + "mawt" => 18000, + "mdt" => -21600, + "mest" => 7200, + "mesz" => 7200, + "met" => 3600, + "mewt" => 3600, + "mexico" => -21600, + "mez" => 3600, + "mht" => 43200, + "mid-atlantic" => -7200, + "mmt" => 23400, + "mountain" => -25200, + "msd" => 14400, + "msk" => 10800, + "mst" => -25200, + "mut" => 14400, + "mvt" => 18000, + "myanmar" => 23400, + "myt" => 28800, + "n" => -3600, + "n. central asia" => 21600, + "nct" => 39600, + "ndt" => -5400, + "nepal" => 20700, + "new zealand" => 43200, + "newfoundland" => -12600, + "nfdt" => 43200, + "nft" => 39600, + "north asia" => 25200, + "north asia east" => 28800, + "novst" => 25200, + "novt" => 25200, + "npt" => 20700, + "nrt" => 43200, + "nst" => -9000, + "nt" => -39600, + "nut" => -39600, + "nzdt" => 46800, + "nzst" => 43200, + "nzt" => 43200, + "o" => -7200, + "omsst" => 25200, + "omst" => 21600, + "orat" => 18000, + "p" => -10800, + "pacific" => -28800, + "pacific sa" => -14400, + "pdt" => -25200, + "pet" => -18000, + "petst" => 43200, + "pett" => 43200, + "pgt" => 36000, + "phot" => 46800, + "pht" => 28800, + "pkt" => 18000, + "pmdt" => -7200, + "pmst" => -10800, + "pont" => 39600, + "pst" => -28800, + "pwt" => 32400, + "pyst" => -10800, + "q" => -14400, + "qyzt" => 21600, + "r" => -18000, + "ret" => 14400, + "romance" => 3600, + "rott" => -10800, + "russian" => 10800, + "s" => -21600, + "sa eastern" => -10800, + "sa pacific" => -18000, + "sa western" => -14400, + "sakt" => 39600, + "samoa" => -39600, + "samt" => 14400, + "sast" => 7200, + "sbt" => 39600, + "sct" => 14400, + "se asia" => 25200, + "sgt" => 28800, + "south africa" => 7200, + "sret" => 39600, + "sri lanka" => 21600, + "srt" => -10800, + "sst" => -39600, + "swt" => 3600, + "syot" => 10800, + "t" => -25200, + "taht" => -36000, + "taipei" => 28800, + "tasmania" => 36000, + "tft" => 18000, + "tjt" => 18000, + "tkt" => 46800, + "tlt" => 32400, + "tmt" => 18000, + "tokyo" => 32400, + "tonga" => 46800, + "tost" => 50400, + "tot" => 46800, + "trt" => 10800, + "tvt" => 43200, + "u" => -28800, + "ulast" => 32400, + "ulat" => 28800, + "us eastern" => -18000, + "us mountain" => -25200, + "ut" => 0, + "utc" => 0, + "uyst" => -7200, + "uyt" => -10800, + "uzt" => 18000, + "v" => -32400, + "vet" => -14400, + "vladivostok" => 36000, + "vlast" => 39600, + "vlat" => 36000, + "vost" => 21600, + "vut" => 39600, + "w" => -36000, + "w. australia" => 28800, + "w. central africa" => 3600, + "w. europe" => 3600, + "wadt" => 28800, + "wakt" => 43200, + "warst" => -10800, + "wast" => 7200, + "wat" => 3600, + "west" => 3600, + "west asia" => 18000, + "west pacific" => 36000, + "wet" => 0, + "wft" => 43200, + "wgst" => -3600, + "wgt" => -7200, + "wib" => 25200, + "wit" => 32400, + "wita" => 28800, + "wt" => 0, + "x" => -39600, + "y" => -43200, + "yakst" => 36000, + "yakt" => 32400, + "yakutsk" => 32400, + "yapt" => 36000, + "ydt" => -28800, + "yekst" => 21600, + "yekt" => 18000, + "yst" => -32400, + "z" => 0, + "zp4" => 14400, + "zp5" => 18000, + "zp6" => 21600, + # Multi-word timezone names from C's zonetab.list + "met dst" => 7200, + "mountain standard time" => -25200, + "mountain daylight time" => -21600, + "pacific standard time" => -28800, + "pacific daylight time" => -25200, + "eastern standard time" => -18000, + "eastern daylight time" => -14400, + "central standard time" => -21600, + "central daylight time" => -18000, + "atlantic standard time" => -14400, + "atlantic daylight time" => -10800, + "e. australia standard time" => 36000, + "cen. australia standard time" => 34200, + "w. australia standard time" => 28800, + "dateline standard time" => -43200, + "fiji standard time" => 43200, + "samoa standard time" => -39600, + "new zealand standard time" => 43200, + "taipei standard time" => 28800, + "tokyo standard time" => 32400, + "china standard time" => 28800, + "india standard time" => 19800, + "korea standard time" => 32400, + "singapore standard time" => 28800, + "north asia standard time" => 25200, + "north asia east standard time" => 28800, + "se asia standard time" => 25200, + "west asia standard time" => 18000, + "romance standard time" => 3600, + "russian standard time" => 10800, + "us eastern standard time" => -18000, + "us mountain standard time" => -25200, + "sa western standard time" => -14400, + "sa pacific standard time" => -18000, + "sa eastern standard time" => -10800, + "e. south america standard time" => -10800, + "greenland standard time" => -10800, + "mid-atlantic standard time" => -7200, + "azores standard time" => -3600, + "cape verde standard time" => -3600, + "gmt standard time" => 0, + "greenwich standard time" => 0, + "w. europe standard time" => 3600, + "central europe standard time" => 3600, + "central european standard time" => 3600, + "gtb standard time" => 7200, + "e. europe standard time" => 7200, + "egypt standard time" => 7200, + "south africa standard time" => 7200, + "fle standard time" => 7200, + "israel standard time" => 7200, + "arabian standard time" => 14400, + "arab standard time" => 10800, + "e. africa standard time" => 10800, + "iran standard time" => 12600, + "west pacific standard time" => 36000, + "aus central standard time" => 34200, + "aus eastern standard time" => 36000, + "central pacific standard time" => 39600, + "tasmania standard time" => 36000, + "canada central standard time" => -21600, + "mexico standard time" => -21600, + "mexico standard time 2" => -25200, + "central america standard time" => -21600, + "nepal standard time" => 20700, + "sri lanka standard time" => 21600, + "n. central asia standard time" => 21600, + "central asia standard time" => 21600, + "afghanistan standard time" => 16200, + "ekaterinburg standard time" => 18000, + "alaska standard time" => -32400, + "alaska daylight time" => -28800, + "hawaii standard time" => -36000, + }.freeze +end From 0cdfd42220808c6759e3c24d48c23c2a612641be Mon Sep 17 00:00:00 2001 From: jinroq Date: Sun, 15 Feb 2026 16:02:25 +0900 Subject: [PATCH 02/11] Put `# encoding: US-ASCII` at the beginning. --- lib/date/constants.rb | 15 ++++++--------- 1 file changed, 6 insertions(+), 9 deletions(-) diff --git a/lib/date/constants.rb b/lib/date/constants.rb index d9db674b..11bdb961 100644 --- a/lib/date/constants.rb +++ b/lib/date/constants.rb @@ -1,3 +1,4 @@ +# encoding: US-ASCII # frozen_string_literal: true # Constants @@ -10,15 +11,11 @@ class Date private_constant :HAVE_JD, :HAVE_DF, :HAVE_CIVIL, :HAVE_TIME, :COMPLEX_DAT MONTHNAMES = [nil, "January", "February", "March", "April", "May", "June", - "July", "August", "September", "October", "November", "December"] - .map { |s| s&.encode(Encoding::US_ASCII)&.freeze }.freeze + "July", "August", "September", "October", "November", "December"].freeze ABBR_MONTHNAMES = [nil, "Jan", "Feb", "Mar", "Apr", "May", "Jun", - "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"] - .map { |s| s&.encode(Encoding::US_ASCII)&.freeze }.freeze - DAYNAMES = %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday] - .map { |s| s.encode(Encoding::US_ASCII).freeze }.freeze - ABBR_DAYNAMES = %w[Sun Mon Tue Wed Thu Fri Sat] - .map { |s| s.encode(Encoding::US_ASCII).freeze }.freeze + "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"].freeze + DAYNAMES = %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday].freeze + ABBR_DAYNAMES = %w[Sun Mon Tue Wed Thu Fri Sat].freeze # Pattern constants for regex ABBR_DAYS_PATTERN = 'sun|mon|tue|wed|thu|fri|sat' @@ -149,7 +146,7 @@ class Date private_constant :HAVE_ALPHA, :HAVE_DIGIT, :HAVE_DASH, :HAVE_DOT, :HAVE_SLASH # C: default strftime format is US-ASCII - STRFTIME_DEFAULT_FMT = '%F'.encode(Encoding::US_ASCII) + STRFTIME_DEFAULT_FMT = '%F' private_constant :STRFTIME_DEFAULT_FMT # strftime spec categories From 802e0c2e1b3a259332016191f8de87d45fcd9f64 Mon Sep 17 00:00:00 2001 From: jinroq Date: Mon, 16 Feb 2026 00:36:49 +0900 Subject: [PATCH 03/11] Optimized methods MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit | Implementation | i/s | μs/i | | :--- | :--- | :--- | | System (C ext) | 347.5k | 2.88 | | Pre-optimization (pure Ruby) | 313.5k | 3.19 | | Post-optimization (pure Ruby) | 380.0k | 2.63 | | Implementation | i/s | μs/i | | :--- | :--- | :--- | | System (C ext) | 4.32M | 0.23 | | Pre-optimization (pure Ruby) | 312k | 3.20 | | Post-optimization (pure Ruby) | 1.67M | 0.60 | **5.4x speedup** (312k → 1.67M i/s). Reached approximately **39%** of the C extension's performance. | Implementation | i/s | | :--- | :--- | | System (C ext) | 4.50M | | Pre-optimization (pure Ruby) | 311k | | Post-optimization (pure Ruby) | 1.63M | For cases where the fast path is not applicable (e.g., Julian calendar or BCE years), performance remains equivalent to the previous implementation (no changes). The fast path is applied when all of the following conditions are met: 1. `year`, `month`, and `day` are all `Integer`. 2. The date is determined to be strictly Gregorian (e.g., `start` is `GREGORIAN`, or a reform date like `ITALY` with `year > 1930`). By satisfying these conditions, the implementation skips six `self.class.send` calls, `Hash` allocations, redundant `decode_year` calls, and repetitive array generation. | Implementation | i/s | | :--- | :--- | | System (C ext) | 9.58M | | Pre-optimization (pure Ruby) | 458k | | Post-optimization (pure Ruby) | 2.51M | **5.5x speedup** (458k → 2.51M i/s). Reached approximately **26%** of the C extension's performance. | Implementation | i/s | | :--- | :--- | | System (C ext) | 9.59M | | Pre-optimization (pure Ruby) | 574k | | Post-optimization (pure Ruby) | 2.53M | **4.4x speedup.** 1. **Added a Fast Path** — For `Integer` arguments and Gregorian calendar cases, the entire method chain of `numeric?` (called 3 times) and `valid_civil_sub` is skipped. Instead, month and day range checks are performed inline. 2. **Eliminated Repeated Array Allocation in `valid_civil_sub`** — Changed the implementation to reference a `MONTH_DAYS` constant instead of creating a new array `[nil, 31, 28, ...]` on every call. | Case | System (C ext) | Pre-optimization | Post-optimization | | :--- | :--- | :--- | :--- | | Date.jd | 4.12M | 462k | 1.18M | | Date.jd(0) | 4.20M | 467k | 1.19M | | Date.jd(JULIAN) | 4.09M | 468k | 1.22M | | Date.jd(GREG) | 4.07M | 467k | 1.21M | **Approximately 2.6x speedup** (462k → 1.18M i/s). Reached approximately **29%** of the C extension's performance. The fast path is effective across all `start` patterns (`ITALY` / `JULIAN` / `GREGORIAN`). The following processes are now skipped: - `valid_sg` + `c_valid_start_p` (numerous type checks) - `value_trunc` (array allocation for `Integer`) - `decode_jd` (array allocation for standard Julian Days) - `d_simple_new_internal` (`canon` + flag operations + method call overhead) | Case | System (C ext) | Pre-optimization | Post-optimization | Improvement | | :--- | :--- | :--- | :--- | :--- | | Date.ordinal | 2.66M | 170k | 645k | 3.8x | | Date.ordinal(-1) | 1.87M | 119k | 639k | 5.4x | | Date.ordinal(neg) | 3.08M | 107k | 106k | (Slow path) | **3.8x to 5.4x speedup** in cases where the fast path is applicable. Reached approximately **24% to 34%** of the C extension's performance. `Date.ordinal(neg)` remains on the slow path (equivalent to previous performance) because the year -4712 does not meet the fast path condition (`year > REFORM_END_YEAR`). | Case | System (C ext) | Pre-optimization | Post-optimization | Improvement | | :--- | :--- | :--- | :--- | :--- | | Date.commercial | 2.18M | 126k | 574k | 4.5x | | Date.commercial(-1) | 1.45M | 85k | 560k | 6.6x | | Date.commercial(neg) | 2.84M | 93k | 90k | (Slow path) | **4.5x to 6.6x speedup** in cases where the fast path is applicable. Reached approximately **26% to 39%** of the C extension's performance. Inlined the ISO week-to-JD conversion: 1. Obtain the JD for Jan 1 using `c_gregorian_civil_to_jd(year, 1, 1)` (requires only one method call). 2. Directly calculate `max_weeks` (52 or 53) from the ISO weekday to perform a week range check. 3. Calculate the Monday of Week 1 using: `base = (jd_jan1 + 3) - ((jd_jan1 + 3) % 7)`. 4. Directly calculate the JD using: `rjd = base + 7*(week-1) + (day-1)`. This bypasses the entire previous chain of `valid_commercial_p` → `c_valid_commercial_p` → `c_commercial_to_jd` → `c_jd_to_commercial` (verification via inverse conversion). | Case | System (C ext) | Pre-optimization | Post-optimization | Improvement | | :--- | :--- | :--- | :--- | :--- | | valid_ordinal? (true) | 3.76M | 221k | 3.38M | 15.3x | | valid_ordinal? (false) | 3.77M | 250k | 3.39M | 13.6x | | valid_ordinal? (-1) | 2.37M | 148k | 2.67M | 18.0x | **15x to 18x speedup.** Performance reached **90% to 112%** of the C extension, making it nearly equivalent or even slightly faster. Since `valid_ordinal?` does not require object instantiation and only involves leap year determination and day-of-year range checks, the inline cost of the fast path is extremely low, allowing it to rival the performance of the C extension. | Case | System (C ext) | Pre-optimization | Post-optimization | Improvement | | :--- | :--- | :--- | :--- | :--- | | valid_commercial? (true) | 2.94M | 167k | 1.09M | 6.5x | | valid_commercial? (false) | 3.56M | 218k | 1.08M | 5.0x | | valid_commercial? (-1) | 1.79M | 104k | 1.07M | 10.3x | **5x to 10x speedup.** Performance reached approximately **30% to 37%** of the C extension. The same ISO week validation logic used in the `Date.commercial` fast path (calculating `max_weeks` from the JD of Jan 1 and performing `cwday`/`cweek` range checks) has been inlined. The reason it does not rival the C extension as closely as `valid_ordinal?` is due to the remaining overhead of a single method call to `c_gregorian_civil_to_jd(year, 1, 1)`. | Method | i/s | | :--- | :--- | | Date.valid_jd? | 9.29M | | Date.valid_jd?(false) | 9.68M | It is approximately **3.3x faster** compared to the C extension benchmarks (Reference values: 2.93M / 2.80M). The simplification to only perform type checks has had a significant impact on performance. | Method | Pre-optimization | Post-optimization | Improvement | | :--- | :--- | :--- | :--- | | Date.gregorian_leap?(2000) | 1.40M | 7.39M | 5.3x | | Date.gregorian_leap?(1900) | 1.39M | 7.48M | 5.4x | It is approximately **4.5x faster** even when compared to the C extension reference values (1.69M / 1.66M). For `Integer` arguments, the implementation now performs the leap year determination inline, skipping three method calls: the `numeric?` check, `decode_year`, and `c_gregorian_leap_p?`. Non-`Integer` arguments (such as `Rational`) will fall back to the conventional path. | Method | Pre-optimization | Post-optimization | Improvement | | :--- | :--- | :--- | :--- | | Date.julian_leap? | 2.27M | 8.98M | 4.0x | It is approximately **3.2x faster** even when compared to the C extension reference value (2.80M). For `Integer` arguments, the implementation now skips calls to `numeric?`, `decode_year`, and `c_julian_leap_p?`, returning the result directly via an inline `year % 4 == 0` check. | Method | Pre-optimization | Post-optimization | Improvement | | :--- | :--- | :--- | :--- | | Date#year | 3.27M | 10.06M | 3.1x | It is approximately **2.8x faster** even when compared to the C extension reference value (3.65M). In cases where `@nth == 0 && @has_civil` (which covers almost all typical use cases), the implementation now skips the `m_year` → `simple_dat_p?` → `get_s_civil` method chain as well as `self.class.send(:f_zero_p?, nth)`, returning `@year` directly. Add early return in `m_mon` when `@has_civil` is already true, skipping `simple_dat_p?` check and `get_s_civil`/`get_c_civil` method call overhead. Same pattern as `m_real_year`. Benchmark results (Ruby 4.0.1, benchmark-ips): Date#month: C 21,314,867 ips -> Ruby 14,302,144 ips (67.1%) DateTime#month: C 20,843,168 ips -> Ruby 14,113,170 ips (67.7%) Add early return in `m_mday` when `@has_civil` is already true, skipping `simple_dat_p?` check and `get_s_civil`/`get_c_civil` method call overhead. Same pattern as `m_real_year` and `m_mon`. Benchmark results (Ruby 4.0.1, benchmark-ips): Date#day: C 18,415,779 ips -> Ruby 14,248,797 ips (77.4%) DateTime#day: C 18,758,870 ips -> Ruby 13,750,236 ips (73.3%) Add early return in `m_wday` when `@has_jd` is true and `@of` is nil (simple Date), inlining `(@jd + 1) % 7` directly. This skips `m_local_jd`, `get_s_jd`, `c_jd_to_wday` method call overhead. Benchmark results (Ruby 4.0.1, benchmark-ips): Date#wday: C 20,923,653 ips -> Ruby 11,174,133 ips (53.4%) DateTime#wday: C 20,234,376 ips -> Ruby 3,721,404 ips (18.4%) Note: DateTime#wday is not covered by this fast path since it requires offset-aware local JD calculation. Add fast path in `m_yday` for simple Date (`@of.nil?`) with `@has_civil` already computed. When the calendar is proleptic Gregorian or the date is well past the reform period, compute yday directly via `YEARTAB[month] + day`, skipping `m_local_jd`, `m_virtual_sg`, `m_year`, `m_mon`, `m_mday`, and other method call overhead. Benchmark results (Ruby 4.0.1, benchmark-ips): Date#yday: C 16,253,269 ips -> Ruby 1,942,757 ips (12.0%) DateTime#yday: C 14,927,308 ips -> Ruby 851,319 ips ( 5.7%) Note: DateTime#yday is not covered by this fast path since it requires offset-aware local JD calculation. Multiple optimizations to `Date#+` and its object creation path: 1. Eliminate `instance_variable_set` in `new_with_jd_and_time`: Replace 10 `instance_variable_set` calls with a protected `_init_with_jd` method using direct `@var =` assignment. Benefits all callers (Date#+, Date#-, Date#>>, DateTime#+, etc). 2. Avoid `self.class.send` overhead in `Date#+`: Replace `self.class.send(:new_with_jd, ...)` chain with direct `self.class.allocate` + `obj._init_with_jd(...)` (protected call). 3. Eager JD computation in `Date.civil` fast path: Compute JD via Neri-Schneider algorithm in `initialize` instead of deferring. Ensures `@has_jd = true` from creation, so `Date#+` always takes the fast `@has_jd` path. 4. Add `_init_simple_with_jd` with only 4 ivar assignments: For simple Date fast path, skip 7 nil assignments that `allocate` already provides as undefined (returns nil). 5. Fix fast path condition to handle `@has_civil` without `@has_jd`: When only civil data is available, compute JD inline via Neri-Schneider before addition. Benchmark results (Ruby 4.0.1, benchmark-ips): Date#+1: C 5,961,579 ips -> Ruby 3,150,254 ips (52.8%) Date#+100: C 6,054,311 ips -> Ruby 3,088,684 ips (51.0%) Date#-1: C 4,077,013 ips -> Ruby 2,488,817 ips (61.0%) Date#+1 progression: Before: 1,065,416 ips (17.9% of C) After ivar_set removal: 1,972,000 ips (33.1% of C) After send avoidance: 2,691,799 ips (45.2% of C) After eager JD + 4-ivar init: 3,150,254 ips (52.8% of C) Date#-1: C 4,077,013 ips -> Ruby 2,863,047 ips (70.2%) Date#-1 progression: Before: 989,991 ips (24.3% of C) After Date#+ optimization: 2,488,817 ips (61.0% of C) After Date#- fast path: 2,863,047 ips (70.2% of C) Date#<<1: C 2,214,936 ips -> Ruby 1,632,773 ips (73.7%) Date#<<1 progression: Before: 205,555 ips ( 9.3% of C) After Date#>> optimization: 1,574,551 ips (71.1% of C) After direct fast path: 1,632,773 ips (73.7% of C) - Ruby version: 4.0 (Docker) - C baseline: bench/results/20260215/4.0.1_system.tsv - Tool: benchmark-ips ┌──────────────┬─────────┬────────────┬─────────┐ │ Benchmark │ C (ips) │ Ruby (ips) │ Ruby/C │ ├──────────────┼─────────┼────────────┼─────────┤ │ Date#<<1 │ 2.21 M │ 1.62 M │ 1/1.4x │ ├──────────────┼─────────┼────────────┼─────────┤ │ DateTime#<<1 │ 2.13 M │ 177.53 K │ 1/12.0x │ └──────────────┴─────────┴────────────┴─────────┘ Changes: Replaced the slow path of Date#<< which delegated to self >> (-n) with an inlined version of Date#>>'s slow path logic. This eliminates the extra method call, sign negation, and redundant condition checks. - Date#<< (Date only): reaches 71% of C performance - DateTime#<< (with offset): remains at 1/12x due to the slow path being exercised more heavily - Ruby version: 4.0 (Docker) - C baseline: bench/results/20260215/4.0.1_system.tsv - Tool: benchmark-ips ┌──────────────┬─────────┬───────────────────┬──────────────────┬─────────┐ │ Benchmark │ C (ips) │ Ruby before (ips) │ Ruby after (ips) │ after/C │ ├──────────────┼─────────┼───────────────────┼──────────────────┼─────────┤ │ Date#<=> │ 11.84 M │ 635.23 K │ 2.99 M │ 1/4.0x │ ├──────────────┼─────────┼───────────────────┼──────────────────┼─────────┤ │ DateTime#<=> │ 12.24 M │ 622.88 K │ 577.00 K │ 1/21.2x │ └──────────────┴─────────┴───────────────────┴──────────────────┴─────────┘ Changes: Added a fast path to `Date#<=>` for the common case where both objects are simple Date instances (`@df`, `@sf`, `@of` are all `nil`) with `@nth == 0` and `@has_jd` set. In this case, the comparison reduces to a direct `@jd <=> other.@jd` integer comparison, eliminating two `m_canonicalize_jd` calls (each of which allocates a `[nth, jd]` array via `canonicalize_jd`), redundant `simple_dat_p?` checks, and chained accessor calls for `m_nth`, `m_jd`, `m_df`, and `m_sf`. - `Date#<=>` (Date only): 4.7x improvement over pre-optimization Ruby, reaches 75% of C performance - `DateTime#<=>` (with offset): unaffected — falls through to the existing slow path Benchmark: Date#== optimization (pure Ruby vs C) - Ruby version: 4.0 (Docker) - C baseline: bench/results/20260215/4.0.1_system.tsv - Tool: benchmark-ips ┌─────────────┬─────────┬───────────────────┬──────────────────┬─────────┐ │ Benchmark │ C (ips) │ Ruby before (ips) │ Ruby after (ips) │ after/C │ ├─────────────┼─────────┼───────────────────┼──────────────────┼─────────┤ │ Date#== │ 2.78 M │ 875.47 K │ 3.24 M │ 1.17x │ ├─────────────┼─────────┼───────────────────┼──────────────────┼─────────┤ │ DateTime#== │ 2.72 M │ 798.68 K │ 924.96 K │ 1/2.9x │ └─────────────┴─────────┴───────────────────┴──────────────────┴─────────┘ Changes: Added a fast path to `Date#==` for the common case where both objects are simple Date instances (`@df`, `@sf`, `@of` are all `nil`) with `@nth == 0` and `@has_jd` set. In this case, equality reduces to a direct `@jd == other.@jd` integer comparison. This eliminates two `m_canonicalize_jd` calls (each allocating a `[nth, jd]` array via `canonicalize_jd`), redundant `simple_dat_p?` checks, and chained accessor calls for `m_nth`, `m_jd`, `m_df`, and `m_sf`. - `Date#==` (Date only): 3.7x improvement over pre-optimization Ruby, 17% faster than C - `DateTime#==` (with offset): unaffected — falls through to the existing slow path Add fast paths that skip `m_canonicalize_jd` (which allocates an array) for the common case: both objects are simple (`@df`, `@sf`, `@of` are all `nil`), `@nth == 0`, `@has_jd` is true, and `0 <= @jd < CM_PERIOD` (guaranteeing that canonicalization is a no-op). For `Date#===`, whether the two dates are on the same calendar or not, the result always reduces to `@jd == other.@jd` under these conditions, so the `m_gregorian_p?` check and both `m_canonicalize_jd` calls are eliminated. For `Date#hash`, the same bounds guarantee that `m_nth == 0` and `m_jd == @jd` after canonicalization, so `[0, @jd, @sg].hash` is returned directly. | Method | Before | After | Speedup | C impl | |-------------|-------------|--------------|---------|--------------| | `Date#===` | ~558K ips | ~2,940K ips | +5.3x | ~12,659K ips | | `Date#hash` | ~1,990K ips | ~6,873K ips | +3.5x | ~13,833K ips | feat: Optimized `Date#<`. Add an explicit `Date#<` method with a fast path that bypasses the `Comparable` module overhead. When both objects are simple (`@df`, `@sf`, `@of` are all `nil`), `@nth == 0`, and `@has_jd` is true, `@jd < other.@jd` is returned directly without going through `<=>`. The slow path delegates to `super` (Comparable) to preserve all edge-case behavior including `ArgumentError` for incomparable types. | Method | Before | After | Speedup | C impl | |----------|-------------|-------------|---------|-------------| | `Date#<` | ~2,430K ips | ~3,330K ips | +37% | ~7,628K ips | Add an explicit `Date#>` method with a fast path that bypasses the `Comparable` module overhead. When both objects are simple (`@df`, `@sf`, `@of` are all `nil`), `@nth == 0`, and `@has_jd` is true, `@jd > other.@jd` is returned directly without going through `<=>`. The slow path delegates to `super` (Comparable) to preserve all edge-case behavior including `ArgumentError` for incomparable types. | Method | Before | After | Speedup | C impl | |----------|-------------|-------------|---------|-------------| | `Date#>` | ~2,560K ips | ~3,330K ips | +30% | ~7,682K ips | --- lib/date/constants.rb | 8 +- lib/date/core.rb | 540 +++++++++++++++++++++++++++++++++++++----- 2 files changed, 481 insertions(+), 67 deletions(-) diff --git a/lib/date/constants.rb b/lib/date/constants.rb index 11bdb961..2f7ca2ba 100644 --- a/lib/date/constants.rb +++ b/lib/date/constants.rb @@ -72,14 +72,14 @@ class Date # Days in each month (non-leap and leap year) MONTH_DAYS = [ - [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31], # non-leap - [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] # leap + [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze, # non-leap + [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze # leap ].freeze private_constant :MONTH_DAYS YEARTAB = [ - [0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334], # non-leap - [0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335] # leap + [0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334].freeze, # non-leap + [0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335].freeze # leap ].freeze private_constant :YEARTAB diff --git a/lib/date/core.rb b/lib/date/core.rb index 03b6d9cb..ff00087c 100644 --- a/lib/date/core.rb +++ b/lib/date/core.rb @@ -29,6 +29,50 @@ class Date # # Related: Date.jd. def initialize(year = -4712, month = 1, day = 1, start = DEFAULT_SG) + # Fast path: Integer arguments, Gregorian calendar + # Avoids self.class.send, Hash allocation, redundant decode_year + if year.is_a?(Integer) && year.abs < 579000 && month.is_a?(Integer) && day.is_a?(Integer) + gregorian_fast = if start.is_a?(Float) && start.infinite? + start < 0 # GREGORIAN (-Infinity) only + elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD + year > REFORM_END_YEAR + end + + if gregorian_fast + m = month + m += 13 if m < 0 + raise Error unless m >= 1 && m <= 12 + + leap = (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) + last = MONTH_DAYS[leap ? 1 : 0][m] + d = day + d = last + d + 1 if d < 0 + raise Error unless d >= 1 && d <= last + + j = (m < 3) ? 1 : 0 + y0 = year - j + m0 = j.nonzero? ? m + 12 : m + d0 = d - 1 + q1 = y0 / 100 + yc = (NS_DAYS_IN_4_YEARS * y0) / 4 - q1 + q1 / 4 + mc = (NS_DAYS_BEFORE_NEW_YEAR * m0 - 914) / 10 + + @nth = 0 + @jd = yc + mc + d0 + NS_EPOCH + @sg = start + @year = year + @month = m + @day = d + @has_jd = true + @has_civil = true + @df = nil + @sf = nil + @of = nil + return self + end + end + + # Original path: handles non-Integer args, Julian/reform dates, fractional days y = year m = month d = day @@ -135,6 +179,21 @@ class << self # # Related: Date.jd, Date.new. def valid_civil?(year, month, day, start = DEFAULT_SG) + # Fast path: Integer args, non-Julian start + if year.is_a?(Integer) && month.is_a?(Integer) && day.is_a?(Integer) + gregorian_fast = if start.is_a?(Float) && start.infinite? + start < 0 + elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD + true + end + + if gregorian_fast + return false if month < 1 || month > 12 + leap = (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) + return day >= 1 && day <= MONTH_DAYS[leap ? 1 : 0][month] + end + end + return false unless numeric?(year) return false unless numeric?(month) return false unless numeric?(day) @@ -170,6 +229,32 @@ def valid_civil?(year, month, day, start = DEFAULT_SG) # # Related: Date.new. def jd(jd = 0, start = DEFAULT_SG) + # Fast path: Integer jd in common range, valid start + if jd.is_a?(Integer) && jd >= 0 && jd < CM_PERIOD + valid_start = if start.is_a?(Float) && start.infinite? + true + elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD + true + end + + if valid_start + obj = allocate + obj.instance_variable_set(:@nth, 0) + obj.instance_variable_set(:@jd, jd) + obj.instance_variable_set(:@sg, start) + obj.instance_variable_set(:@year, 0) + obj.instance_variable_set(:@month, 0) + obj.instance_variable_set(:@day, 0) + obj.instance_variable_set(:@has_jd, true) + obj.instance_variable_set(:@has_civil, false) + obj.instance_variable_set(:@df, nil) + obj.instance_variable_set(:@sf, nil) + obj.instance_variable_set(:@of, nil) + return obj + end + end + + # Original path j = 0 fr = 0 sg = start @@ -203,11 +288,11 @@ def jd(jd = 0, start = DEFAULT_SG) # # Related: Date.jd. def valid_jd?(jd, start = DEFAULT_SG) - return false unless numeric?(jd) + # All Numeric jd values are valid; skip valid_jd_sub/valid_sg chain + return true if jd.is_a?(Numeric) + return true if jd.respond_to?(:to_int) - result = valid_jd_sub(jd, start, 0) - - !result.nil? + false end # call-seq: @@ -221,6 +306,9 @@ def valid_jd?(jd, start = DEFAULT_SG) # # Related: Date.julian_leap?. def gregorian_leap?(year) + if year.is_a?(Integer) + return (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) + end raise TypeError, "invalid year (not numeric)" unless numeric?(year) _, ry = decode_year(year, -1) @@ -240,6 +328,9 @@ def gregorian_leap?(year) # # Related: Date.gregorian_leap?. def julian_leap?(year) + if year.is_a?(Integer) + return (year % 4).zero? + end raise TypeError, "invalid year (not numeric)" unless numeric?(year) _, ry = decode_year(year, +1) @@ -276,6 +367,40 @@ def julian_leap?(year) # # Related: Date.jd, Date.new. def ordinal(year = -4712, yday = 1, start = DEFAULT_SG) + # Fast path: Integer args, Gregorian calendar + if year.is_a?(Integer) && year.abs < 579000 && yday.is_a?(Integer) + gregorian_fast = if start.is_a?(Float) && start.infinite? + start < 0 + elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD + year > REFORM_END_YEAR + end + + if gregorian_fast + leap = (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) + days_in_year = leap ? 366 : 365 + d = yday + d = days_in_year + d + 1 if d < 0 + raise Error unless d >= 1 && d <= days_in_year + + rjd = c_gregorian_civil_to_jd(year, 1, 1) + d - 1 + + obj = allocate + obj.instance_variable_set(:@nth, 0) + obj.instance_variable_set(:@jd, rjd) + obj.instance_variable_set(:@sg, start) + obj.instance_variable_set(:@year, 0) + obj.instance_variable_set(:@month, 0) + obj.instance_variable_set(:@day, 0) + obj.instance_variable_set(:@has_jd, true) + obj.instance_variable_set(:@has_civil, false) + obj.instance_variable_set(:@df, nil) + obj.instance_variable_set(:@sf, nil) + obj.instance_variable_set(:@of, nil) + return obj + end + end + + # Original path y = year d = yday fr2 = 0 @@ -317,6 +442,23 @@ def ordinal(year = -4712, yday = 1, start = DEFAULT_SG) # # Related: Date.jd, Date.ordinal. def valid_ordinal?(year, day, start = DEFAULT_SG) + # Fast path: Integer args, non-Julian start + if year.is_a?(Integer) && day.is_a?(Integer) + gregorian_fast = if start.is_a?(Float) && start.infinite? + start < 0 + elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD + true + end + + if gregorian_fast + leap = (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) + days_in_year = leap ? 366 : 365 + d = day + d = days_in_year + d + 1 if d < 0 + return d >= 1 && d <= days_in_year + end + end + return false unless numeric?(year) return false unless numeric?(day) @@ -368,6 +510,55 @@ def valid_ordinal?(year, day, start = DEFAULT_SG) # # Related: Date.jd, Date.new, Date.ordinal. def commercial(cwyear = -4712, cweek = 1, cwday = 1, start = DEFAULT_SG) + # Fast path: Integer args, Gregorian calendar + if cwyear.is_a?(Integer) && cwyear.abs < 579000 && cweek.is_a?(Integer) && cwday.is_a?(Integer) + gregorian_fast = if start.is_a?(Float) && start.infinite? + start < 0 + elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD + cwyear > REFORM_END_YEAR + end + + if gregorian_fast + # Validate cwday (handle negative) + d = cwday + d += 8 if d < 0 + raise Error unless d >= 1 && d <= 7 + + # JD of Jan 1 and ISO week metadata + jd_jan1 = c_gregorian_civil_to_jd(cwyear, 1, 1) + + # Max ISO weeks: 53 if Jan 1 is Thursday, or leap year and Jan 1 is Wednesday + p_val = (jd_jan1 + 1) % 7 # 0=Sun..6=Sat + p_val = 7 if p_val == 0 # Convert to ISO (1=Mon..7=Sun) + leap = (cwyear % 4 == 0) && (cwyear % 100 != 0 || cwyear % 400 == 0) + max_weeks = (p_val == 4 || (leap && p_val == 3)) ? 53 : 52 + + # Handle negative week + w = cweek + w = max_weeks + w + 1 if w < 0 + raise Error unless w >= 1 && w <= max_weeks + + # Compute JD: Monday of week 1 + offset + rjd2 = jd_jan1 + 3 + rjd = (rjd2 - (rjd2 % 7)) + 7 * (w - 1) + (d - 1) + + obj = allocate + obj.instance_variable_set(:@nth, 0) + obj.instance_variable_set(:@jd, rjd) + obj.instance_variable_set(:@sg, start) + obj.instance_variable_set(:@year, 0) + obj.instance_variable_set(:@month, 0) + obj.instance_variable_set(:@day, 0) + obj.instance_variable_set(:@has_jd, true) + obj.instance_variable_set(:@has_civil, false) + obj.instance_variable_set(:@df, nil) + obj.instance_variable_set(:@sf, nil) + obj.instance_variable_set(:@of, nil) + return obj + end + end + + # Original path y = cwyear w = cweek d = cwday @@ -418,6 +609,34 @@ def commercial(cwyear = -4712, cweek = 1, cwday = 1, start = DEFAULT_SG) # # Related: Date.jd, Date.commercial. def valid_commercial?(year, week, day, start = DEFAULT_SG) + # Fast path: Integer args, non-Julian start + if year.is_a?(Integer) && week.is_a?(Integer) && day.is_a?(Integer) + gregorian_fast = if start.is_a?(Float) && start.infinite? + start < 0 + elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD + true + end + + if gregorian_fast + # Validate cwday (handle negative) + d = day + d += 8 if d < 0 + return false unless d >= 1 && d <= 7 + + # Max ISO weeks: 53 if Jan 1 is Thursday, or leap year and Jan 1 is Wednesday + jd_jan1 = c_gregorian_civil_to_jd(year, 1, 1) + p_val = (jd_jan1 + 1) % 7 # 0=Sun..6=Sat + p_val = 7 if p_val == 0 # Convert to ISO (1=Mon..7=Sun) + leap = (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) + max_weeks = (p_val == 4 || (leap && p_val == 3)) ? 53 : 52 + + # Handle negative week + w = week + w = max_weeks + w + 1 if w < 0 + return w >= 1 && w <= max_weeks + end + end + return false unless numeric?(year) return false unless numeric?(week) return false unless numeric?(day) @@ -436,40 +655,18 @@ def valid_commercial?(year, week, day, start = DEFAULT_SG) # # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. def today(start = DEFAULT_SG) - begin - time = Time.now - rescue - raise SystemCallError, "time" - end - - begin - y = time.year - m = time.month - d = time.day - rescue - raise SystemCallError, "localtime" - end - - nth, ry, _, _ = decode_year(y, -1) + time = Time.now obj = allocate - obj.instance_variable_set(:@nth, nth) - obj.instance_variable_set(:@year, ry) - obj.instance_variable_set(:@month, m) - obj.instance_variable_set(:@day, d) + obj.instance_variable_set(:@nth, 0) + obj.instance_variable_set(:@year, time.year) + obj.instance_variable_set(:@month, time.mon) + obj.instance_variable_set(:@day, time.mday) obj.instance_variable_set(:@jd, nil) - obj.instance_variable_set(:@sg, GREGORIAN) + obj.instance_variable_set(:@sg, start) obj.instance_variable_set(:@has_jd, false) obj.instance_variable_set(:@has_civil, true) - if start != GREGORIAN - obj.instance_variable_set(:@sg, start) - if obj.instance_variable_get(:@has_jd) - obj.instance_variable_set(:@jd, nil) - obj.instance_variable_set(:@has_jd, false) - end - end - obj end @@ -808,9 +1005,7 @@ def valid_civil_sub(year, month, day, start, need_jd) return nil if month < 1 || month > 12 leap_year = start == JULIAN ? julian_leap?(year) : gregorian_leap?(year) - - days_in_month = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] - max_day = (month == 2 && leap_year) ? 29 : days_in_month[month] + max_day = MONTH_DAYS[leap_year ? 1 : 0][month] return nil if day < 1 || day > max_day @@ -1137,13 +1332,7 @@ def c_gregorian_ldom_jd(year, month) end def c_gregorian_last_day_of_month(year, month) - days_in_month = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31] - - if month == 2 && gregorian_leap?(year) - 29 - else - days_in_month[month] - end + MONTH_DAYS[gregorian_leap?(year) ? 1 : 0][month] end def c_civil_to_jd(year, month, day, sg) @@ -1341,18 +1530,7 @@ def new_with_jd(nth, jd, start) def new_with_jd_and_time(nth, jd, df, sf, of, start) obj = allocate - obj.instance_variable_set(:@nth, nth) - obj.instance_variable_set(:@jd, jd) - obj.instance_variable_set(:@sg, start) - obj.instance_variable_set(:@df, df) - obj.instance_variable_set(:@sf, sf) - obj.instance_variable_set(:@of, of) - obj.instance_variable_set(:@year, nil) - obj.instance_variable_set(:@month, nil) - obj.instance_variable_set(:@day, nil) - obj.instance_variable_set(:@has_jd, true) - obj.instance_variable_set(:@has_civil, false) - + obj.send(:_init_with_jd, nth, jd, df, sf, of, start) obj end @@ -1586,6 +1764,16 @@ def start # # d <=> Object.new # => nil def <=>(other) + if other.is_a?(Date) && + @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && + other.instance_variable_get(:@nth) == 0 && + other.instance_variable_get(:@has_jd) && + other.instance_variable_get(:@df).nil? && + other.instance_variable_get(:@sf).nil? && + other.instance_variable_get(:@of).nil? + return @jd <=> other.instance_variable_get(:@jd) + end + case other when Date m_canonicalize_jd @@ -1625,6 +1813,32 @@ def <=>(other) end end + def <(other) # :nodoc: + if other.is_a?(Date) && + @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && + other.instance_variable_get(:@nth) == 0 && + other.instance_variable_get(:@has_jd) && + other.instance_variable_get(:@df).nil? && + other.instance_variable_get(:@sf).nil? && + other.instance_variable_get(:@of).nil? + return @jd < other.instance_variable_get(:@jd) + end + super + end + + def >(other) # :nodoc: + if other.is_a?(Date) && + @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && + other.instance_variable_get(:@nth) == 0 && + other.instance_variable_get(:@has_jd) && + other.instance_variable_get(:@df).nil? && + other.instance_variable_get(:@sf).nil? && + other.instance_variable_get(:@of).nil? + return @jd > other.instance_variable_get(:@jd) + end + super + end + # call-seq: # self === other -> true, false, or nil. # @@ -1659,6 +1873,17 @@ def <=>(other) # # d === Object.new # => nil def ===(other) + if other.is_a?(Date) && + @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && + @jd >= 0 && @jd < CM_PERIOD && + other.instance_variable_get(:@nth) == 0 && + other.instance_variable_get(:@has_jd) && + other.instance_variable_get(:@df).nil? && + other.instance_variable_get(:@sf).nil? && + other.instance_variable_get(:@of).nil? + return @jd == other.instance_variable_get(:@jd) + end + return equal_gen(other) unless other.is_a?(Date) # Call equal_gen even if the Gregorian calendars do not match. @@ -1700,6 +1925,29 @@ def ===(other) # d1 = d0 >> 1 # => # # d2 = d1 >> -1 # => # def >>(n) + if n.is_a?(Integer) && @of.nil? && @nth == 0 && @has_civil + sg = @sg + gregorian_fast = if sg.is_a?(Float) && sg.infinite? + sg < 0 + elsif sg.is_a?(Integer) && sg >= REFORM_BEGIN_JD && sg <= REFORM_END_JD + @year > REFORM_END_YEAR + end + if gregorian_fast + t = @year * 12 + (@month - 1) + n + y = t / 12 + m = (t % 12) + 1 + d = @day + + leap = (y % 4 == 0) && (y % 100 != 0 || y % 400 == 0) + last = MONTH_DAYS[leap ? 1 : 0][m] + d = last if d > last + + obj = self.class.allocate + obj._init_simple_with_civil(y, m, d, sg) + return obj + end + end + # Calculate years and months t = m_real_year * 12 + (m_mon - 1) + n @@ -1758,12 +2006,71 @@ def >>(n) # d1 = d0 << 1 # => # # d2 = d1 << -1 # => # def <<(n) + if n.is_a?(Integer) && @of.nil? && @nth == 0 && @has_civil + sg = @sg + gregorian_fast = if sg.is_a?(Float) && sg.infinite? + sg < 0 + elsif sg.is_a?(Integer) && sg >= REFORM_BEGIN_JD && sg <= REFORM_END_JD + @year > REFORM_END_YEAR + end + if gregorian_fast + t = @year * 12 + (@month - 1) - n + y = t / 12 + m = (t % 12) + 1 + d = @day + + leap = (y % 4 == 0) && (y % 100 != 0 || y % 400 == 0) + last = MONTH_DAYS[leap ? 1 : 0][m] + d = last if d > last + + obj = self.class.allocate + obj._init_simple_with_civil(y, m, d, sg) + return obj + end + end + raise TypeError, "expected numeric" unless n.is_a?(Numeric) - self >> (-n) + t = m_real_year * 12 + (m_mon - 1) - n + + if t.is_a?(Integer) && t.abs < (1 << 62) + y = t / 12 + m = (t % 12) + 1 + else + y = t.div(12) + m = (t % 12).to_i + 1 + end + + d = m_mday + sg = m_sg + + result = nil + loop do + result = self.class.send(:valid_civil_p, y, m, d, sg) + break if result + + d -= 1 + raise Error if d < 1 + end + + nth = result[:nth] + rjd = result[:rjd] + rjd2 = self.class.send(:encode_jd, nth, rjd) + + self + (rjd2 - m_real_local_jd) end def ==(other) # :nodoc: + if other.is_a?(Date) && + @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && + other.instance_variable_get(:@nth) == 0 && + other.instance_variable_get(:@has_jd) && + other.instance_variable_get(:@df).nil? && + other.instance_variable_get(:@sf).nil? && + other.instance_variable_get(:@of).nil? + return @jd == other.instance_variable_get(:@jd) + end + return false unless other.is_a?(Date) m_canonicalize_jd @@ -1776,6 +2083,17 @@ def ==(other) # :nodoc: end def eql?(other) # :nodoc: + if other.is_a?(Date) && + @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && + other.instance_variable_get(:@nth) == 0 && + other.instance_variable_get(:@has_jd) && + other.instance_variable_get(:@df).nil? && + other.instance_variable_get(:@sf).nil? && + other.instance_variable_get(:@of).nil? + return @jd == other.instance_variable_get(:@jd) && + @sg == other.instance_variable_get(:@sg) + end + return false unless other.is_a?(Date) m_canonicalize_jd @@ -1787,6 +2105,10 @@ def eql?(other) # :nodoc: end def hash # :nodoc: + if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && + @jd >= 0 && @jd < CM_PERIOD + return [0, @jd, @sg].hash + end m_canonicalize_jd [m_nth, m_jd, @sg].hash end @@ -1806,6 +2128,34 @@ def hash # :nodoc: # DateTime.jd(0,12) + DateTime.new(2001,2,3).ajd # #=> # def +(other) + if other.is_a?(Integer) && @of.nil? && @nth == 0 + if @has_jd + jd = @jd + other + elsif @has_civil + sg = @sg + gregorian_fast = if sg.is_a?(Float) && sg.infinite? + sg < 0 + elsif sg.is_a?(Integer) && sg >= REFORM_BEGIN_JD && sg <= REFORM_END_JD + @year > REFORM_END_YEAR + end + if gregorian_fast + j = (@month < 3) ? 1 : 0 + y0 = @year - j + m0 = j.nonzero? ? @month + 12 : @month + d0 = @day - 1 + q1 = y0 / 100 + yc = (NS_DAYS_IN_4_YEARS * y0) / 4 - q1 + q1 / 4 + mc = (NS_DAYS_BEFORE_NEW_YEAR * m0 - 914) / 10 + jd = yc + mc + d0 + NS_EPOCH + other + end + end + if jd && jd >= 0 && jd < CM_PERIOD + obj = self.class.allocate + obj._init_simple_with_jd(jd, @sg) + return obj + end + end + case other when Integer nth = m_nth @@ -1821,11 +2171,13 @@ def +(other) nth, jd = canonicalize_jd(nth, jd) end + obj = self.class.allocate if simple_dat_p? - self.class.send(:new_with_jd, nth, jd, @sg) + obj._init_with_jd(nth, jd, nil, nil, nil, @sg) else - self.class.send(:new_with_jd_and_time, nth, jd, @df || 0, @sf || 0, @of || 0, @sg) + obj._init_with_jd(nth, jd, @df || 0, @sf || 0, @of || 0, @sg) end + obj when Float s = other >= 0 ? 1 : -1 o = other.abs @@ -1884,11 +2236,13 @@ def +(other) nth = nth.nonzero? ? @nth + nth : @nth + obj = self.class.allocate if df.zero? && sf.zero? && (@of.nil? || @of.zero?) - self.class.send(:new_with_jd, nth, jd, @sg) + obj._init_with_jd(nth, jd, nil, nil, nil, @sg) else - self.class.send(:new_with_jd_and_time, nth, jd, df, sf, @of || 0, @sg) + obj._init_with_jd(nth, jd, df, sf, @of || 0, @sg) end + obj when Rational return self + other.numerator if other.denominator == 1 @@ -1949,11 +2303,13 @@ def +(other) nth = nth.nonzero? ? @nth + nth : @nth + obj = self.class.allocate if df.zero? && sf.zero? - self.class.send(:new_with_jd, nth, jd, @sg) + obj._init_with_jd(nth, jd, nil, nil, nil, @sg) else - self.class.send(:new_with_jd_and_time, nth, jd, df, sf, @of || 0, @sg) + obj._init_with_jd(nth, jd, df, sf, @of || 0, @sg) end + obj else raise TypeError, "expected numeric" unless other.is_a?(Numeric) @@ -1979,6 +2335,15 @@ def +(other) # Date.new(2001,2,3) - Date.new(2001) #=> (33/1) # DateTime.new(2001,2,3) - DateTime.new(2001,2,2,12) #=> (1/2) def -(other) + if other.is_a?(Integer) && @of.nil? && @nth == 0 && @has_jd + jd = @jd - other + if jd >= 0 && jd < CM_PERIOD + obj = self.class.allocate + obj._init_simple_with_jd(jd, @sg) + return obj + end + end + return minus_dd(other) if other.is_a?(Date) raise TypeError, "expected numeric" unless other.is_a?(Numeric) @@ -2833,6 +3198,40 @@ def valid_civil_date?(year, month, day, sg) self.class.send(:valid_civil_date?, year, month, day, sg) end + protected + + def _init_with_jd(nth, jd, df, sf, of, start) + @nth = nth + @jd = jd + @sg = start + @df = df + @sf = sf + @of = of + @year = nil + @month = nil + @day = nil + @has_jd = true + @has_civil = false + end + + def _init_simple_with_jd(jd, start) + @nth = 0 + @jd = jd + @sg = start + @has_jd = true + end + + def _init_simple_with_civil(year, month, day, start) + @nth = 0 + @sg = start + @year = year + @month = month + @day = day + @has_civil = true + end + + private + def canonicalize_jd(nth, jd) if jd < 0 nth = nth - 1 @@ -3114,6 +3513,8 @@ def m_of end def m_real_year + return @year if @nth == 0 && @has_civil + nth = @nth year = m_year @@ -3123,14 +3524,16 @@ def m_real_year end def m_mon - simple_dat_p? ? get_s_civil : get_c_civil + return @month if @has_civil + simple_dat_p? ? get_s_civil : get_c_civil @month end def m_mday - simple_dat_p? ? get_s_civil : get_c_civil + return @day if @has_civil + simple_dat_p? ? get_s_civil : get_c_civil @day end @@ -3341,6 +3744,8 @@ def c_valid_start_p?(sg) end def m_wday + return (@jd + 1) % 7 if @has_jd && @of.nil? + c_jd_to_wday(m_local_jd) end @@ -3349,6 +3754,15 @@ def c_jd_to_wday(jd) end def m_yday + if @has_civil && @of.nil? + sg = @sg + if (sg.is_a?(Float) && sg.infinite? && sg < 0) || + (sg.is_a?(Integer) && @has_jd && (@jd - sg) > 366) + leap = self.class.send(:c_gregorian_leap_p?, @year) + return YEARTAB[leap ? 1 : 0][@month] + @day + end + end + jd = m_local_jd sg = m_virtual_sg From d4aa1aa5709101443561205bdd5939599d584825 Mon Sep 17 00:00:00 2001 From: jinroq Date: Sun, 22 Feb 2026 16:51:23 +0900 Subject: [PATCH 04/11] Optimized some methods. MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit feat: Optimize Date#strftime with lookup tables, fast paths, and integer flags Summary of changes: 1. Replace string-based flag accumulation with integer bitmask - Introduced FLAG_MINUS, FLAG_SPACE, FLAG_UPPER, FLAG_CHCASE, FLAG_ZERO - Eliminates per-call String allocation for format modifier parsing 2. Add fast path in strftime_format for simple Date objects - Detects simple Date (@df/@sf/@of all nil, @nth == 0) once per call - Bypasses tmx_* method chain for common specs (Y, m, d, A, B, etc.) - Precomputes f_year, f_month, f_day, f_wday from instance variables 3. Add FOUR_DIGIT precomputed lookup table - "0000".."9999" frozen string table avoids per-call sprintf for years 0..9999 - Applied to fast paths (%F/%Y-%m-%d, composite, %c) and strftime_format 4. Move TWO_DIGIT, FOUR_DIGIT, and FLAG_* constants to constants.rb - Consolidates all Date constants in one file --- Performance comparison (Date#strftime, Ruby 4.0.1) Benchmark: Date#strftime (default) C extension: 2,862,515 Pure Ruby before: 86,749 Pure Ruby after: 1,341,000 vs before: +15.5x vs C ext: 46.8% ──────────────────────────────────────── Benchmark: Date#strftime(%Y-%m-%d) C extension: 3,040,048 Pure Ruby before: 108,336 Pure Ruby after: 1,346,000 vs before: +12.4x vs C ext: 44.3% ──────────────────────────────────────── Benchmark: Date#strftime(%A %B) C extension: 2,960,230 Pure Ruby before: 83,226 Pure Ruby after: 265,000 vs before: +3.2x vs C ext: 9.0% ──────────────────────────────────────── Benchmark: Date#strftime(%c) C extension: 2,001,595 Pure Ruby before: 43,985 Pure Ruby after: 1,010,000 vs before: +23.0x vs C ext: 50.5% ──────────────────────────────────────── Benchmark: Date#strftime(%x) C extension: 2,622,940 Pure Ruby before: 89,569 Pure Ruby after: 1,438,000 vs before: +16.1x vs C ext: 54.8% ──────────────────────────────────────── Benchmark: Date#strftime(composite) C extension: 1,652,488 Pure Ruby before: 47,050 Pure Ruby after: 1,268,000 vs before: +27.0x vs C ext: 76.7% feat: Add direct fast paths to Date#iso8601, #rfc2822, and #asctime For simple Date objects (no time/offset, @nth == 0), bypass the strftime machinery entirely and build the result string directly using the FOUR_DIGIT and TWO_DIGIT precomputed tables. Changes in lib/date/core.rb: - Date#iso8601 / #xmlschema: build "%Y-%m-%d" string directly - Date#rfc2822 / #rfc822: build RFC 2822 string directly using ABBR_DAYNAMES, ABBR_MONTHNAMES, FOUR_DIGIT; offset fixed to "+0000" for simple Date - Date#asctime / #ctime: build ctime string directly with space-padded day; uses ABBR_DAYNAMES, ABBR_MONTHNAMES, FOUR_DIGIT - All three methods fall back to strftime for non-simple Date objects (DateTime, objects with non-zero offset, etc.) Performance comparison (Ruby 4.0.1, measured 2026-02-22): Benchmark | Pure Ruby (after) | C extension | After / C ext ----------------|-------------------|---------------|--------------- Date#iso8601 | 2,420,256 | 3,983,797 | 60.8 % Date#rfc2822 | 1,811,210 | 1,960,706 | 92.4 % Date#asctime | 1,590,435 | 2,444,714 | 65.1 % Unit: iterations/second (i/s). "Pure Ruby (after)" is measured with Process.clock_gettime on Ruby 4.0.1 (docker ruby:4.0) after this change. All three methods previously delegated to strftime, which parsed the format string through strftime_format on every call. The new fast paths eliminate that overhead for the common case (simple Date created via Date.new / Date.civil). Date#rfc2822 reaches 92% of C extension performance. feat: Optimize Date._strptime with fast path and byte-level digit scanning Summary of changes in lib/date/strptime.rb: 1. Add fast path for '%F' / '%Y-%m-%d' (the default format) - Parse year/mon/mday directly with a single compiled regex, bypassing the full format-string scanner and _strptime_spec dispatch entirely. - Note: manual byte scanning was tested for this hot path but found to be slower than the C regex engine due to Ruby method-call overhead; the regex-based fast path is retained. 2. Remove unnecessary str = string.dup - The input string is read-only inside the parser; the copy was wasteful. 3. Cache fmt_len = format.length - Avoid repeated length calls on every loop iteration. 4. Replace String-based width accumulation with integer arithmetic - width_str = String.new + regex digit check replaced by d.ord - 48 integer accumulation; field_width is nil (not specified) or Integer. 5. Replace format whitespace regex with explicit char comparison - format[i] =~ /\s/ replaced by direct comparison against ' ', "\t", "\n", "\r", "\v", "\f". 6. Change _strptime_spec calling convention to in-place hash modification - Old: returns {pos: new_pos, hash: h} — allocates two hashes per spec. - New: modifies the caller's hash directly and returns new_pos (Integer) or nil on failure — zero extra allocations per spec. - _strptime_composite updated to match the new convention. 7. Add scan_uint / scan_sint byte-level digit scanners - scan_uint(str, pos, max): reads unsigned digits via getbyte, no regex, no substring, no MatchData — returns [value, new_pos] or nil. - scan_sint(str, pos, max): handles optional leading +/- prefix. 8. Replace regex-based matching in _strptime_spec for all numeric specifiers - Affected: Y, C, y, m, d/e, j, H/k, I/l, M, S, L, N, w, u, U, W, V, G, g, s, Q. - Each str[pos..].match(/\A.../) call eliminated: no substring allocation, no MatchData object, no regex engine overhead per numeric field. Performance comparison (Ruby 4.0.1, measured 2026-02-22): Benchmark | Before (i/s) | After (i/s) | C ext (i/s) | After / C ext ---------------------------|--------------|-------------|-------------|--------------- Date._strptime (default) | 40,248 | 740,864 | 2,610,013 | 28.4 % Date.strptime (default) | 37,440 | 323,953 | 1,373,996 | 23.6 % Date._strptime (complex) | 24,015 | 75,532 | 1,097,796 | 6.9 % Unit: iterations/second (i/s). "Before" is taken from bench/results/20260222/4.0.1_local.tsv (prior to this change). "C ext" is taken from bench/results/20260222/4.0.1_system.tsv. "After" is measured with Process.clock_gettime on ruby:4.0 (Docker) after all changes in this commit. The default format (Date._strptime with no explicit format argument) improves 18.4x over the baseline by hitting the '%F' fast path. The complex format ('%Y-%m-%d %H:%M:%S') improves 3.1x through the elimination of per-spec substring and MatchData allocations via scan_uint / scan_sint. feat: Apply StringScanner (Approach A) to Date._strptime general parser Replace the hand-rolled position-integer loop in _strptime with a StringScanner-based approach to eliminate redundant String allocations. Changes: - Add `require 'strscan'` - Main loop: use `format.getbyte(i)` (Integer comparison) instead of `format[i]` (String allocation) for every format character - Literal character matching: `ss.string.getbyte(ss.pos) == fb` + `ss.pos += 1` instead of `str[pos] == c` (String allocation per literal char) - Whitespace skipping: `ss.skip(/[ \t\n\r\v\f]*/)` instead of a hand-rolled while loop with per-char String comparisons - `%p`/`%P`: `ss.scan(/a\.?m\.?|p\.?m\.?/i)` eliminates the `str[pos..].match(/\A.../)` substring allocation - `%n`/`%t`: `ss.skip(/\s*/)` replaces `str[pos..].match(/\A\s+/)` - `_strptime_spec` signature: `(ss, spec, width, hash, next_is_num)` — updates `ss.pos` in-place, returns `true`/`nil` - `_strptime_composite` signature: `(ss, format, context_hash)` — uses `format.getbyte(i)` and `ss.string.getbyte(ss.pos)` throughout, returns the diff hash (or nil) rather than `{pos:, hash:}` - The `%F`/`%Y-%m-%d` regex fast path is unchanged Performance (500,000 iterations, ruby 4.0, linux/amd64): | Method | C ext (i/s) | Before (i/s) | After (i/s) | % of C | |-----------------------------|-------------|--------------|-------------|--------| | Date._strptime (default %F) | 2,610,014 | 740,864 | 747,515 | 28.6% | | Date.strptime (default %F) | 1,373,996 | 323,953 | 326,703 | 23.8% | | Date._strptime (complex fmt)| 1,097,796 | 75,532 | 106,642 | 9.7% | The default-format path shows only marginal gains because the regex fast path (`%F`/`%Y-%m-%d`) bypasses the StringScanner loop entirely. The complex-format path improves by ~41% over Approach C, driven by eliminating per-character String allocations in the main parse loop. feat: Expand _strptime fast paths for common datetime formats (Approach D) Add direct regex fast paths for two additional format strings, bypassing the StringScanner general parser loop entirely. Changes: - Refactor the existing `%F`/`%Y-%m-%d` fast path into a `case/when` dispatch for extensibility - Add fast path for `'%Y-%m-%d %H:%M:%S'`: matches `/\A([+-]?\d+)-(\d{1,2})-(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})/` and returns `{year:, mon:, mday:, hour:, min:, sec:}` directly - Add fast path for `'%Y-%m-%dT%H:%M:%S'`: same as above with `T` separator (ISO 8601 datetime) - Both fast paths validate ranges (mon 1-12, mday 1-31, hour 0-24, min 0-59, sec 0-60) and set `:leftover` if trailing input remains Performance (500,000 iterations, ruby 4.0, linux/amd64): | Method | C ext (i/s) | Before (i/s) | After (i/s) | % of C | |-----------------------------------|-------------|--------------|-------------| --------| | Date._strptime (default %F) | 2,610,014 | 747,515 | 723,600 | 27.7% | | Date.strptime (default %F) | 1,373,996 | 326,703 | 332,490 | 24.2% | | Date._strptime (%Y-%m-%d %H:%M:%S) | 1,097,796 | 106,642 | 544,377 | 49.6% | The complex datetime format improves ~5x by eliminating all StringScanner and spec-dispatch overhead for the hot `%Y-%m-%d %H:%M:%S` pattern. The default `%F` case is unchanged in behavior (before/after difference is within benchmark noise). feat: Optimize constructors, accessors, and strptime internals (Phases 4–8) Changes - strptime internals - Precompute NUM_PATTERN_SPECS_TABLE, STRPTIME_DAYNAME_BY_INT_KEY, and STRPTIME_MONNAME_BY_INT_KEY in constants.rb for O(1) byte-level lookup - Rewrite num_pattern_p with getbyte to eliminate String allocations - Replace ss.skip(/[ \t\n\r\v\f]*/) with skip_ws byte-loop helper (3 sites) -Julian calendar fast path - Add integer-arithmetic Julian JD fast path in Date#initialize covering Date::JULIAN start and pre-reform years (e.g. Date.civil(-4712, 1, 1)) - Computed accessor hot paths - Add @jd fast path to Date#ajd, #amjd, #mjd, #ld bypassing 6-level method chain - Arithmetic and conversion hot paths - Add @jd fast path to Date#to_datetime (skip decode_year + c_civil_to_jd) - Inline Date#wday as (@jd + 1) % 7 - Optimize Date#-(Date) to direct Rational(@jd - other.@jd, 1) - Constructor ivar reduction and accessor inlining - Reduce instance_variable_set calls in Date.jd / .ordinal / .commercial fast paths from 11 to 4 (allocate initializes remaining ivars to nil) - Inline early-return in Date#year, #month, #day Performance: C extension vs pure Ruby (i/s, measured on Ruby 4.0.1) Method | C ext | Ruby | Ruby/C -----------------------|----------|----------|------- Date.civil | 4,626k | 1,018k | 22% Date.civil(neg) | 4,649k | 1,258k | 27% Date.jd | 4,884k | 2,311k | 47% Date.ordinal | 3,032k | 947k | 31% Date.commercial | 2,483k | 809k | 33% Date#year | 20,261k | 13,268k | 65% Date#month | 21,387k | 15,796k | 74% Date#day | 18,377k | 15,798k | 86% Date#wday | 20,868k | 11,957k | 57% Date#jd | 19,662k | 16,496k | 84% Date#ajd | 7,566k | 4,643k | 61% Date#mjd | 11,732k | 8,089k | 69% Date#amjd | 10,574k | 5,746k | 54% Date#ld | 11,805k | 8,216k | 70% Date#yday | 15,685k | 19,099k | 122% Date#cwyear | 4,494k | 6,810k | 152% Date#cweek | 4,550k | 14,646k | 322% Date#-Date | 1,858k | 2,327k | 125% Date#-1 | 3,715k | 3,612k | 97% Date#+1 | 5,516k | 3,460k | 63% Date#to_datetime | 6,686k | 2,126k | 32% Date#iso8601 | 3,997k | 2,505k | 63% Date#rfc3339 | 1,801k | 2,242k | 125% Date#rfc2822 | 1,963k | 1,687k | 86% Date#strftime | 2,830k | 1,347k | 48% Date._parse(iso) | 237k | 61k | 26% Date._strptime | 2,719k | 782k | 29% Date.strptime(complex) | 1,123k | 114k | 10% --- lib/date/constants.rb | 56 ++++ lib/date/core.rb | 351 +++++++++++++++++---- lib/date/parse.rb | 13 +- lib/date/strftime.rb | 439 +++++++++++++++++--------- lib/date/strptime.rb | 709 +++++++++++++++++++++++------------------- 5 files changed, 1025 insertions(+), 543 deletions(-) diff --git a/lib/date/constants.rb b/lib/date/constants.rb index 2f7ca2ba..fcf8e2b5 100644 --- a/lib/date/constants.rb +++ b/lib/date/constants.rb @@ -161,6 +161,31 @@ class Date NUM_PATTERN_SPECS = "CDdeFGgHIjkLlMmNQRrSsTUuVvWwXxYy" private_constant :NUM_PATTERN_SPECS + # Precomputed byte-indexed boolean table for num_pattern_p. + # Entry is true if the byte value corresponds to a digit-consuming %-specifier. + NUM_PATTERN_SPECS_TABLE = begin + t = Array.new(256, false) + NUM_PATTERN_SPECS.each_byte { |b| t[b] = true } + t.freeze + end + private_constant :NUM_PATTERN_SPECS_TABLE + + # Precomputed zero-padded two-digit strings "00".."99". + TWO_DIGIT = (0..99).map { |i| (i < 10 ? "0#{i}" : i.to_s).freeze }.freeze + private_constant :TWO_DIGIT + + # Precomputed zero-padded four-digit year strings "0000".."9999". + FOUR_DIGIT = (0..9999).map { |y| sprintf("%04d", y).freeze }.freeze + private_constant :FOUR_DIGIT + + # Integer bitmask flags for strftime format modifier parsing. + FLAG_MINUS = 0x01 # '-' suppress padding + FLAG_SPACE = 0x02 # '_' space padding + FLAG_UPPER = 0x04 # '^' upcase result + FLAG_CHCASE = 0x08 # '#' change case (CHCASE) + FLAG_ZERO = 0x10 # '0' zero padding (explicit) + private_constant :FLAG_MINUS, :FLAG_SPACE, :FLAG_UPPER, :FLAG_CHCASE, :FLAG_ZERO + # Fragment completion table for DateTime parsing COMPLETE_FRAGS_TABLE = [ [:time, [:hour, :min, :sec].freeze], @@ -176,4 +201,35 @@ class Date [nil, [:year, :wnum1, :cwday, :hour, :min, :sec].freeze], ].each { |a| a.freeze }.freeze private_constant :COMPLETE_FRAGS_TABLE + + # Lookup tables for O(1) day/month name matching in strptime %a/%b. + # Key: 24-bit integer (b0|0x20)<<16|(b1|0x20)<<8|(b2|0x20) of lowercase 3-char abbreviation. + # Value: [index, full_lower, full_len, abbr_len]. + # This avoids string allocation for the 3-char prefix key entirely. + STRPTIME_DAYNAME_BY_INT_KEY = begin + h = {} + DAYNAMES.each_with_index do |name, idx| + abbr = ABBR_DAYNAMES[idx] + k = ((abbr.getbyte(0) | 0x20) << 16) | + ((abbr.getbyte(1) | 0x20) << 8) | + (abbr.getbyte(2) | 0x20) + h[k] = [idx, name.downcase, name.length, abbr.length].freeze + end + h.freeze + end + private_constant :STRPTIME_DAYNAME_BY_INT_KEY + + STRPTIME_MONNAME_BY_INT_KEY = begin + h = {} + MONTHNAMES.each_with_index do |name, idx| + next unless name + abbr = ABBR_MONTHNAMES[idx] + k = ((abbr.getbyte(0) | 0x20) << 16) | + ((abbr.getbyte(1) | 0x20) << 8) | + (abbr.getbyte(2) | 0x20) + h[k] = [idx, name.downcase, name.length, abbr.length].freeze + end + h.freeze + end + private_constant :STRPTIME_MONNAME_BY_INT_KEY end diff --git a/lib/date/core.rb b/lib/date/core.rb index ff00087c..4e285ffa 100644 --- a/lib/date/core.rb +++ b/lib/date/core.rb @@ -70,6 +70,50 @@ def initialize(year = -4712, month = 1, day = 1, start = DEFAULT_SG) @of = nil return self end + + # Julian fast path: JULIAN start, or year < REFORM_BEGIN_YEAR with reform-range start. + # Covers Date.civil(-4712, 1, 1) and Date.civil(2024, 6, 15, Date::JULIAN). + julian_fast = if start.is_a?(Float) && start.infinite? + start > 0 # JULIAN (+Infinity) + elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD + year < REFORM_BEGIN_YEAR + end + + if julian_fast + m = month + m += 13 if m < 0 + raise Error unless m >= 1 && m <= 12 + + # Julian leap year: divisible by 4 (no century exception) + leap = (year % 4 == 0) + last = MONTH_DAYS[leap ? 1 : 0][m] + d = day + d = last + d + 1 if d < 0 + raise Error unless d >= 1 && d <= last + + # Julian JD via integer arithmetic: + # jd = floor(365.25*(y+4716)) + floor(30.6001*(m+1)) + d - 1524 + # = (1461*(y+4716))/4 + (153*(m+1))/5 + d - 1524 + y2 = year; m2 = m + if m2 <= 2 + y2 -= 1 + m2 += 12 + end + jd = (1461 * (y2 + 4716)) / 4 + (153 * (m2 + 1)) / 5 + d - 1524 + + @nth = 0 + @jd = jd + @sg = start + @year = year + @month = m + @day = d + @has_jd = true + @has_civil = true + @df = nil + @sf = nil + @of = nil + return self + end end # Original path: handles non-Integer args, Julian/reform dates, fractional days @@ -242,14 +286,7 @@ def jd(jd = 0, start = DEFAULT_SG) obj.instance_variable_set(:@nth, 0) obj.instance_variable_set(:@jd, jd) obj.instance_variable_set(:@sg, start) - obj.instance_variable_set(:@year, 0) - obj.instance_variable_set(:@month, 0) - obj.instance_variable_set(:@day, 0) obj.instance_variable_set(:@has_jd, true) - obj.instance_variable_set(:@has_civil, false) - obj.instance_variable_set(:@df, nil) - obj.instance_variable_set(:@sf, nil) - obj.instance_variable_set(:@of, nil) return obj end end @@ -388,14 +425,7 @@ def ordinal(year = -4712, yday = 1, start = DEFAULT_SG) obj.instance_variable_set(:@nth, 0) obj.instance_variable_set(:@jd, rjd) obj.instance_variable_set(:@sg, start) - obj.instance_variable_set(:@year, 0) - obj.instance_variable_set(:@month, 0) - obj.instance_variable_set(:@day, 0) obj.instance_variable_set(:@has_jd, true) - obj.instance_variable_set(:@has_civil, false) - obj.instance_variable_set(:@df, nil) - obj.instance_variable_set(:@sf, nil) - obj.instance_variable_set(:@of, nil) return obj end end @@ -546,14 +576,7 @@ def commercial(cwyear = -4712, cweek = 1, cwday = 1, start = DEFAULT_SG) obj.instance_variable_set(:@nth, 0) obj.instance_variable_set(:@jd, rjd) obj.instance_variable_set(:@sg, start) - obj.instance_variable_set(:@year, 0) - obj.instance_variable_set(:@month, 0) - obj.instance_variable_set(:@day, 0) obj.instance_variable_set(:@has_jd, true) - obj.instance_variable_set(:@has_civil, false) - obj.instance_variable_set(:@df, nil) - obj.instance_variable_set(:@sf, nil) - obj.instance_variable_set(:@of, nil) return obj end end @@ -1672,6 +1695,8 @@ def check_limit(str, limit) # Date.new(2001, 2, 3).year # => 2001 # (Date.new(1, 1, 1) - 1).year # => 0 def year + # Hot path: inline m_real_year for the common case (@nth=0, civil cached) + return @year if @nth == 0 && @has_civil m_real_year end @@ -1682,11 +1707,15 @@ def year # # Date.new(2001, 2, 3).mon # => 2 def month + # Hot path: inline m_mon for the common case (civil cached) + return @month if @has_civil m_mon end alias mon month def day + # Hot path: inline m_mday for the common case (civil cached) + return @day if @has_civil m_mday end alias mday day @@ -1700,6 +1729,7 @@ def day # DateTime.new(2001,2,3,4,5,6,'+7').jd #=> 2451944 # DateTime.new(2001,2,3,4,5,6,'-7').jd #=> 2451944 def jd + return @jd if @nth == 0 && @has_jd m_real_jd end @@ -2344,7 +2374,17 @@ def -(other) end end - return minus_dd(other) if other.is_a?(Date) + if other.is_a?(Date) + # Hot path: both simple dates with @nth=0 and JD set. + # Result is always Rational(jd_self - jd_other, 1). + if @df.nil? && @sf.nil? && @of.nil? && @has_jd && @nth == 0 && + other.send(:simple_dat_p?) && + other.instance_variable_get(:@has_jd) && + other.instance_variable_get(:@nth) == 0 + return Rational(@jd - other.instance_variable_get(:@jd), 1) + end + return minus_dd(other) + end raise TypeError, "expected numeric" unless other.is_a?(Numeric) @@ -2419,6 +2459,10 @@ def julian? # # Date.new(2001, 2, 3).ld # => 152784 def ld + # Hot path: simple Date with @nth=0 and JD already set. + if @df.nil? && @sf.nil? && @of.nil? && @has_jd && @nth == 0 + return @jd - 2299160 + end m_real_local_jd - 2299160 end @@ -2430,23 +2474,23 @@ def ld # Date.new(2000).leap? # => true # Date.new(2001).leap? # => false def leap? - if gregorian? - # For the Gregorian calendar, get m_year to determine if it is a leap year. + return @leap unless @leap.nil? + result = if gregorian? + self.class.send(:c_gregorian_leap_p?, m_year) + else + # For the Julian calendar, calculate JD for March 1st. y = m_year + sg = m_virtual_sg + rjd, _ = self.class.send(:c_civil_to_jd, y, 3, 1, sg) - return self.class.send(:c_gregorian_leap_p?, y) - end - - # For the Julian calendar, calculate JD for March 1st. - y = m_year - sg = m_virtual_sg - rjd, _ = self.class.send(:c_civil_to_jd, y, 3, 1, sg) + # Get the date of the day before March 1st (the last day of February). + _, _, rd = self.class.send(:c_jd_to_civil, rjd - 1, sg) - # Get the date of the day before March 1st (the last day of February). - _, _, rd = self.class.send(:c_jd_to_civil, rjd - 1, sg) - - # If February 29th exists, it is a leap year. - rd == 29 + # If February 29th exists, it is a leap year. + rd == 29 + end + @leap = result unless frozen? + result end # call-seq: @@ -2590,6 +2634,8 @@ def saturday? # # Date.new(2001, 2, 3).wday # => 6 def wday + # Hot path: inline m_wday for simple Date (C: (jd + 1) % 7) + return (@jd + 1) % 7 if @has_jd && @of.nil? m_wday end @@ -2600,7 +2646,10 @@ def wday # # Date.new(2001, 2, 3).yday # => 34 def yday - m_yday + return @yday if @yday + val = m_yday + @yday = val unless frozen? + val end # call-seq: @@ -2775,6 +2824,10 @@ def day_fraction # DateTime.new(2001,2,3,4,5,6,'+7').mjd #=> 51943 # DateTime.new(2001,2,3,4,5,6,'-7').mjd #=> 51943 def mjd + # Hot path: simple Date with @nth=0 and JD already set. + if @df.nil? && @sf.nil? && @of.nil? && @has_jd && @nth == 0 + return @jd - 2_400_001 + end m_real_local_jd - 2_400_001 end @@ -2847,7 +2900,13 @@ def to_date # # Returns a DateTime whose value is the same as +self+. def to_datetime - # Use internal constructor to bypass validation (reform-gap safety) + # Hot path: simple Date with JD already set. + # C: d_lite_to_datetime passes @nth, @jd, @sg directly (no civil->JD conversion). + if @df.nil? && @sf.nil? && @of.nil? && @has_jd + return DateTime.send(:new_with_jd_and_time, @nth, @jd, 0, 0, 0, @sg) + end + + # Original path for complex dates or JD-less simple dates. nth, ry = self.class.send(:decode_year, year, -1) rjd, _ = self.class.send(:c_civil_to_jd, ry, month, day, Date::GREGORIAN) obj = DateTime.send(:new_with_jd_and_time, nth, rjd, 0, 0, 0, Date::GREGORIAN) @@ -2864,6 +2923,11 @@ def to_datetime # DateTime.new(2001,2,3,4,5,6,'+7').ajd #=> (11769328217/4800) # DateTime.new(2001,2,2,14,5,6,'-7').ajd #=> (11769328217/4800) def ajd + # Hot path: simple Date with @nth=0 and JD already set. + # ajd = jd - 1/2 = Rational(jd * 2 - 1, 2) + if @df.nil? && @sf.nil? && @of.nil? && @has_jd && @nth == 0 + return Rational(@jd * 2 - 1, 2) + end m_ajd end @@ -2876,6 +2940,11 @@ def ajd # DateTime.new(2001,2,3,4,5,6,'+7').amjd #=> (249325817/4800) # DateTime.new(2001,2,2,14,5,6,'-7').amjd #=> (249325817/4800) def amjd + # Hot path: simple Date with @nth=0 and JD already set. + # amjd = jd - 2400001 as Rational + if @df.nil? && @sf.nil? && @of.nil? && @has_jd && @nth == 0 + return Rational(@jd - 2400001, 1) + end m_amjd end @@ -2970,7 +3039,22 @@ def marshal_load(array) # See {asctime}[https://linux.die.net/man/3/asctime]. # def asctime - strftime('%a %b %e %H:%M:%S %Y') + if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil && @has_jd + y = @year + wday = (@jd + 1) % 7 + ed = @day < 10 ? " #{@day}" : @day.to_s + y_str = if y >= 0 && y <= 9999 + FOUR_DIGIT[y] + elsif y >= 0 + sprintf("%04d", y) + else + sprintf("%05d", y) + end + str = "#{ABBR_DAYNAMES[wday]} #{ABBR_MONTHNAMES[@month]} #{ed} 00:00:00 #{y_str}" + str.force_encoding(Encoding::US_ASCII) + else + strftime('%a %b %e %H:%M:%S %Y') + end end alias_method :ctime, :asctime @@ -2983,7 +3067,19 @@ def asctime # # Date.new(2001, 2, 3).iso8601 # => "2001-02-03" def iso8601 - strftime('%Y-%m-%d') + if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil + y = @year + str = if y >= 0 && y <= 9999 + "#{FOUR_DIGIT[y]}-#{TWO_DIGIT[@month]}-#{TWO_DIGIT[@day]}" + elsif y >= 0 + sprintf("%04d-%02d-%02d", y, @month, @day) + else + sprintf("%05d-%02d-%02d", y, @month, @day) + end + str.force_encoding(Encoding::US_ASCII) + else + strftime('%Y-%m-%d') + end end alias_method :xmlschema, :iso8601 @@ -2995,7 +3091,19 @@ def iso8601 # # Date.new(2001, 2, 3).rfc3339 # => "2001-02-03T00:00:00+00:00" def rfc3339 - strftime('%Y-%m-%dT%H:%M:%S%:z') + if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil + y = @year + str = if y >= 0 && y <= 9999 + "#{FOUR_DIGIT[y]}-#{TWO_DIGIT[@month]}-#{TWO_DIGIT[@day]}T00:00:00+00:00" + elsif y >= 0 + sprintf("%04d-%02d-%02dT00:00:00+00:00", y, @month, @day) + else + sprintf("%05d-%02d-%02dT00:00:00+00:00", y, @month, @day) + end + str.force_encoding(Encoding::US_ASCII) + else + strftime('%Y-%m-%dT%H:%M:%S%:z') + end end # call-seq: @@ -3006,7 +3114,21 @@ def rfc3339 # # Date.new(2001, 2, 3).rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000" def rfc2822 - strftime('%a, %-d %b %Y %T %z') + if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil && @has_jd + y = @year + wday = (@jd + 1) % 7 + y_str = if y >= 0 && y <= 9999 + FOUR_DIGIT[y] + elsif y >= 0 + sprintf("%04d", y) + else + sprintf("%05d", y) + end + str = "#{ABBR_DAYNAMES[wday]}, #{@day} #{ABBR_MONTHNAMES[@month]} #{y_str} 00:00:00 +0000" + str.force_encoding(Encoding::US_ASCII) + else + strftime('%a, %-d %b %Y %T %z') + end end alias_method :rfc822, :rfc2822 @@ -3019,8 +3141,22 @@ def rfc2822 # Date.new(2001, 2, 3).httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT" # def httpdate - # For Date objects, offset is always 0, so we can directly call strftime - strftime('%a, %d %b %Y %T GMT') + if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil + get_s_jd + y = @year + wday = (@jd + 1) % 7 + y_str = if y >= 0 && y <= 9999 + FOUR_DIGIT[y] + elsif y >= 0 + sprintf("%04d", y) + else + sprintf("%05d", y) + end + str = "#{ABBR_DAYNAMES[wday]}, #{TWO_DIGIT[@day]} #{ABBR_MONTHNAMES[@month]} #{y_str} 00:00:00 GMT" + str.force_encoding(Encoding::US_ASCII) + else + strftime('%a, %d %b %Y %T GMT') + end end # call-seq: @@ -3032,11 +3168,44 @@ def httpdate # Date.new(2001, 2, 3).jisx0301 # => "H13.02.03" # def jisx0301 - jd = m_real_local_jd - y = m_real_year - - fmt = jisx0301_date_format(jd, y) - strftime(fmt) + if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil + get_s_jd + jd = @jd + y = @year + mm = TWO_DIGIT[@month] + dd = TWO_DIGIT[@day] + str = if !jd.is_a?(Integer) || jd < 2405160 + # Pre-Meiji or non-integer JD: ISO format + if y >= 0 && y <= 9999 + "#{FOUR_DIGIT[y]}-#{mm}-#{dd}" + elsif y >= 0 + sprintf("%04d-%02d-%02d", y, @month, @day) + else + sprintf("%05d-%02d-%02d", y, @month, @day) + end + elsif jd < 2419614 + ey = y - 1867 + "M#{ey < 100 ? TWO_DIGIT[ey] : sprintf('%02d', ey)}.#{mm}.#{dd}" + elsif jd < 2424875 + ey = y - 1911 + "T#{ey < 100 ? TWO_DIGIT[ey] : sprintf('%02d', ey)}.#{mm}.#{dd}" + elsif jd < 2447535 + ey = y - 1925 + "S#{ey < 100 ? TWO_DIGIT[ey] : sprintf('%02d', ey)}.#{mm}.#{dd}" + elsif jd < 2458605 + ey = y - 1988 + "H#{ey < 100 ? TWO_DIGIT[ey] : sprintf('%02d', ey)}.#{mm}.#{dd}" + else + ey = y - 2018 + "R#{ey < 100 ? TWO_DIGIT[ey] : sprintf('%02d', ey)}.#{mm}.#{dd}" + end + str.force_encoding(Encoding::US_ASCII) + else + jd = m_real_local_jd + y = m_real_year + fmt = jisx0301_date_format(jd, y) + strftime(fmt) + end end def to_s @@ -3644,28 +3813,70 @@ def f_jd(other) end def dup_obj_with_new_start(sg) - dup = dup_obj - dup.send(:set_sg, sg) - - dup + if @df.nil? && @sf.nil? && @of.nil? + # Fast path for simple Date (no time/offset components). + # Absolute hot path: nth==0 (common Gregorian date) with JD already cached. + if @nth == 0 && @has_jd + new_obj = self.class.send(:allocate) + new_obj.instance_variable_set(:@nth, 0) + new_obj.instance_variable_set(:@jd, @jd) + new_obj.instance_variable_set(:@sg, sg) + new_obj.instance_variable_set(:@df, nil) + new_obj.instance_variable_set(:@sf, nil) + new_obj.instance_variable_set(:@of, nil) + new_obj.instance_variable_set(:@year, nil) + new_obj.instance_variable_set(:@month, nil) + new_obj.instance_variable_set(:@day, nil) + new_obj.instance_variable_set(:@has_jd, true) + new_obj.instance_variable_set(:@has_civil, false) + return new_obj + end + # General simple path: inline get_s_jd and canon(@nth). + unless @has_jd + if @has_civil + jd, _ = self.class.send(:c_civil_to_jd, @year, @month, @day, s_virtual_sg) + @jd = jd + @has_jd = true + end + end + nth = @nth + nth = nth.numerator if nth.is_a?(Rational) && nth.denominator == 1 + new_obj = self.class.send(:allocate) + new_obj.instance_variable_set(:@nth, nth) + new_obj.instance_variable_set(:@jd, @jd) + new_obj.instance_variable_set(:@sg, sg) + new_obj.instance_variable_set(:@df, nil) + new_obj.instance_variable_set(:@sf, nil) + new_obj.instance_variable_set(:@of, nil) + new_obj.instance_variable_set(:@year, nil) + new_obj.instance_variable_set(:@month, nil) + new_obj.instance_variable_set(:@day, nil) + new_obj.instance_variable_set(:@has_jd, @has_jd) + new_obj.instance_variable_set(:@has_civil, false) + new_obj + else + dup = dup_obj + dup.send(:set_sg, sg) + dup + end end def dup_obj if simple_dat_p? - # Simple data replication - new_obj = self.class.send(:d_lite_s_alloc_simple) + # Simple data replication: allocate directly, avoid d_lite_s_alloc_simple overhead + new_obj = self.class.send(:allocate) new_obj.instance_variable_set(:@nth, canon(@nth)) new_obj.instance_variable_set(:@jd, @jd) new_obj.instance_variable_set(:@sg, @sg) + new_obj.instance_variable_set(:@df, nil) + new_obj.instance_variable_set(:@sf, nil) + new_obj.instance_variable_set(:@of, nil) new_obj.instance_variable_set(:@year, @year) new_obj.instance_variable_set(:@month, @month) new_obj.instance_variable_set(:@day, @day) new_obj.instance_variable_set(:@has_jd, @has_jd) new_obj.instance_variable_set(:@has_civil, @has_civil) - new_obj.instance_variable_set(:@df, nil) - new_obj.instance_variable_set(:@sf, nil) - new_obj.instance_variable_set(:@of, nil) new_obj else @@ -3882,20 +4093,24 @@ def m_real_cwyear end def m_cwyear - jd = m_local_jd - sg = m_virtual_sg - - ry, _, _ = self.class.send(:c_jd_to_commercial, jd, sg) - + return @cwyear if @has_commercial + ry, rw, _ = self.class.send(:c_jd_to_commercial, m_local_jd, m_virtual_sg) + unless frozen? + @cwyear = ry + @cweek = rw + @has_commercial = true + end ry end def m_cweek - jd = m_local_jd - sg = m_virtual_sg - - _, rw, _ = self.class.send(:c_jd_to_commercial, jd, sg) - + return @cweek if @has_commercial + ry, rw, _ = self.class.send(:c_jd_to_commercial, m_local_jd, m_virtual_sg) + unless frozen? + @cwyear = ry + @cweek = rw + @has_commercial = true + end rw end diff --git a/lib/date/parse.rb b/lib/date/parse.rb index 095a522f..e560b3bb 100644 --- a/lib/date/parse.rb +++ b/lib/date/parse.rb @@ -1914,14 +1914,11 @@ def subx(str, pat, rep = " ") def check_class(str) flags = 0 - str.each_char do |c| - flags |= HAVE_ALPHA if c =~ /[a-zA-Z]/ - flags |= HAVE_DIGIT if c =~ /\d/ - flags |= HAVE_DASH if c == '-' - flags |= HAVE_DOT if c == '.' - flags |= HAVE_SLASH if c == '/' - end - + flags |= HAVE_ALPHA if str.match?(/[a-zA-Z]/) + flags |= HAVE_DIGIT if str.match?(/\d/) + flags |= HAVE_DASH if str.include?('-') + flags |= HAVE_DOT if str.include?('.') + flags |= HAVE_SLASH if str.include?('/') flags end diff --git a/lib/date/strftime.rb b/lib/date/strftime.rb index eacec7a0..b4e3f020 100644 --- a/lib/date/strftime.rb +++ b/lib/date/strftime.rb @@ -20,6 +20,53 @@ def strftime(format = STRFTIME_DEFAULT_FMT) # Empty format returns empty string return '' if format.empty? + # Fast path: simple Date (no time/offset, @nth == 0) with civil fields cached. + # Covers the most common case for Date objects created via Date.new or Date.civil. + if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil && !format.include?("\0") + y = @year + case format + when '%Y-%m-%d', '%F' + str = if y >= 0 && y <= 9999 + "#{FOUR_DIGIT[y]}-#{TWO_DIGIT[@month]}-#{TWO_DIGIT[@day]}" + elsif y >= 0 + sprintf("%04d-%02d-%02d", y, @month, @day) + else + sprintf("%05d-%02d-%02d", y, @month, @day) + end + return str.force_encoding(format.encoding) + when '%Y-%m-%dT%H:%M:%S%z' + str = if y >= 0 && y <= 9999 + "#{FOUR_DIGIT[y]}-#{TWO_DIGIT[@month]}-#{TWO_DIGIT[@day]}T00:00:00+0000" + elsif y >= 0 + sprintf("%04d-%02d-%02dT00:00:00+0000", y, @month, @day) + else + sprintf("%05d-%02d-%02dT00:00:00+0000", y, @month, @day) + end + return str.force_encoding(format.encoding) + when '%x' + # %x = %m/%d/%y + str = "#{TWO_DIGIT[@month]}/#{TWO_DIGIT[@day]}/#{TWO_DIGIT[y % 100]}" + return str.force_encoding(format.encoding) + end + + # Formats that also require wday (needs @jd). + if @has_jd + wday = (@jd + 1) % 7 + case format + when '%c' + # %c = %a %b %e %H:%M:%S %Y (always 24 chars for 4-digit year) + ed = @day < 10 ? " #{@day}" : @day.to_s + y_str = (y >= 0 && y <= 9999) ? FOUR_DIGIT[y] : (y >= 0 ? sprintf("%04d", y) : sprintf("%05d", y)) + str = "#{ABBR_DAYNAMES[wday]} #{ABBR_MONTHNAMES[@month]} #{ed} 00:00:00 #{y_str}" + return str.force_encoding(format.encoding) + when '%A, %B %d, %Y' + y_str = (y >= 0 && y <= 9999) ? FOUR_DIGIT[y] : (y >= 0 ? sprintf("%04d", y) : sprintf("%05d", y)) + str = "#{DAYNAMES[wday]}, #{MONTHNAMES[@month]} #{TWO_DIGIT[@day]}, #{y_str}" + return str.force_encoding(format.encoding) + end + end + end + # What to do if format string contains a "\0". if format.include?("\0") result = String.new @@ -172,113 +219,204 @@ def decode_offset(of) end # Processing format strings. + # Uses format.index('%') to scan literal sections in bulk, avoiding + # per-character String allocation from format[i] indexing. def strftime_format(format) result = String.new - i = 0 + pos = 0 + fmt_len = format.length + + # Detect simple Date (no time/offset) with both civil and JD fields cached. + # Precompute frequently accessed values to bypass the tmx_* method chain. + if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil && @has_jd + f_year = @year + f_month = @month + f_day = @day + f_wday = (@jd + 1) % 7 + is_simple = true + else + is_simple = false + end - while i < format.length - if format[i] == '%' && i + 1 < format.length - # Skip '%' - i += 1 + while pos < fmt_len + # Find next '%' starting from current position. + pct = format.index('%', pos) - # C: Parse all modifiers in a flat loop (flags, width, colons, E/O) - flags = String.new - width = String.new - modifier = nil - colons = 0 - - while i < format.length - c = format[i] - case c - when 'E', 'O' - modifier = c - i += 1 - when ':' - colons += 1 - i += 1 - when '-', '_', '^', '#' - flags << c - i += 1 - when '0' - # '0' is a flag only when width is still empty - if width.empty? - flags << c - i += 1 - else - width << c - i += 1 - end - when /[1-9]/ - width << c - i += 1 - # Continue reading remaining digits - while i < format.length && format[i] =~ /[0-9]/ - width << format[i] - i += 1 - end + if pct.nil? + # No more format specs — append remaining literal text as a block. + result << format[pos..] if pos < fmt_len + break + end + + # Append literal text before this '%' as a single block copy. + result << format[pos, pct - pos] if pct > pos + + i = pct + 1 + if i >= fmt_len + # Trailing '%' with nothing after — append as literal (matches C behavior). + result << '%' + break + end + + # Parse all modifiers in a flat loop (flags, width, colons, E/O). + # flags: integer bitmask (FLAG_MINUS | FLAG_SPACE | FLAG_UPPER | FLAG_CHCASE | FLAG_ZERO) + # width: integer (-1 = not specified) + flags = 0 + width = -1 + modifier = nil + colons = 0 + + while i < fmt_len + c = format[i] + case c + when 'E', 'O' + modifier = c + i += 1 + when ':' + colons += 1 + i += 1 + when '-' + flags |= FLAG_MINUS + i += 1 + when '_' + flags |= FLAG_SPACE + i += 1 + when '^' + flags |= FLAG_UPPER + i += 1 + when '#' + flags |= FLAG_CHCASE + i += 1 + when '0' + # '0' is a flag only when width is not yet started + if width == -1 + flags |= FLAG_ZERO else - break + width = width * 10 end - end - - # Invalid if both E/O and colon modifiers are present. - if modifier && colons > 0 - if i < format.length - spec = format[i] - result << "%#{modifier}#{':' * colons}#{spec}" + i += 1 + when '1'..'9' + width = format[i].ord - 48 + i += 1 + # Continue reading remaining digits + while i < fmt_len + d = format[i] + break if d < '0' || d > '9' + width = width * 10 + (d.ord - 48) i += 1 end - next + else + break end + end - # Width specifier overflow check - unless width.empty? - if width.length > 10 || (width.length == 10 && width > '2147483647') - raise Errno::ERANGE, "Result too large" - end - if width.to_i >= 1024 - raise Errno::ERANGE, "Result too large" - end + # Invalid if both E/O and colon modifiers are present. + if modifier && colons > 0 + if i < fmt_len + spec = format[i] + result << "%#{modifier}#{':' * colons}#{spec}" + i += 1 end + pos = i + next + end - if i < format.length - spec = format[i] + # Width specifier overflow check + if width != -1 && width >= 1024 + raise Errno::ERANGE, "Result too large" + end - if modifier - # E/O modifier check must come first - valid = case modifier - when 'E' - %w[c C x X y Y].include?(spec) - when 'O' - %w[d e H k I l m M S u U V w W y].include?(spec) - else - false - end + if i < fmt_len + spec = format[i] - if valid - formatted = format_spec(spec, flags, width) - result << formatted + if modifier + # E/O modifier check must come first + valid = case modifier + when 'E' + %w[c C x X y Y].include?(spec) + when 'O' + %w[d e H k I l m M S u U V w W y].include?(spec) + else + false + end + + if valid + result << format_spec(spec, flags, width) + else + result << "%#{modifier}#{flags_to_s(flags)}#{width == -1 ? '' : width}#{spec}" + end + elsif spec == 'z' + if is_simple && flags == 0 && width == -1 && colons == 0 + # Simple Date: offset is always 0, result is always '+0000'. + result << '+0000' + else + result << format_z(tmx_offset, width, flags, colons) + end + elsif colons > 0 + # Colon modifier is only valid for 'z'. + result << "%#{':' * colons}#{flags_to_s(flags)}#{width == -1 ? '' : width}#{spec}" + elsif is_simple && flags == 0 && width == -1 + # Fast path: simple Date with no flags or width — bypass tmx_* method chain. + case spec + when 'Y' + raise Errno::ERANGE, "Result too large" if f_year.bit_length > 128 + if f_year >= 0 && f_year <= 9999 + result << FOUR_DIGIT[f_year] else - result << "%#{modifier}#{flags}#{width}#{spec}" + result << sprintf("%0#{f_year < 0 ? 5 : 4}d", f_year) end - elsif spec == 'z' - # %z with any combination of colons/width/flags - formatted = format_z(tmx_offset, width, flags, colons) - result << formatted - elsif colons > 0 - # Colon modifier is only valid for 'z'. - result << "%#{':' * colons}#{flags}#{width}#{spec}" + when 'C' + c = f_year / 100 + result << (c >= 0 && c < 100 ? TWO_DIGIT[c] : sprintf('%02d', c)) + when 'y' + result << TWO_DIGIT[f_year % 100] + when 'm' + result << TWO_DIGIT[f_month] + when 'd' + result << TWO_DIGIT[f_day] + when 'e' + result << sprintf('%2d', f_day) + when 'A' + result << (DAYNAMES[f_wday] || '?') + when 'a' + result << (ABBR_DAYNAMES[f_wday] || '?')[0, 3] + when 'B' + result << (MONTHNAMES[f_month] || '?') + when 'b', 'h' + result << (ABBR_MONTHNAMES[f_month] || '?')[0, 3] + when 'H', 'M', 'S' + result << '00' + when 'I', 'l' + # hour=0 → h = 0%12 = 0 → h = 12 + result << '12' + when 'k' + # sprintf('%2d', 0) = ' 0' + result << ' 0' + when 'P' + result << 'am' # hour=0 < 12 + when 'p' + result << 'AM' + when 'w' + result << f_wday.to_s + when 'Z' + result << '+00:00' + when '%' + result << '%' + when 'n' + result << "\n" + when 't' + result << "\t" else - formatted = format_spec(spec, flags, width) - result << formatted + result << format_spec(spec, flags, width) end - - i += 1 + else + result << format_spec(spec, flags, width) end - else - result << format[i] + i += 1 end + + pos = i end result.force_encoding('US-ASCII') if result.ascii_only? @@ -286,11 +424,22 @@ def strftime_format(format) result end - def format_spec(spec, flags = '', width = '') + def flags_to_s(flags) + return '' if flags == 0 + s = ''.dup + s << '-' if flags & FLAG_MINUS != 0 + s << '_' if flags & FLAG_SPACE != 0 + s << '^' if flags & FLAG_UPPER != 0 + s << '#' if flags & FLAG_CHCASE != 0 + s << '0' if flags & FLAG_ZERO != 0 + s + end + + def format_spec(spec, flags = 0, width = -1) # N/L: width controls precision (number of fractional digits) if spec == 'N' || spec == 'L' - precision = if !width.empty? - width.to_i + precision = if width != -1 + width elsif spec == 'L' 3 else @@ -308,8 +457,7 @@ def format_spec(spec, flags = '', width = '') base_result = apply_case_flags(base_result, spec, flags) # Apply width specifier. - if !width.empty? - width_num = width.to_i + if width != -1 default_pad = if NUMERIC_SPECS.include?(spec) '0' elsif SPACE_PAD_SPECS.include?(spec) @@ -317,7 +465,7 @@ def format_spec(spec, flags = '', width = '') else ' ' end - apply_width(base_result, width_num, flags, default_pad) + apply_width(base_result, width, flags, default_pad) else base_result end @@ -325,9 +473,9 @@ def format_spec(spec, flags = '', width = '') # C: Apply ^ (UPPER) and # (CHCASE) flags def apply_case_flags(str, spec, flags) - if flags.include?('^') + if flags & FLAG_UPPER != 0 str.upcase - elsif flags.include?('#') + elsif flags & FLAG_CHCASE != 0 if CHCASE_UPPER_SPECS.include?(spec) str.upcase elsif CHCASE_LOWER_SPECS.include?(spec) @@ -341,94 +489,99 @@ def apply_case_flags(str, spec, flags) end # format specifiers - def get_base_format(spec, flags = '') + def get_base_format(spec, flags = 0) case spec when 'Y' # 4-digit year y = tmx_year raise Errno::ERANGE, "Result too large" if y.is_a?(Integer) && y.bit_length > 128 # C: FMT('0', y >= 0 ? 4 : 5, "ld", y) - prec = y < 0 ? 5 : 4 - if flags.include?('-') + if flags & FLAG_MINUS != 0 y.to_s - elsif flags.include?('_') - sprintf("%#{prec}d", y) + elsif flags & FLAG_SPACE != 0 + sprintf("%#{y < 0 ? 5 : 4}d", y) + elsif y >= 0 && y <= 9999 + FOUR_DIGIT[y] else - sprintf("%0#{prec}d", y) + sprintf("%0#{y < 0 ? 5 : 4}d", y) end when 'C' # Century - sprintf('%02d', tmx_year / 100) + c = tmx_year / 100 + c >= 0 && c < 100 ? TWO_DIGIT[c] : sprintf('%02d', c) when 'y' # Two-digit year - sprintf('%02d', tmx_year % 100) + TWO_DIGIT[tmx_year % 100] when 'm' # Month (01-12) - sprintf('%02d', tmx_mon) + if flags & FLAG_MINUS != 0 + tmx_mon.to_s + elsif flags & FLAG_SPACE != 0 + sprintf('%2d', tmx_mon) + else + TWO_DIGIT[tmx_mon] + end when 'B' # Full month name MONTHNAMES[tmx_mon] || '?' when 'b', 'h' # Abbreviated month name (ABBR_MONTHNAMES[tmx_mon] || '?')[0, 3] when 'd' # Day (01-31) - if flags.include?('-') - # Left-justified (no padding) + if flags & FLAG_MINUS != 0 tmx_mday.to_s - elsif flags.include?('_') - # Space-padded + elsif flags & FLAG_SPACE != 0 sprintf('%2d', tmx_mday) else - # Zero-padded (default) - sprintf('%02d', tmx_mday) + TWO_DIGIT[tmx_mday] end when 'e' # Day (1-31) blank filled - if flags.include?('-') + if flags & FLAG_MINUS != 0 tmx_mday.to_s - elsif flags.include?('0') - sprintf('%02d', tmx_mday) + elsif flags & FLAG_ZERO != 0 + TWO_DIGIT[tmx_mday] else sprintf('%2d', tmx_mday) end when 'j' # Day of the year (001-366) - if flags.include?('-') + if flags & FLAG_MINUS != 0 tmx_yday.to_s else sprintf('%03d', tmx_yday) end when 'H' # Hour (00-23) - if flags.include?('-') + if flags & FLAG_MINUS != 0 tmx_hour.to_s - elsif flags.include?('_') + elsif flags & FLAG_SPACE != 0 sprintf('%2d', tmx_hour) else - sprintf('%02d', tmx_hour) + TWO_DIGIT[tmx_hour] end when 'k' # Hour (0-23) blank-padded sprintf('%2d', tmx_hour) when 'I' # Hour (01-12) h = tmx_hour % 12 h = 12 if h.zero? - if flags.include?('-') + if flags & FLAG_MINUS != 0 h.to_s - elsif flags.include?('_') + elsif flags & FLAG_SPACE != 0 sprintf('%2d', h) else - sprintf('%02d', h) + TWO_DIGIT[h] end when 'l' # Hour (1-12) blank filled h = tmx_hour % 12 h = 12 if h.zero? sprintf('%2d', h) when 'M' # Minutes (00-59) - if flags.include?('-') + if flags & FLAG_MINUS != 0 tmx_min.to_s - elsif flags.include?('_') + elsif flags & FLAG_SPACE != 0 sprintf('%2d', tmx_min) else - sprintf('%02d', tmx_min) + TWO_DIGIT[tmx_min] end when 'S' # Seconds (00-59) - if flags.include?('-') + if flags & FLAG_MINUS != 0 tmx_sec.to_s - elsif flags.include?('_') + elsif flags & FLAG_SPACE != 0 sprintf('%2d', tmx_sec) else - sprintf('%02d', tmx_sec) + TWO_DIGIT[tmx_sec] end when 'L' # Milliseconds (000-999) sprintf('%09d', (tmx_sec_fraction * 1_000_000_000).floor) @@ -451,25 +604,26 @@ def get_base_format(spec, flags = '') when 'u' # Day of the week (1-7, Monday is 1) tmx_cwday.to_s when 'U' # Week number (00-53, Sunday start) - sprintf('%02d', tmx_wnum0) + TWO_DIGIT[tmx_wnum0] when 'W' # Week number (00-53, Monday start) - sprintf('%02d', tmx_wnum1) + TWO_DIGIT[tmx_wnum1] when 'V' # ISO week number (01-53) - sprintf('%02d', tmx_cweek) + TWO_DIGIT[tmx_cweek] when 'G' # ISO week year y = tmx_cwyear - prec = y < 0 ? 5 : 4 - if flags.include?('-') + if flags & FLAG_MINUS != 0 y.to_s - elsif flags.include?('_') - sprintf("%#{prec}d", y) + elsif flags & FLAG_SPACE != 0 + sprintf("%#{y < 0 ? 5 : 4}d", y) + elsif y >= 0 && y <= 9999 + FOUR_DIGIT[y] else - sprintf("%0#{prec}d", y) + sprintf("%0#{y < 0 ? 5 : 4}d", y) end when 'g' # ISO week year (2 digits) - sprintf('%02d', tmx_cwyear % 100) + TWO_DIGIT[tmx_cwyear % 100] when 'z' # Time Zone Offset (+0900) — handled by format_z in format_spec - format_z(tmx_offset, '', '', 0) + format_z(tmx_offset, -1, 0, 0) when 'Z' # Time Zone Name tmx_zone || '' when 's' # Number of seconds since the Unix epoch @@ -511,14 +665,14 @@ def get_base_format(spec, flags = '') def apply_width(str, width, flags, default_pad = ' ') # '-' flag means no padding at all - return str if flags.include?('-') + return str if flags & FLAG_MINUS != 0 return str if str.length >= width # Determine a padding character. padding = - if flags.include?('0') + if flags & FLAG_ZERO != 0 '0' - elsif flags.include?('_') + elsif flags & FLAG_SPACE != 0 ' ' else default_pad @@ -529,7 +683,8 @@ def apply_width(str, width, flags, default_pad = ' ') # C: format %z with width/flags/colons support # Matches date_strftime.c case 'z' logic exactly. - def format_z(offset, width_str, flags, colons) + # width: integer (-1 = not specified), flags: integer bitmask + def format_z(offset, width, flags, colons) sign = offset < 0 ? '-' : '+' aoff = offset.abs hours = aoff / 3600 @@ -538,9 +693,9 @@ def format_z(offset, width_str, flags, colons) hl = hours < 10 ? 1 : 2 # actual digits needed for hours hw = 2 # default hour width - hw = 1 if flags.include?('-') && hl == 1 + hw = 1 if flags & FLAG_MINUS != 0 && hl == 1 - precision = width_str.empty? ? -1 : width_str.to_i + precision = width # -1 means not specified # Calculate fixed chars (everything except hour digits) per colons variant fixed = case colons @@ -565,7 +720,7 @@ def format_z(offset, width_str, flags, colons) result = String.new # C: space padding — print spaces before sign, reduce hour precision - if flags.include?('_') && hp > hl + if flags & FLAG_SPACE != 0 && hp > hl result << ' ' * (hp - hl) hp = hl end diff --git a/lib/date/strptime.rb b/lib/date/strptime.rb index e73bfc55..d4889ca6 100644 --- a/lib/date/strptime.rb +++ b/lib/date/strptime.rb @@ -1,4 +1,5 @@ # frozen_string_literal: true +require 'strscan' # Implementation of ruby/date/ext/date/date_strptime.c class Date @@ -19,37 +20,85 @@ class << self # # Related: Date.strptime (returns a \Date object). def _strptime(string, format = '%F') - str = string.dup - pos = 0 + # Fast paths for the most common format strings. + case format + when '%F', '%Y-%m-%d' + m = /\A([+-]?\d+)-(\d{1,2})-(\d{1,2})/.match(string) + return nil unless m + mon = m[2].to_i + mday = m[3].to_i + return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 + h = { year: m[1].to_i, mon: mon, mday: mday } + rest = m.post_match + h[:leftover] = rest unless rest.empty? + return h + + when '%Y-%m-%d %H:%M:%S' + m = /\A([+-]?\d+)-(\d{1,2})-(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})/.match(string) + return nil unless m + mon = m[2].to_i + mday = m[3].to_i + hour = m[4].to_i + min = m[5].to_i + sec = m[6].to_i + return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 + return nil if hour > 24 || min > 59 || sec > 60 + h = { year: m[1].to_i, mon: mon, mday: mday, hour: hour, min: min, sec: sec } + rest = m.post_match + h[:leftover] = rest unless rest.empty? + return h + + when '%Y-%m-%dT%H:%M:%S' + m = /\A([+-]?\d+)-(\d{1,2})-(\d{1,2})T(\d{1,2}):(\d{1,2}):(\d{1,2})/.match(string) + return nil unless m + mon = m[2].to_i + mday = m[3].to_i + hour = m[4].to_i + min = m[5].to_i + sec = m[6].to_i + return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 + return nil if hour > 24 || min > 59 || sec > 60 + h = { year: m[1].to_i, mon: mon, mday: mday, hour: hour, min: min, sec: sec } + rest = m.post_match + h[:leftover] = rest unless rest.empty? + return h + end + + ss = StringScanner.new(string) hash = {} i = 0 - while i < format.length - if format[i] == '%' && i + 1 < format.length + fmt_len = format.length + while i < fmt_len + fb = format.getbyte(i) + if fb == 37 && i + 1 < fmt_len # '%' i += 1 # Parse modifier (E, O) modifier = nil - if i < format.length && (format[i] == 'E' || format[i] == 'O') - modifier = format[i] + fb2 = format.getbyte(i) + if i < fmt_len && (fb2 == 69 || fb2 == 79) # 'E' == 69, 'O' == 79 + modifier = fb2 == 69 ? 'E' : 'O' i += 1 end # Parse colons for %:z, %::z, %:::z colons = 0 - while i < format.length && format[i] == ':' + while i < fmt_len && format.getbyte(i) == 58 # ':' colons += 1 i += 1 end - # Parse width - width_str = String.new - while i < format.length && format[i] =~ /[0-9]/ - width_str << format[i] + # Parse width as integer (avoids String allocation and regex digit check) + field_width = nil + while i < fmt_len + db = format.getbyte(i) + break if db < 48 || db > 57 # '0'..'9' + field_width = (field_width || 0) * 10 + db - 48 i += 1 end - break if i >= format.length + break if i >= fmt_len spec = format[i] i += 1 @@ -65,10 +114,9 @@ def _strptime(string, format = '%F') false end unless valid - # Invalid modifier - try to match literal - literal = "%#{modifier}#{':' * colons}#{width_str}#{spec}" - if str[pos, literal.length] == literal - pos += literal.length + literal = "%#{modifier}#{':' * colons}#{field_width}#{spec}" + if ss.string[ss.pos, literal.length] == literal + ss.pos += literal.length else return nil end @@ -78,9 +126,9 @@ def _strptime(string, format = '%F') # Handle colon+z if colons > 0 && spec == 'z' - result = _strptime_zone_colon(str, pos, colons) + result = _strptime_zone_colon(ss.string, ss.pos, colons) return nil unless result - pos = result[:pos] + ss.pos = result[:pos] hash[:zone] = result[:zone] hash[:offset] = result[:offset] next @@ -89,33 +137,25 @@ def _strptime(string, format = '%F') return nil end - # Determine field width - field_width = width_str.empty? ? nil : width_str.to_i - # C: NUM_PATTERN_P() - check if next format element is a digit-consuming pattern. - # Used by %C, %G, %L, %N, %Y to limit digit consumption when adjacent. next_is_num = num_pattern_p(format, i) - result = _strptime_spec(str, pos, spec, field_width, hash, next_is_num) - return nil unless result - pos = result[:pos] - hash.merge!(result[:hash]) if result[:hash] - elsif format[i] == '%' && i + 1 == format.length - # Trailing % - match literal - if pos < str.length && str[pos] == '%' - pos += 1 + return nil unless _strptime_spec(ss, spec, field_width, hash, next_is_num) + elsif fb == 37 && i + 1 == fmt_len # Trailing % - match literal + if ss.string.getbyte(ss.pos) == 37 # '%' + ss.pos += 1 else return nil end i += 1 - elsif format[i] =~ /\s/ + elsif fb == 32 || fb == 9 || fb == 10 || fb == 13 || fb == 11 || fb == 12 # whitespace # Whitespace in format matches zero or more whitespace in input i += 1 - pos += 1 while pos < str.length && str[pos] =~ /\s/ + skip_ws(ss) else # Literal match - if pos < str.length && str[pos] == format[i] - pos += 1 + if ss.string.getbyte(ss.pos) == fb + ss.pos += 1 else return nil end @@ -124,29 +164,15 @@ def _strptime(string, format = '%F') end # Store leftover if any - if pos < str.length - hash[:leftover] = str[pos..] - end + hash[:leftover] = ss.rest unless ss.eos? # --- Post-processing (C: date__strptime, date_strptime.c:524-546) --- # C: cent = del_hash("_cent"); - # Apply _cent to both cwyear and year. - # Note: The inline _century approach in %C/%y/%g handlers covers most - # cases, but this post-processing ensures correctness for all orderings - # and applies century to both year and cwyear simultaneously. - # We delete _century and _century_set here to keep the hash clean, - # matching C's del_hash("_cent") behavior. hash.delete(:_century) hash.delete(:_century_set) # C: merid = del_hash("_merid"); - # Apply _merid to hour: hour = (hour % 12) + merid - # This handles both %I (12-hour) and %H (24-hour) correctly: - # %I=12 + AM(0) → (12 % 12) + 0 = 0 - # %I=12 + PM(12) → (12 % 12) + 12 = 12 - # %I=4 + PM(12) → (4 % 12) + 12 = 16 - # %I=4 + AM(0) → (4 % 12) + 0 = 4 merid = hash.delete(:_merid) if merid hour = hash[:hour] @@ -195,431 +221,464 @@ def strptime(string = JULIAN_EPOCH_DATE, format = '%F', start = DEFAULT_SG) private + # Advances StringScanner past zero or more ASCII whitespace bytes + # (space=32, tab=9, LF=10, CR=13, VT=11, FF=12). + # Avoids regex overhead compared to ss.skip(/[ \t\n\r\v\f]*/). + def skip_ws(ss) + str = ss.string + p = ss.pos + len = str.length + while p < len + b = str.getbyte(p) + break unless b == 32 || b == 9 || b == 10 || b == 13 || b == 11 || b == 12 + p += 1 + end + ss.pos = p + end + + # Scans unsigned decimal integer from +str+ at +pos+, up to +max+ digits. + # Returns [value, new_pos] or nil if no digit found. + def scan_uint(str, pos, max) + val = 0 + count = 0 + len = str.length + while count < max && pos + count < len + b = str.getbyte(pos + count) + break unless b >= 48 && b <= 57 # '0'..'9' + val = val * 10 + b - 48 + count += 1 + end + count > 0 ? [val, pos + count] : nil + end + + # Scans signed decimal integer (optional leading +/-) from +str+ at +pos+. + # Returns [value, new_pos] or nil if no digit found. + def scan_sint(str, pos, max) + b = str.getbyte(pos) + if b == 43 # '+' + result = scan_uint(str, pos + 1, max) + result + elsif b == 45 # '-' + result = scan_uint(str, pos + 1, max) + result ? [-result[0], result[1]] : nil + else + scan_uint(str, pos, max) + end + end + # C: num_pattern_p (date_strptime.c:48) # Returns true if the format string at position `i` starts with a # digit-consuming pattern (a literal digit or a %-specifier that reads digits). + # Uses byte-level operations to avoid String allocations. def num_pattern_p(format, i) return false if i >= format.length - c = format[i] - return true if c =~ /\d/ - if c == '%' + b = format.getbyte(i) + return true if b >= 48 && b <= 57 # '0'..'9' + if b == 37 # '%' i += 1 return false if i >= format.length - # Skip E/O modifier - if format[i] == 'E' || format[i] == 'O' + b2 = format.getbyte(i) + # Skip E/O modifier (E=69, O=79) + if b2 == 69 || b2 == 79 i += 1 return false if i >= format.length + b2 = format.getbyte(i) end - s = format[i] - return true if s =~ /\d/ || NUM_PATTERN_SPECS.include?(s) + return true if (b2 >= 48 && b2 <= 57) || NUM_PATTERN_SPECS_TABLE[b2] end false end - def _strptime_spec(str, pos, spec, width, context_hash, next_is_num = false) - h = {} + # Modifies +hash+ in-place with parsed values for +spec+. + # Advances +ss+ position on success. Returns true on success, nil on failure. + def _strptime_spec(ss, spec, width, hash, next_is_num = false) + str = ss.string + pos = ss.pos case spec when 'Y' # Full year (possibly negative) - # C: if (NUM_PATTERN_P()) READ_DIGITS(n, 4); else READ_DIGITS_MAX(n); - if width - w = width - elsif next_is_num - w = 4 - else - w = 40 # effectively unlimited - end - m = str[pos..].match(/\A([+-]?\d{1,#{w}})/) - return nil unless m - h[:year] = m[1].to_i - { pos: pos + m[0].length, hash: h } + year, new_pos = scan_sint(str, pos, width || (next_is_num ? 4 : 40)) + return nil unless year + hash[:year] = year + ss.pos = new_pos + true when 'C' # Century - # C: if (NUM_PATTERN_P()) READ_DIGITS(n, 2); else READ_DIGITS_MAX(n); - if width - w = width - elsif next_is_num - w = 2 - else - w = 40 + century, new_pos = scan_sint(str, pos, width || (next_is_num ? 2 : 40)) + return nil unless century + hash[:_century] = century + if hash[:year] && !hash[:_century_set] + hash[:year] = century * 100 + (hash[:year] % 100) + hash[:_century_set] = true end - m = str[pos..].match(/\A([+-]?\d{1,#{w}})/) - return nil unless m - century = m[1].to_i - h[:_century] = century - if context_hash[:year] && !context_hash[:_century_set] - h[:year] = century * 100 + (context_hash[:year] % 100) - h[:_century_set] = true - end - { pos: pos + m[0].length, hash: h } + ss.pos = new_pos + true when 'y' # 2-digit year - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - y = m[1].to_i - if context_hash[:_century] - h[:year] = context_hash[:_century] * 100 + y - h[:_century_set] = true + y, new_pos = scan_uint(str, pos, width || 2) + return nil unless y + if hash[:_century] + hash[:year] = hash[:_century] * 100 + y + hash[:_century_set] = true else - h[:year] = y >= 69 ? y + 1900 : y + 2000 + hash[:year] = y >= 69 ? y + 1900 : y + 2000 end - { pos: pos + m[0].length, hash: h } + ss.pos = new_pos + true when 'm' # Month (01-12) - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - mon = m[1].to_i + mon, new_pos = scan_uint(str, pos, width || 2) + return nil unless mon return nil if mon < 1 || mon > 12 - h[:mon] = mon - { pos: pos + m[0].length, hash: h } + hash[:mon] = mon + ss.pos = new_pos + true when 'd', 'e' # Day of month - # C: if (str[si] == ' ') { si++; READ_DIGITS(n, 1); } else { READ_DIGITS(n, 2); } - if str[pos] == ' ' - m = str[pos + 1..].match(/\A(\d)/) - return nil unless m - day = m[1].to_i + if str.getbyte(pos) == 32 # ' ' + day, new_pos = scan_uint(str, pos + 1, 1) + return nil unless day return nil if day < 1 || day > 31 - h[:mday] = day - { pos: pos + 1 + m[0].length, hash: h } + hash[:mday] = day + ss.pos = new_pos else - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - day = m[1].to_i + day, new_pos = scan_uint(str, pos, width || 2) + return nil unless day return nil if day < 1 || day > 31 - h[:mday] = day - { pos: pos + m[0].length, hash: h } + hash[:mday] = day + ss.pos = new_pos end + true when 'j' # Day of year (001-366) - w = width || 3 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - yday = m[1].to_i + yday, new_pos = scan_uint(str, pos, width || 3) + return nil unless yday return nil if yday < 1 || yday > 366 - h[:yday] = yday - { pos: pos + m[0].length, hash: h } + hash[:yday] = yday + ss.pos = new_pos + true when 'H', 'k' # Hour (00-24) - # C: if (str[si] == ' ') { si++; READ_DIGITS(n, 1); } else { READ_DIGITS(n, 2); } - if str[pos] == ' ' - m = str[pos + 1..].match(/\A(\d)/) - return nil unless m - hour = m[1].to_i + if str.getbyte(pos) == 32 # ' ' + hour, new_pos = scan_uint(str, pos + 1, 1) + return nil unless hour return nil if hour > 24 - h[:hour] = hour - { pos: pos + 1 + m[0].length, hash: h } + hash[:hour] = hour + ss.pos = new_pos else - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - hour = m[1].to_i + hour, new_pos = scan_uint(str, pos, width || 2) + return nil unless hour return nil if hour > 24 - h[:hour] = hour - { pos: pos + m[0].length, hash: h } + hash[:hour] = hour + ss.pos = new_pos end + true when 'I', 'l' # Hour (01-12) - # C: if (str[si] == ' ') { si++; READ_DIGITS(n, 1); } else { READ_DIGITS(n, 2); } - if str[pos] == ' ' - m = str[pos + 1..].match(/\A(\d)/) - return nil unless m - hour = m[1].to_i + if str.getbyte(pos) == 32 # ' ' + hour, new_pos = scan_uint(str, pos + 1, 1) + return nil unless hour return nil if hour < 1 || hour > 12 - h[:hour] = hour - { pos: pos + 1 + m[0].length, hash: h } + hash[:hour] = hour + ss.pos = new_pos else - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - hour = m[1].to_i + hour, new_pos = scan_uint(str, pos, width || 2) + return nil unless hour return nil if hour < 1 || hour > 12 - h[:hour] = hour # C stores raw value; _merid post-processing applies % 12 - { pos: pos + m[0].length, hash: h } + hash[:hour] = hour + ss.pos = new_pos end + true when 'M' # Minute (00-59) - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - min = m[1].to_i + min, new_pos = scan_uint(str, pos, width || 2) + return nil unless min return nil if min > 59 - h[:min] = min - { pos: pos + m[0].length, hash: h } + hash[:min] = min + ss.pos = new_pos + true when 'S' # Second (00-60) - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - sec = m[1].to_i + sec, new_pos = scan_uint(str, pos, width || 2) + return nil unless sec return nil if sec > 60 - h[:sec] = sec - { pos: pos + m[0].length, hash: h } - - when 'L' # Milliseconds - # C: if (NUM_PATTERN_P()) READ_DIGITS(n, 3); else READ_DIGITS_MAX(n); - if width - w = width - elsif next_is_num - w = 3 - else - w = 40 + hash[:sec] = sec + ss.pos = new_pos + true + + when 'L' # Milliseconds — normalize digit string to 3-digit precision + w = width || (next_is_num ? 3 : 40) + val, count = 0, 0 + str_len = str.length + while count < w && pos + count < str_len + b = str.getbyte(pos + count) + break unless b >= 48 && b <= 57 + val = val * 10 + b - 48 + count += 1 end - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - frac_str = m[1].ljust(3, '0')[0, 3] - h[:sec_fraction] = Rational(frac_str.to_i, 1000) - { pos: pos + m[0].length, hash: h } - - when 'N' # Nanoseconds - # C: if (NUM_PATTERN_P()) READ_DIGITS(n, 9); else READ_DIGITS_MAX(n); - if width - w = width - elsif next_is_num - w = 9 - else - w = 40 + return nil if count == 0 + val *= 10 ** (3 - count) if count < 3 + val /= 10 ** (count - 3) if count > 3 + hash[:sec_fraction] = Rational(val, 1000) + ss.pos = pos + count + true + + when 'N' # Nanoseconds — normalize digit string to 9-digit precision + w = width || (next_is_num ? 9 : 40) + val, count = 0, 0 + str_len = str.length + while count < w && pos + count < str_len + b = str.getbyte(pos + count) + break unless b >= 48 && b <= 57 + val = val * 10 + b - 48 + count += 1 end - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - frac_str = m[1].ljust(9, '0')[0, 9] - h[:sec_fraction] = Rational(frac_str.to_i, 1_000_000_000) - { pos: pos + m[0].length, hash: h } + return nil if count == 0 + val *= 10 ** (9 - count) if count < 9 + val /= 10 ** (count - 9) if count > 9 + hash[:sec_fraction] = Rational(val, 1_000_000_000) + ss.pos = pos + count + true when 'p', 'P' # AM/PM - # C: set_hash("_merid", INT2FIX(hour)); - # Store _merid value (0 for AM, 12 for PM) for post-processing. - # This avoids order-dependency: %p can appear before or after %I/%H. - m = str[pos..].match(/\A(a\.?m\.?|p\.?m\.?)/i) + m = ss.scan(/a\.?m\.?|p\.?m\.?/i) return nil unless m - ampm = m[1].delete('.').upcase - h[:_merid] = (ampm == 'PM') ? 12 : 0 - { pos: pos + m[0].length, hash: h } + ampm = m.delete('.').upcase + hash[:_merid] = (ampm == 'PM') ? 12 : 0 + true when 'A', 'a' # Day name (full or abbreviated) - DAYNAMES.each_with_index do |name, idx| - next unless name - # Try full name first, then abbreviated - [name, ABBR_DAYNAMES[idx]].each do |n| - next unless n - if str[pos, n.length]&.downcase == n.downcase - h[:wday] = idx - return { pos: pos + n.length, hash: h } + # Zero-alloc integer key from 3 bytes (lowercase via | 0x20). + # Check byte 4 to skip full-name string comparison in the common case. + b0 = str.getbyte(pos) + b1 = str.getbyte(pos + 1) + b2 = str.getbyte(pos + 2) + if b0 && b1 && b2 + k0 = b0 | 0x20; k1 = b1 | 0x20; k2 = b2 | 0x20 + if k0 >= 97 && k0 <= 122 && k1 >= 97 && k1 <= 122 && k2 >= 97 && k2 <= 122 + ikey = (k0 << 16) | (k1 << 8) | k2 + if (info = STRPTIME_DAYNAME_BY_INT_KEY[ikey]) + idx, full, full_len, abbr_len = info + b3 = str.getbyte(pos + abbr_len) + # If next byte is non-alpha, it's an abbreviated name. + if b3.nil? || (t = b3 | 0x20) < 97 || t > 122 + hash[:wday] = idx + ss.pos = pos + abbr_len + elsif str[pos, full_len]&.downcase == full + hash[:wday] = idx + ss.pos = pos + full_len + else + hash[:wday] = idx + ss.pos = pos + abbr_len + end + true end end end - return nil when 'B', 'b', 'h' # Month name (full or abbreviated) - MONTHNAMES.each_with_index do |name, idx| - next unless name - # Try full name first, then abbreviated - [name, ABBR_MONTHNAMES[idx]].each do |n| - next unless n - if str[pos, n.length]&.downcase == n.downcase - h[:mon] = idx - return { pos: pos + n.length, hash: h } + # Zero-alloc integer key from 3 bytes (lowercase via | 0x20). + b0 = str.getbyte(pos) + b1 = str.getbyte(pos + 1) + b2 = str.getbyte(pos + 2) + if b0 && b1 && b2 + k0 = b0 | 0x20; k1 = b1 | 0x20; k2 = b2 | 0x20 + if k0 >= 97 && k0 <= 122 && k1 >= 97 && k1 <= 122 && k2 >= 97 && k2 <= 122 + ikey = (k0 << 16) | (k1 << 8) | k2 + if (info = STRPTIME_MONNAME_BY_INT_KEY[ikey]) + idx, full, full_len, abbr_len = info + b3 = str.getbyte(pos + abbr_len) + if b3.nil? || (t = b3 | 0x20) < 97 || t > 122 + hash[:mon] = idx + ss.pos = pos + abbr_len + elsif str[pos, full_len]&.downcase == full + hash[:mon] = idx + ss.pos = pos + full_len + else + hash[:mon] = idx + ss.pos = pos + abbr_len + end + true end end end - return nil when 'w' # Weekday number (0-6, Sunday=0) - m = str[pos..].match(/\A(\d)/) - return nil unless m - wday = m[1].to_i - return nil if wday > 6 - h[:wday] = wday - { pos: pos + m[0].length, hash: h } + b = str.getbyte(pos) + return nil unless b && b >= 48 && b <= 54 # '0'..'6' + hash[:wday] = b - 48 + ss.pos = pos + 1 + true when 'u' # Weekday number (1-7, Monday=1) - m = str[pos..].match(/\A(\d)/) - return nil unless m - cwday = m[1].to_i - return nil if cwday < 1 || cwday > 7 - h[:cwday] = cwday - { pos: pos + m[0].length, hash: h } + b = str.getbyte(pos) + return nil unless b && b >= 49 && b <= 55 # '1'..'7' + hash[:cwday] = b - 48 + ss.pos = pos + 1 + true when 'U' # Week number (Sunday start, 00-53) - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - wnum = m[1].to_i + wnum, new_pos = scan_uint(str, pos, width || 2) + return nil unless wnum return nil if wnum > 53 - h[:wnum0] = wnum - { pos: pos + m[0].length, hash: h } + hash[:wnum0] = wnum + ss.pos = new_pos + true when 'W' # Week number (Monday start, 00-53) - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - wnum = m[1].to_i + wnum, new_pos = scan_uint(str, pos, width || 2) + return nil unless wnum return nil if wnum > 53 - h[:wnum1] = wnum - { pos: pos + m[0].length, hash: h } + hash[:wnum1] = wnum + ss.pos = new_pos + true when 'V' # ISO week number (01-53) - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - cweek = m[1].to_i + cweek, new_pos = scan_uint(str, pos, width || 2) + return nil unless cweek return nil if cweek < 1 || cweek > 53 - h[:cweek] = cweek - { pos: pos + m[0].length, hash: h } + hash[:cweek] = cweek + ss.pos = new_pos + true when 'G' # ISO week year - # C: if (NUM_PATTERN_P()) READ_DIGITS(n, 4); else READ_DIGITS_MAX(n); - if width - w = width - elsif next_is_num - w = 4 - else - w = 40 - end - m = str[pos..].match(/\A([+-]?\d{1,#{w}})/) - return nil unless m - h[:cwyear] = m[1].to_i - { pos: pos + m[0].length, hash: h } + cwyear, new_pos = scan_sint(str, pos, width || (next_is_num ? 4 : 40)) + return nil unless cwyear + hash[:cwyear] = cwyear + ss.pos = new_pos + true when 'g' # ISO week year (2-digit) - w = width || 2 - m = str[pos..].match(/\A(\d{1,#{w}})/) - return nil unless m - y = m[1].to_i - if context_hash[:_century] - h[:cwyear] = context_hash[:_century] * 100 + y - h[:_century_set] = true + y, new_pos = scan_uint(str, pos, width || 2) + return nil unless y + if hash[:_century] + hash[:cwyear] = hash[:_century] * 100 + y + hash[:_century_set] = true else - h[:cwyear] = y >= 69 ? y + 1900 : y + 2000 + hash[:cwyear] = y >= 69 ? y + 1900 : y + 2000 end - { pos: pos + m[0].length, hash: h } + ss.pos = new_pos + true when 'Z', 'z' # Timezone result = _strptime_zone(str, pos) return nil unless result - h[:zone] = result[:zone] - h[:offset] = result[:offset] unless result[:offset].nil? - { pos: result[:pos], hash: h } + hash[:zone] = result[:zone] + hash[:offset] = result[:offset] unless result[:offset].nil? + ss.pos = result[:pos] + true when 's' # Seconds since epoch - m = str[pos..].match(/\A([+-]?\d+)/) - return nil unless m - h[:seconds] = m[1].to_i - { pos: pos + m[0].length, hash: h } + secs, new_pos = scan_sint(str, pos, 40) + return nil unless secs + hash[:seconds] = secs + ss.pos = new_pos + true when 'Q' # Milliseconds since epoch - m = str[pos..].match(/\A([+-]?\d+)/) - return nil unless m - h[:seconds] = Rational(m[1].to_i, 1000) - { pos: pos + m[0].length, hash: h } + msecs, new_pos = scan_sint(str, pos, 40) + return nil unless msecs + hash[:seconds] = Rational(msecs, 1000) + ss.pos = new_pos + true - when 'n' # Newline - m = str[pos..].match(/\A\s+/) - if m - { pos: pos + m[0].length, hash: h } - else - { pos: pos, hash: h } - end - - when 't' # Tab - m = str[pos..].match(/\A\s+/) - if m - { pos: pos + m[0].length, hash: h } - else - { pos: pos, hash: h } - end + when 'n', 't' # Newline / Tab — match any whitespace + skip_ws(ss) + true when '%' # Literal % - if pos < str.length && str[pos] == '%' - { pos: pos + 1, hash: h } - else - return nil - end + return nil unless str.getbyte(pos) == 37 # '%' + ss.pos = pos + 1 + true when 'F' # %Y-%m-%d - result = _strptime_composite(str, pos, '%Y-%m-%d', context_hash) + result = _strptime_composite(ss, '%Y-%m-%d', hash) return nil unless result - { pos: result[:pos], hash: result[:hash] } + hash.merge!(result) + true when 'D', 'x' # %m/%d/%y - result = _strptime_composite(str, pos, '%m/%d/%y', context_hash) + result = _strptime_composite(ss, '%m/%d/%y', hash) return nil unless result - { pos: result[:pos], hash: result[:hash] } + hash.merge!(result) + true when 'T', 'X' # %H:%M:%S - result = _strptime_composite(str, pos, '%H:%M:%S', context_hash) + result = _strptime_composite(ss, '%H:%M:%S', hash) return nil unless result - { pos: result[:pos], hash: result[:hash] } + hash.merge!(result) + true when 'R' # %H:%M - result = _strptime_composite(str, pos, '%H:%M', context_hash) + result = _strptime_composite(ss, '%H:%M', hash) return nil unless result - { pos: result[:pos], hash: result[:hash] } + hash.merge!(result) + true when 'r' # %I:%M:%S %p - result = _strptime_composite(str, pos, '%I:%M:%S %p', context_hash) + result = _strptime_composite(ss, '%I:%M:%S %p', hash) return nil unless result - { pos: result[:pos], hash: result[:hash] } + hash.merge!(result) + true when 'c' # %a %b %e %H:%M:%S %Y - result = _strptime_composite(str, pos, '%a %b %e %H:%M:%S %Y', context_hash) + result = _strptime_composite(ss, '%a %b %e %H:%M:%S %Y', hash) return nil unless result - { pos: result[:pos], hash: result[:hash] } + hash.merge!(result) + true when 'v' # %e-%b-%Y - result = _strptime_composite(str, pos, '%e-%b-%Y', context_hash) + result = _strptime_composite(ss, '%e-%b-%Y', hash) return nil unless result - { pos: result[:pos], hash: result[:hash] } + hash.merge!(result) + true when '+' # %a %b %e %H:%M:%S %Z %Y - result = _strptime_composite(str, pos, '%a %b %e %H:%M:%S %Z %Y', context_hash) + result = _strptime_composite(ss, '%a %b %e %H:%M:%S %Z %Y', hash) return nil unless result - { pos: result[:pos], hash: result[:hash] } + hash.merge!(result) + true else # Unknown specifier - try to match literal literal = "%#{spec}" if str[pos, literal.length] == literal - { pos: pos + literal.length, hash: h } + ss.pos = pos + literal.length + true else - return nil + nil end end end - def _strptime_composite(str, pos, format, context_hash) + def _strptime_composite(ss, format, context_hash) merged_hash = context_hash.dup i = 0 - while i < format.length - if format[i] == '%' && i + 1 < format.length + fmt_len = format.length + while i < fmt_len + fb = format.getbyte(i) + if fb == 37 && i + 1 < fmt_len # '%' i += 1 spec = format[i] i += 1 - result = _strptime_spec(str, pos, spec, nil, merged_hash) - return nil unless result - pos = result[:pos] - merged_hash.merge!(result[:hash]) if result[:hash] - elsif format[i] =~ /\s/ + return nil unless _strptime_spec(ss, spec, nil, merged_hash) + elsif fb == 32 || fb == 9 || fb == 10 || fb == 13 || fb == 11 || fb == 12 # whitespace i += 1 - pos += 1 while pos < str.length && str[pos] =~ /\s/ + skip_ws(ss) else - if pos < str.length && str[pos] == format[i] - pos += 1 + if ss.string.getbyte(ss.pos) == fb + ss.pos += 1 else return nil end i += 1 end end - # Return only newly parsed keys + # Return only newly parsed or updated keys new_hash = {} merged_hash.each { |k, v| new_hash[k] = v unless context_hash.key?(k) && context_hash[k] == v } - # Ensure updated values are included merged_hash.each { |k, v| new_hash[k] = v if context_hash[k] != v } - { pos: pos, hash: new_hash } + new_hash end def _strptime_zone(str, pos) From 8909ef5c1669a1005f3e16faf5337b002325d170 Mon Sep 17 00:00:00 2001 From: jinroq Date: Wed, 25 Feb 2026 15:40:10 +0900 Subject: [PATCH 05/11] Rewrite Date and DateTime from C extension to pure Ruby Replace the C extension (ext/date/date_core.c, date_parse.c, date_strftime.c, date_strptime.c) with a pure Ruby implementation while maintaining full compatibility with the existing test suite (143 tests, 162,593 assertions). Key implementation files: - lib/date/core.rb: Date class with calendar conversions, arithmetic, and comparison operators - lib/date/datetime.rb: DateTime class with time component handling - lib/date/parse.rb: Date parsing (_parse, _rfc3339, _httpdate, _rfc2822, _xmlschema, _iso8601, _jisx0301) with byte-level fast paths - lib/date/strftime.rb: strftime formatting engine - lib/date/strptime.rb: strptime parsing engine - lib/date/constants.rb: Consolidated constants - lib/date/zonetab.rb: Timezone lookup table - lib/date/time.rb: Time conversion methods Performance optimizations: - Byte-level fast paths for common date format parsing (ISO 8601, RFC 3339, RFC 2822, HTTP dates) - Integer-based JD comparison instead of Rational arithmetic - Lazy evaluation for civil date computation and deconstruct_keys - Inlined private method calls to reduce __send__ overhead - O(1) boolean lookup tables replacing Array linear scans in strptime --- lib/date.rb | 2 + lib/date/constants.rb | 591 +++-- lib/date/core.rb | 5385 ++++++++++++----------------------------- lib/date/datetime.rb | 1415 ++++++----- lib/date/parse.rb | 3799 +++++++++++------------------ lib/date/strftime.rb | 1157 ++++----- lib/date/strptime.rb | 2100 ++++++++++------ lib/date/time.rb | 64 +- 8 files changed, 6016 insertions(+), 8497 deletions(-) diff --git a/lib/date.rb b/lib/date.rb index 3ad70c9c..1bb5da3f 100644 --- a/lib/date.rb +++ b/lib/date.rb @@ -1,6 +1,8 @@ # frozen_string_literal: true # date.rb: Written by Tadayoshi Funaba 1998-2011 +require 'timeout' + if RUBY_VERSION >= "3.3" require_relative "date/version" require_relative "date/constants" diff --git a/lib/date/constants.rb b/lib/date/constants.rb index fcf8e2b5..c9333b6a 100644 --- a/lib/date/constants.rb +++ b/lib/date/constants.rb @@ -3,26 +3,13 @@ # Constants class Date - HAVE_JD = 0b00000001 # 1 - HAVE_DF = 0b00000010 # 2 - HAVE_CIVIL = 0b00000100 # 4 - HAVE_TIME = 0b00001000 # 8 - COMPLEX_DAT = 0b10000000 # 128 - private_constant :HAVE_JD, :HAVE_DF, :HAVE_CIVIL, :HAVE_TIME, :COMPLEX_DAT - - MONTHNAMES = [nil, "January", "February", "March", "April", "May", "June", - "July", "August", "September", "October", "November", "December"].freeze - ABBR_MONTHNAMES = [nil, "Jan", "Feb", "Mar", "Apr", "May", "Jun", - "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"].freeze + MONTHNAMES = [nil, 'January', 'February', 'March', 'April', 'May', 'June', + 'July', 'August', 'September', 'October', 'November', 'December'].freeze + ABBR_MONTHNAMES = [nil, 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', + 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'].freeze DAYNAMES = %w[Sunday Monday Tuesday Wednesday Thursday Friday Saturday].freeze ABBR_DAYNAMES = %w[Sun Mon Tue Wed Thu Fri Sat].freeze - # Pattern constants for regex - ABBR_DAYS_PATTERN = 'sun|mon|tue|wed|thu|fri|sat' - DAYS_PATTERN = 'sunday|monday|tuesday|wednesday|thursday|friday|saturday' - ABBR_MONTHS_PATTERN = 'jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec' - private_constant :ABBR_DAYS_PATTERN, :DAYS_PATTERN, :ABBR_MONTHS_PATTERN - ITALY = 2299161 # 1582-10-15 ENGLAND = 2361222 # 1752-09-14 JULIAN = Float::INFINITY @@ -31,205 +18,377 @@ class Date DEFAULT_SG = ITALY private_constant :DEFAULT_SG - MINUTE_IN_SECONDS = 60 - HOUR_IN_SECONDS = 3600 - DAY_IN_SECONDS = 86400 - HALF_DAYS_IN_SECONDS = DAY_IN_SECONDS / 2 - SECOND_IN_MILLISECONDS = 1000 - SECOND_IN_NANOSECONDS = 1_000_000_000 - private_constant :MINUTE_IN_SECONDS, :HOUR_IN_SECONDS, :DAY_IN_SECONDS, :SECOND_IN_MILLISECONDS, :SECOND_IN_NANOSECONDS, :HALF_DAYS_IN_SECONDS - - JC_PERIOD0 = 1461 # 365.25 * 4 - GC_PERIOD0 = 146097 # 365.2425 * 400 - CM_PERIOD0 = 71149239 # (lcm 7 1461 146097) - CM_PERIOD = (0xfffffff / CM_PERIOD0) * CM_PERIOD0 - CM_PERIOD_JCY = (CM_PERIOD / JC_PERIOD0) * 4 - CM_PERIOD_GCY = (CM_PERIOD / GC_PERIOD0) * 400 - private_constant :JC_PERIOD0, :GC_PERIOD0, :CM_PERIOD0, :CM_PERIOD, :CM_PERIOD_JCY, :CM_PERIOD_GCY - - REFORM_BEGIN_YEAR = 1582 - REFORM_END_YEAR = 1930 - REFORM_BEGIN_JD = 2298874 # ns 1582-01-01 - REFORM_END_JD = 2426355 # os 1930-12-31 - private_constant :REFORM_BEGIN_YEAR, :REFORM_END_YEAR, :REFORM_BEGIN_JD, :REFORM_END_JD - - SEC_WIDTH = 6 - MIN_WIDTH = 6 - HOUR_WIDTH = 5 - MDAY_WIDTH = 5 - MON_WIDTH = 4 - private_constant :SEC_WIDTH, :MIN_WIDTH, :HOUR_WIDTH, :MDAY_WIDTH, :MON_WIDTH - - SEC_SHIFT = 0 - MIN_SHIFT = SEC_WIDTH - HOUR_SHIFT = MIN_WIDTH + SEC_WIDTH - MDAY_SHIFT = HOUR_WIDTH + MIN_WIDTH + SEC_WIDTH - MON_SHIFT = MDAY_WIDTH + HOUR_WIDTH + MIN_WIDTH + SEC_WIDTH - private_constant :SEC_SHIFT, :MIN_SHIFT, :HOUR_SHIFT, :MDAY_SHIFT, :MON_SHIFT - - PK_MASK = ->(x) { (1 << x) - 1 } - private_constant :PK_MASK - - # Days in each month (non-leap and leap year) - MONTH_DAYS = [ - [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze, # non-leap - [0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze # leap + # Pre-computed lowercase byte arrays for fast case-insensitive name matching in strptime + ABBR_DAY_LOWER_BYTES = ABBR_DAYNAMES.map { |n| n.downcase.bytes.freeze }.freeze + DAY_LOWER_BYTES = DAYNAMES.map { |n| n.downcase.bytes.freeze }.freeze + ABBR_MONTH_LOWER_BYTES = ABBR_MONTHNAMES.each_with_object([]) { |n, a| + a << (n ? n.downcase.bytes.freeze : nil) + }.freeze + MONTH_LOWER_BYTES = MONTHNAMES.each_with_object([]) { |n, a| + a << (n ? n.downcase.bytes.freeze : nil) + }.freeze + private_constant :ABBR_DAY_LOWER_BYTES, :DAY_LOWER_BYTES, + :ABBR_MONTH_LOWER_BYTES, :MONTH_LOWER_BYTES + + # 3-byte integer key lookup tables for O(1) abbreviated name matching. + # Key = (byte0_lower << 16) | (byte1_lower << 8) | byte2_lower + # Value = [index, full_name_length] + ABBR_DAY_3KEY = ABBR_DAYNAMES.each_with_index.to_h { |n, i| + b = n.downcase.bytes + [(b[0] << 16) | (b[1] << 8) | b[2], [i, DAYNAMES[i].length].freeze] + }.freeze + ABBR_MONTH_3KEY = ABBR_MONTHNAMES.each_with_index.each_with_object({}) { |(n, i), h| + next if n.nil? + b = n.downcase.bytes + h[(b[0] << 16) | (b[1] << 8) | b[2]] = [i, MONTHNAMES[i].length].freeze + }.freeze + private_constant :ABBR_DAY_3KEY, :ABBR_MONTH_3KEY + + # Case-insensitive abbreviated month name -> month number (1-12) + ABBR_MONTH_NUM = ABBR_MONTHNAMES.each_with_index.each_with_object({}) { |(n, i), h| + next if n.nil? + h[n.downcase] = i + }.freeze + + # Case-insensitive abbreviated day name -> wday number (0-6) + ABBR_DAY_NUM = ABBR_DAYNAMES.each_with_index.to_h { |n, i| [n.downcase, i] }.freeze + private_constant :ABBR_MONTH_NUM, :ABBR_DAY_NUM + + JULIAN_EPOCH_DATE = '-4712-01-01'.freeze + JULIAN_EPOCH_DATETIME = '-4712-01-01T00:00:00+00:00'.freeze + JULIAN_EPOCH_DATETIME_RFC2822 = 'Mon, 1 Jan -4712 00:00:00 +0000'.freeze + JULIAN_EPOCH_DATETIME_HTTPDATE = 'Mon, 01 Jan -4712 00:00:00 GMT'.freeze + private_constant :JULIAN_EPOCH_DATE, :JULIAN_EPOCH_DATETIME, + :JULIAN_EPOCH_DATETIME_RFC2822, :JULIAN_EPOCH_DATETIME_HTTPDATE + + # === Calendar computation (from core.rb) === + + # Days in month for Gregorian calendar. + DAYS_IN_MONTH_GREGORIAN = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze + private_constant :DAYS_IN_MONTH_GREGORIAN + + # Precomputed month offset for Julian Day computation: + # GJD_MONTH_OFFSET[m] == (306001 * (gm + 1)) / 10000 + # where gm = m + 12 for m <= 2, else gm = m. + # Used to avoid an integer multiply in the hot path of civil_to_jd. + GJD_MONTH_OFFSET = [nil, 428, 459, 122, 153, 183, 214, 244, 275, 306, 336, 367, 397].freeze + private_constant :GJD_MONTH_OFFSET + + STRFTIME_DATE_DEFAULT_FMT = '%F'.encode(Encoding::US_ASCII) + private_constant :STRFTIME_DATE_DEFAULT_FMT + + ASCTIME_DAYS = %w[Sun Mon Tue Wed Thu Fri Sat].freeze + ASCTIME_MONS = [nil, 'Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', + 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'].freeze + RFC2822_DAYS = ASCTIME_DAYS + private_constant :ASCTIME_DAYS, :ASCTIME_MONS, :RFC2822_DAYS + + # Pre-computed " Mon " strings for rfc2822/httpdate: " Jan ", " Feb ", ... + RFC_MON_SPACE = ASCTIME_MONS.map { |m| m ? " #{m} ".freeze : nil }.freeze + private_constant :RFC_MON_SPACE + + ERA_TABLE = [ + [2458605, 'R', 2018], # Reiwa: 2019-05-01 + [2447535, 'H', 1988], # Heisei: 1989-01-08 + [2424875, 'S', 1925], # Showa: 1926-12-25 + [2419614, 'T', 1911], # Taisho: 1912-07-30 + [2405160, 'M', 1867], # Meiji: 1873-01-01 ].freeze - private_constant :MONTH_DAYS - - YEARTAB = [ - [0, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334].freeze, # non-leap - [0, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335].freeze # leap + private_constant :ERA_TABLE + + # Pre-built "-MM-DD" suffixes for all valid month/day combinations. + # Indexed by [month][day]. Avoids per-call format() for the month/day portion. + MONTH_DAY_SUFFIX = Array.new(13) { |m| + Array.new(32) { |d| + next nil if m == 0 || d == 0 + format('-%02d-%02d', m, d).encode(Encoding::US_ASCII).freeze + }.freeze + }.freeze + private_constant :MONTH_DAY_SUFFIX + + # === String formatting (from strftime.rb) === + + DEFAULT_STRFTIME_FMT = '%F'.encode(Encoding::US_ASCII).freeze + private_constant :DEFAULT_STRFTIME_FMT + + YMD_FMT = '%Y-%m-%d'.encode(Encoding::US_ASCII).freeze + private_constant :YMD_FMT + + # Locale-independent month/day name tables (same as C ext) + STRFTIME_MONTHS_FULL = MONTHNAMES.freeze + STRFTIME_MONTHS_ABBR = ABBR_MONTHNAMES.freeze + STRFTIME_DAYS_FULL = DAYNAMES.freeze + STRFTIME_DAYS_ABBR = ABBR_DAYNAMES.freeze + private_constant :STRFTIME_MONTHS_FULL, :STRFTIME_MONTHS_ABBR, + :STRFTIME_DAYS_FULL, :STRFTIME_DAYS_ABBR + + # Pre-computed "Sun Jan " prefix table for %c / asctime [wday][month] + ASCTIME_PREFIX = Array.new(7) { |w| + Array.new(13) { |m| + m == 0 ? nil : "#{STRFTIME_DAYS_ABBR[w]} #{STRFTIME_MONTHS_ABBR[m]} ".freeze + }.freeze + }.freeze + private_constant :ASCTIME_PREFIX + + # Pre-computed "Saturday, " prefix table for %A format [wday] + DAY_FULL_COMMA = STRFTIME_DAYS_FULL.map { |d| "#{d}, ".freeze }.freeze + # Pre-computed "March " prefix table for %B format [month] + MONTH_FULL_SPACE = STRFTIME_MONTHS_FULL.map { |m| m ? "#{m} ".freeze : nil }.freeze + private_constant :DAY_FULL_COMMA, :MONTH_FULL_SPACE + + # Bitmask flag constants for strftime parsing + FL_LEFT = 0x01 # '-' flag + FL_SPACE = 0x02 # '_' flag + FL_ZERO = 0x04 # '0' flag + FL_UPPER = 0x08 # '^' flag + FL_CHCASE = 0x10 # '#' flag + private_constant :FL_LEFT, :FL_SPACE, :FL_ZERO, :FL_UPPER, :FL_CHCASE + + # Pre-computed 2-digit zero-padded strings for 0..99 + PAD2 = (0..99).map { |n| format('%02d', n).freeze }.freeze + private_constant :PAD2 + + # Map composite spec bytes to their expansion strings + STRFTIME_COMPOSITE_BYTE = { + 99 => '%a %b %e %H:%M:%S %Y', # 'c' + 68 => '%m/%d/%y', # 'D' + 70 => '%Y-%m-%d', # 'F' + 110 => "\n", # 'n' + 114 => '%I:%M:%S %p', # 'r' + 82 => '%H:%M', # 'R' + 116 => "\t", # 't' + 84 => '%H:%M:%S', # 'T' + 118 => '%e-%^b-%4Y', # 'v' + 88 => '%H:%M:%S', # 'X' + 120 => '%m/%d/%y', # 'x' + }.freeze + private_constant :STRFTIME_COMPOSITE_BYTE + + # Valid specs for %E locale modifier (as byte values) + # c=99, C=67, x=120, X=88, y=121, Y=89 + STRFTIME_E_VALID_BYTES = [99, 67, 120, 88, 121, 89].freeze + # Valid specs for %O locale modifier (as byte values) + # d=100, e=101, H=72, k=107, I=73, l=108, m=109, M=77, S=83, u=117, U=85, V=86, w=119, W=87, y=121 + STRFTIME_O_VALID_BYTES = [100, 101, 72, 107, 73, 108, 109, 77, 83, 117, 85, 86, 119, 87, 121].freeze + private_constant :STRFTIME_E_VALID_BYTES, :STRFTIME_O_VALID_BYTES + + # Maximum allowed format width to prevent unreasonable memory allocation + STRFTIME_MAX_WIDTH = 65535 + # Maximum length for a single formatted field (matches C's STRFTIME_MAX_COPY_LEN) + STRFTIME_MAX_COPY_LEN = 1024 + private_constant :STRFTIME_MAX_WIDTH, :STRFTIME_MAX_COPY_LEN + + # === Parse regex patterns (from parse.rb) === + + RFC3339_RE = /\A\s*(-?\d{4})-(\d{2})-(\d{2})[Tt ](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(Z|[-+]\d{2}:\d{2})\s*\z/i + private_constant :RFC3339_RE + + HTTPDATE_TYPE1_RE = /\A\s*(sun|mon|tue|wed|thu|fri|sat)\s*,\s+(\d{2})\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+(-?\d{4})\s+(\d{2}):(\d{2}):(\d{2})\s+(gmt)\s*\z/i + HTTPDATE_TYPE2_RE = /\A\s*(sunday|monday|tuesday|wednesday|thursday|friday|saturday)\s*,\s+(\d{2})\s*-\s*(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s*-\s*(\d{2})\s+(\d{2}):(\d{2}):(\d{2})\s+(gmt)\s*\z/i + HTTPDATE_TYPE3_RE = /\A\s*(sun|mon|tue|wed|thu|fri|sat)\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(\d{4})\s*\z/i + # Fast path: simplified Type 1 with generic [a-zA-Z] instead of alternation + FAST_HTTPDATE_TYPE1_RE = /\A\s*([a-zA-Z]{3}),\s+(\d{2})\s+([a-zA-Z]{3})\s+(\d{4})\s+(\d{2}):(\d{2}):(\d{2})\s+(GMT)\s*\z/i + private_constant :HTTPDATE_TYPE1_RE, :HTTPDATE_TYPE2_RE, :HTTPDATE_TYPE3_RE, + :FAST_HTTPDATE_TYPE1_RE + + # Wday lookup from abbreviated day name (3-char lowercase key) + HTTPDATE_WDAY = {'sun'=>0,'mon'=>1,'tue'=>2,'wed'=>3,'thu'=>4,'fri'=>5,'sat'=>6}.freeze + HTTPDATE_FULL_WDAY = {'sunday'=>0,'monday'=>1,'tuesday'=>2,'wednesday'=>3,'thursday'=>4,'friday'=>5,'saturday'=>6}.freeze + private_constant :HTTPDATE_WDAY, :HTTPDATE_FULL_WDAY + + RFC2822_RE = /\A\s*(?:(sun|mon|tue|wed|thu|fri|sat)\s*,\s+)?(\d{1,2})\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+(-?\d{2,})\s+(\d{2}):(\d{2})(?::(\d{2}))?\s*([-+]\d{4}|ut|gmt|e[sd]t|c[sd]t|m[sd]t|p[sd]t|[a-ik-z])\s*\z/i + private_constant :RFC2822_RE + + XMLSCHEMA_DATETIME_RE = /\A\s*(-?\d{4,})(?:-(\d{2})(?:-(\d{2}))?)?(?:t(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?)?(z|[-+]\d{2}:\d{2})?\s*\z/i + XMLSCHEMA_TIME_RE = /\A\s*(\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(z|[-+]\d{2}:\d{2})?\s*\z/i + XMLSCHEMA_TRUNC_RE = /\A\s*(?:--(\d{2})(?:-(\d{2}))?|---(\d{2}))(z|[-+]\d{2}:\d{2})?\s*\z/i + private_constant :XMLSCHEMA_DATETIME_RE, :XMLSCHEMA_TIME_RE, :XMLSCHEMA_TRUNC_RE + + ISO8601_EXT_DATETIME_RE = %r{\A\s* + (?: + ([-+]?\d{2,}|-)-(\d{2})?(?:-(\d{2}))? | # year-mon-mday or --mon-mday or ---mday + ([-+]?\d{2,})?-(\d{3}) | # year-yday + (\d{4}|\d{2})?-w(\d{2})(?:-(\d))? | # cwyear-wNN-D + -w-(\d) # -w-D + ) + (?:t + (\d{2}):(\d{2})(?::(\d{2})(?:[,.](\d+))?)? + (z|[-+]\d{2}(?::?\d{2})?)? + )? + \s*\z}xi + + ISO8601_BAS_DATETIME_RE = %r{\A\s* + (?: + ([-+]?(?:\d{4}|\d{2})|--)(\d{2}|-)(\d{2}) | # yyyymmdd / --mmdd / ----dd + ([-+]?(?:\d{4}|\d{2}))(\d{3}) | # yyyyddd + -(\d{3}) | # -ddd + (\d{4}|\d{2})w(\d{2})(\d) | # yyyywwwd + -w(\d{2})(\d) | # -wNN-D + -w-(\d) # -w-D + ) + (?:t? + (\d{2})(\d{2})(?:(\d{2})(?:[,.](\d+))?)? + (z|[-+]\d{2}(\d{2})?)? + )? + \s*\z}xi + + ISO8601_EXT_TIME_RE = /\A\s*(\d{2}):(\d{2})(?::(\d{2})(?:[,.](\d+))?(z|[-+]\d{2}(?::?\d{2})?)?)?\s*\z/i + ISO8601_BAS_TIME_RE = /\A\s*(\d{2})(\d{2})(?:(\d{2})(?:[,.](\d+))?(z|[-+]\d{2}(\d{2})?)?)?\s*\z/i + private_constant :ISO8601_EXT_DATETIME_RE, :ISO8601_BAS_DATETIME_RE, + :ISO8601_EXT_TIME_RE, :ISO8601_BAS_TIME_RE + + JISX0301_ERA = { 'm' => 1867, 't' => 1911, 's' => 1925, 'h' => 1988, 'r' => 2018 }.freeze + JISX0301_RE = /\A\s*([mtshr])?(\d{2})\.(\d{2})\.(\d{2})(?:t(?:(\d{2}):(\d{2})(?::(\d{2})(?:[,.](\d*))?)?(z|[-+]\d{2}(?::?\d{2})?)?)?)?\s*\z/i + private_constant :JISX0301_ERA, :JISX0301_RE + + # Character class flags + HAVE_ALPHA = 1 + HAVE_DIGIT = 2 + HAVE_DASH = 4 + HAVE_DOT = 8 + HAVE_SLASH = 16 + HAVE_COLON = 32 + private_constant :HAVE_ALPHA, :HAVE_DIGIT, :HAVE_DASH, :HAVE_DOT, :HAVE_SLASH, :HAVE_COLON + + PARSE_DAYS_RE = /\b(sun|mon|tue|wed|thu|fri|sat)[^-\/\d\s]*/i + PARSE_MON_RE = /\b(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\S*/i + PARSE_MDAY_RE = /(?> 16 - NS_MONTH_COEFF = 2141 - NS_MONTH_OFFSET = 197913 - private_constant :NS_MONTH_COEFF, :NS_MONTH_OFFSET - - # Coefficients for civil date to JDN month contribution. - # Maps month to accumulated days: days = (NS_CIVIL_MONTH_COEFF * m - NS_CIVIL_MONTH_OFFSET) / 32 - NS_CIVIL_MONTH_COEFF = 979 - NS_CIVIL_MONTH_OFFSET = 2919 - NS_CIVIL_MONTH_DIVISOR = 32 - private_constant :NS_CIVIL_MONTH_COEFF, :NS_CIVIL_MONTH_OFFSET, :NS_CIVIL_MONTH_DIVISOR - - # Days from March 1 to December 31 (for Jan/Feb year adjustment) - NS_DAYS_BEFORE_NEW_YEAR = 306 - private_constant :NS_DAYS_BEFORE_NEW_YEAR - - # Safe bounds for Neri-Schneider algorithm to avoid integer overflow. - # These correspond to approximately years -1,000,000 to +1,000,000. - NS_JD_MIN = -364_000_000 - NS_JD_MAX = 538_000_000 - private_constant :NS_JD_MIN, :NS_JD_MAX - - JULIAN_EPOCH_DATE = "-4712-01-01" - JULIAN_EPOCH_DATETIME = "-4712-01-01T00:00:00+00:00" - JULIAN_EPOCH_DATETIME_RFC2822 = "Mon, 1 Jan -4712 00:00:00 +0000" - JULIAN_EPOCH_DATETIME_HTTPDATE = "Mon, 01 Jan -4712 00:00:00 GMT" - private_constant :JULIAN_EPOCH_DATE, :JULIAN_EPOCH_DATETIME, :JULIAN_EPOCH_DATETIME_RFC2822, :JULIAN_EPOCH_DATETIME_HTTPDATE - - JISX0301_ERA_INITIALS = 'mtshr' - JISX0301_DEFAULT_ERA = 'H' # obsolete - private_constant :JISX0301_ERA_INITIALS, :JISX0301_DEFAULT_ERA - - HAVE_ALPHA = 1 << 0 - HAVE_DIGIT = 1 << 1 - HAVE_DASH = 1 << 2 - HAVE_DOT = 1 << 3 - HAVE_SLASH = 1 << 4 - private_constant :HAVE_ALPHA, :HAVE_DIGIT, :HAVE_DASH, :HAVE_DOT, :HAVE_SLASH - - # C: default strftime format is US-ASCII - STRFTIME_DEFAULT_FMT = '%F' - private_constant :STRFTIME_DEFAULT_FMT - - # strftime spec categories - NUMERIC_SPECS = %w[Y C y m d j H I M S L N G g U W V u w s Q].freeze - SPACE_PAD_SPECS = %w[e k l].freeze - CHCASE_UPPER_SPECS = %w[A a B b h].freeze - CHCASE_LOWER_SPECS = %w[Z p].freeze - private_constant :NUMERIC_SPECS, :SPACE_PAD_SPECS, - :CHCASE_UPPER_SPECS, :CHCASE_LOWER_SPECS - - # strptime digit-consuming specs - NUM_PATTERN_SPECS = "CDdeFGgHIjkLlMmNQRrSsTUuVvWwXxYy" - private_constant :NUM_PATTERN_SPECS - - # Precomputed byte-indexed boolean table for num_pattern_p. - # Entry is true if the byte value corresponds to a digit-consuming %-specifier. - NUM_PATTERN_SPECS_TABLE = begin - t = Array.new(256, false) - NUM_PATTERN_SPECS.each_byte { |b| t[b] = true } - t.freeze - end - private_constant :NUM_PATTERN_SPECS_TABLE - - # Precomputed zero-padded two-digit strings "00".."99". - TWO_DIGIT = (0..99).map { |i| (i < 10 ? "0#{i}" : i.to_s).freeze }.freeze - private_constant :TWO_DIGIT - - # Precomputed zero-padded four-digit year strings "0000".."9999". - FOUR_DIGIT = (0..9999).map { |y| sprintf("%04d", y).freeze }.freeze - private_constant :FOUR_DIGIT - - # Integer bitmask flags for strftime format modifier parsing. - FLAG_MINUS = 0x01 # '-' suppress padding - FLAG_SPACE = 0x02 # '_' space padding - FLAG_UPPER = 0x04 # '^' upcase result - FLAG_CHCASE = 0x08 # '#' change case (CHCASE) - FLAG_ZERO = 0x10 # '0' zero padding (explicit) - private_constant :FLAG_MINUS, :FLAG_SPACE, :FLAG_UPPER, :FLAG_CHCASE, :FLAG_ZERO - - # Fragment completion table for DateTime parsing - COMPLETE_FRAGS_TABLE = [ - [:time, [:hour, :min, :sec].freeze], - [nil, [:jd].freeze], - [:ordinal, [:year, :yday, :hour, :min, :sec].freeze], - [:civil, [:year, :mon, :mday, :hour, :min, :sec].freeze], - [:commercial, [:cwyear, :cweek, :cwday, :hour, :min, :sec].freeze], - [:wday, [:wday, :hour, :min, :sec].freeze], - [:wnum0, [:year, :wnum0, :wday, :hour, :min, :sec].freeze], - [:wnum1, [:year, :wnum1, :wday, :hour, :min, :sec].freeze], - [nil, [:cwyear, :cweek, :wday, :hour, :min, :sec].freeze], - [nil, [:year, :wnum0, :cwday, :hour, :min, :sec].freeze], - [nil, [:year, :wnum1, :cwday, :hour, :min, :sec].freeze], - ].each { |a| a.freeze }.freeze - private_constant :COMPLETE_FRAGS_TABLE - - # Lookup tables for O(1) day/month name matching in strptime %a/%b. - # Key: 24-bit integer (b0|0x20)<<16|(b1|0x20)<<8|(b2|0x20) of lowercase 3-char abbreviation. - # Value: [index, full_lower, full_len, abbr_len]. - # This avoids string allocation for the 3-char prefix key entirely. - STRPTIME_DAYNAME_BY_INT_KEY = begin - h = {} - DAYNAMES.each_with_index do |name, idx| - abbr = ABBR_DAYNAMES[idx] - k = ((abbr.getbyte(0) | 0x20) << 16) | - ((abbr.getbyte(1) | 0x20) << 8) | - (abbr.getbyte(2) | 0x20) - h[k] = [idx, name.downcase, name.length, abbr.length].freeze - end - h.freeze - end - private_constant :STRPTIME_DAYNAME_BY_INT_KEY - - STRPTIME_MONNAME_BY_INT_KEY = begin - h = {} - MONTHNAMES.each_with_index do |name, idx| - next unless name - abbr = ABBR_MONTHNAMES[idx] - k = ((abbr.getbyte(0) | 0x20) << 16) | - ((abbr.getbyte(1) | 0x20) << 8) | - (abbr.getbyte(2) | 0x20) - h[k] = [idx, name.downcase, name.length, abbr.length].freeze - end - h.freeze - end - private_constant :STRPTIME_MONNAME_BY_INT_KEY + private_constant :COMPLETE_FRAGS_TAB + + # O(1) boolean lookup table for numeric specs (used by _sp_num_p_b?) + # Includes both STRPTIME_NUMERIC_SPECS chars and digits '0'..'9' + STRPTIME_NUMERIC_SPEC_SET = Array.new(256, false).tap { |a| + STRPTIME_NUMERIC_SPECS.each_byte { |b| a[b] = true } + 48.upto(57) { |b| a[b] = true } # '0'..'9' + }.freeze + private_constant :STRPTIME_NUMERIC_SPEC_SET + + # O(1) boolean lookup table for E-modifier valid specs + STRPTIME_E_VALID_SET = Array.new(256, false).tap { |a| + 'cCxXyY'.each_byte { |b| a[b] = true } + }.freeze + private_constant :STRPTIME_E_VALID_SET + + # O(1) boolean lookup table for O-modifier valid specs + STRPTIME_O_VALID_SET = Array.new(256, false).tap { |a| + 'deHImMSuUVwWy'.each_byte { |b| a[b] = true } + }.freeze + private_constant :STRPTIME_O_VALID_SET end diff --git a/lib/date/core.rb b/lib/date/core.rb index 4e285ffa..e625ddd2 100644 --- a/lib/date/core.rb +++ b/lib/date/core.rb @@ -1,214 +1,53 @@ # frozen_string_literal: true -# Implementation of ruby/date/ext/date/date_core.c class Date include Comparable Error = Class.new(ArgumentError) - # Initialize method - # call-seq: - # Date.new(year = -4712, month = 1, mday = 1, start = Date::ITALY) -> date - # - # Returns a new Date object constructed from the given arguments: - # - # Date.new(2022).to_s # => "2022-01-01" - # Date.new(2022, 2).to_s # => "2022-02-01" - # Date.new(2022, 2, 4).to_s # => "2022-02-04" - # - # Argument +month+ should be in range (1..12) or range (-12..-1); - # when the argument is negative, counts backward from the end of the year: - # - # Date.new(2022, -11, 4).to_s # => "2022-02-04" - # - # Argument +mday+ should be in range (1..n) or range (-n..-1) - # where +n+ is the number of days in the month; - # when the argument is negative, counts backward from the end of the month. - # - # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. - # - # Related: Date.jd. - def initialize(year = -4712, month = 1, day = 1, start = DEFAULT_SG) - # Fast path: Integer arguments, Gregorian calendar - # Avoids self.class.send, Hash allocation, redundant decode_year - if year.is_a?(Integer) && year.abs < 579000 && month.is_a?(Integer) && day.is_a?(Integer) - gregorian_fast = if start.is_a?(Float) && start.infinite? - start < 0 # GREGORIAN (-Infinity) only - elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD - year > REFORM_END_YEAR - end - - if gregorian_fast - m = month - m += 13 if m < 0 - raise Error unless m >= 1 && m <= 12 - - leap = (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) - last = MONTH_DAYS[leap ? 1 : 0][m] - d = day - d = last + d + 1 if d < 0 - raise Error unless d >= 1 && d <= last - - j = (m < 3) ? 1 : 0 - y0 = year - j - m0 = j.nonzero? ? m + 12 : m - d0 = d - 1 - q1 = y0 / 100 - yc = (NS_DAYS_IN_4_YEARS * y0) / 4 - q1 + q1 / 4 - mc = (NS_DAYS_BEFORE_NEW_YEAR * m0 - 914) / 10 - - @nth = 0 - @jd = yc + mc + d0 + NS_EPOCH - @sg = start - @year = year - @month = m - @day = d - @has_jd = true - @has_civil = true - @df = nil - @sf = nil - @of = nil - return self - end - - # Julian fast path: JULIAN start, or year < REFORM_BEGIN_YEAR with reform-range start. - # Covers Date.civil(-4712, 1, 1) and Date.civil(2024, 6, 15, Date::JULIAN). - julian_fast = if start.is_a?(Float) && start.infinite? - start > 0 # JULIAN (+Infinity) - elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD - year < REFORM_BEGIN_YEAR - end - - if julian_fast - m = month - m += 13 if m < 0 - raise Error unless m >= 1 && m <= 12 - - # Julian leap year: divisible by 4 (no century exception) - leap = (year % 4 == 0) - last = MONTH_DAYS[leap ? 1 : 0][m] - d = day - d = last + d + 1 if d < 0 - raise Error unless d >= 1 && d <= last + # --------------------------------------------------------------------------- + # Class methods + # --------------------------------------------------------------------------- - # Julian JD via integer arithmetic: - # jd = floor(365.25*(y+4716)) + floor(30.6001*(m+1)) + d - 1524 - # = (1461*(y+4716))/4 + (153*(m+1))/5 + d - 1524 - y2 = year; m2 = m - if m2 <= 2 - y2 -= 1 - m2 += 12 + class << self + # Same as Date.new. + def civil(year = -4712, month = 1, day = 1, start = DEFAULT_SG) + unless (Integer === (year + month + day) rescue false) && month >= 1 && month <= 12 + return new(year, month, day, start) + end + if day >= 1 && day <= 28 + gy = month > 2 ? year : year - 1 + gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[month] + day + a = gy / 100 + jd_julian = gjd_base - 1524 + gjd = jd_julian + 2 - a + a / 4 + obj = allocate + obj.__send__(:_init_from_jd, gjd >= start ? gjd : jd_julian, start) + return obj + elsif day >= -31 + dim = if month == 2 + if start == Float::INFINITY + year % 4 == 0 ? 29 : 28 + else + (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? 29 : 28 + end + else + DAYS_IN_MONTH_GREGORIAN[month] + end + d = day < 0 ? day + dim + 1 : day + if d >= 1 && d <= dim + gy = month > 2 ? year : year - 1 + gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[month] + d + a = gy / 100 + jd_julian = gjd_base - 1524 + gjd = jd_julian + 2 - a + a / 4 + obj = allocate + obj.__send__(:_init_from_jd, gjd >= start ? gjd : jd_julian, start) + return obj end - jd = (1461 * (y2 + 4716)) / 4 + (153 * (m2 + 1)) / 5 + d - 1524 - - @nth = 0 - @jd = jd - @sg = start - @year = year - @month = m - @day = d - @has_jd = true - @has_civil = true - @df = nil - @sf = nil - @of = nil - return self end + new(year, month, day, start) end - - # Original path: handles non-Integer args, Julian/reform dates, fractional days - y = year - m = month - d = day - sg = start - fr2 = 0 - - # argument type checking - if y - raise TypeError, "invalid year (not numeric)" unless year.is_a?(Numeric) - end - if m - raise TypeError, "invalid month (not numeric)" unless month.is_a?(Numeric) - end - if d - raise TypeError, "invalid day (not numeric)" unless day.is_a?(Numeric) - # Check if there is a decimal part. - d_trunc, fr = d_trunc_with_frac(d) - d = d_trunc - fr2 = fr if fr.nonzero? - end - - sg = self.class.send(:valid_sg, sg) - style = self.class.send(:guess_style, y, sg) - - if style < 0 - # gregorian calendar only - result = self.class.send(:valid_gregorian_p, y, m, d) - raise Error unless result - - nth, ry = self.class.send(:decode_year, y, -1) - rm = result[:rm] - rd = result[:rd] - - @nth = canon(nth) - @jd = 0 - @sg = sg - @year = ry - @month = rm - @day = rd - @has_jd = false - @has_civil = true - @df = nil - @sf = nil - @of = nil - else - # full validation - result = self.class.send(:valid_civil_p, y, m, d, sg) - raise Error unless result - - nth = result[:nth] - ry = result[:ry] - rm = result[:rm] - rd = result[:rd] - rjd = result[:rjd] - - @nth = canon(nth) - @jd = rjd - @sg = sg - @year = ry - @month = rm - @day = rd - @has_jd = true - @has_civil = true - @df = nil - @sf = nil - @of = nil - end - - # Add any decimal parts. - if fr2.nonzero? - new_date = self + fr2 - @nth = new_date.instance_variable_get(:@nth) - @jd = new_date.instance_variable_get(:@jd) - @sg = new_date.instance_variable_get(:@sg) - @year = new_date.instance_variable_get(:@year) - @month = new_date.instance_variable_get(:@month) - @day = new_date.instance_variable_get(:@day) - @has_jd = new_date.instance_variable_get(:@has_jd) - @has_civil = new_date.instance_variable_get(:@has_civil) - @df = new_date.instance_variable_get(:@df) - @sf = new_date.instance_variable_get(:@sf) - @of = new_date.instance_variable_get(:@of) - end - - self - end - - # Class methods - class << self - # Same as `Date.new`. - alias_method :civil, :new - # call-seq: # Date.valid_civil?(year, month, mday, start = Date::ITALY) -> true or false # @@ -223,28 +62,8 @@ class << self # # Related: Date.jd, Date.new. def valid_civil?(year, month, day, start = DEFAULT_SG) - # Fast path: Integer args, non-Julian start - if year.is_a?(Integer) && month.is_a?(Integer) && day.is_a?(Integer) - gregorian_fast = if start.is_a?(Float) && start.infinite? - start < 0 - elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD - true - end - - if gregorian_fast - return false if month < 1 || month > 12 - leap = (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) - return day >= 1 && day <= MONTH_DAYS[leap ? 1 : 0][month] - end - end - - return false unless numeric?(year) - return false unless numeric?(month) - return false unless numeric?(day) - - result = valid_civil_sub(year, month, day, start, 0) - - !result.nil? + return false unless year.is_a?(Numeric) && month.is_a?(Numeric) && day.is_a?(Numeric) + !!internal_valid_civil?(year, month, day, start) end alias_method :valid_date?, :valid_civil? @@ -273,44 +92,10 @@ def valid_civil?(year, month, day, start = DEFAULT_SG) # # Related: Date.new. def jd(jd = 0, start = DEFAULT_SG) - # Fast path: Integer jd in common range, valid start - if jd.is_a?(Integer) && jd >= 0 && jd < CM_PERIOD - valid_start = if start.is_a?(Float) && start.infinite? - true - elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD - true - end - - if valid_start - obj = allocate - obj.instance_variable_set(:@nth, 0) - obj.instance_variable_set(:@jd, jd) - obj.instance_variable_set(:@sg, start) - obj.instance_variable_set(:@has_jd, true) - return obj - end - end - - # Original path - j = 0 - fr = 0 - sg = start - - sg = valid_sg(start) if start - - if jd - raise TypeError, "invalid jd (not numeric)" unless jd.is_a?(Numeric) - - j, fr = value_trunc(jd) - end - - nth, rjd = decode_jd(j) - - ret = d_simple_new_internal(nth, rjd, sg, 0, 0, 0, HAVE_JD) - - ret = ret + fr if fr.nonzero? - - ret + jd = Integer(jd) + obj = allocate + obj.__send__(:_init_from_jd, jd, start) + obj end # call-seq: @@ -324,12 +109,8 @@ def jd(jd = 0, start = DEFAULT_SG) # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. # # Related: Date.jd. - def valid_jd?(jd, start = DEFAULT_SG) - # All Numeric jd values are valid; skip valid_jd_sub/valid_sg chain - return true if jd.is_a?(Numeric) - return true if jd.respond_to?(:to_int) - - false + def valid_jd?(jd, _start = DEFAULT_SG) + jd.is_a?(Numeric) end # call-seq: @@ -343,14 +124,8 @@ def valid_jd?(jd, start = DEFAULT_SG) # # Related: Date.julian_leap?. def gregorian_leap?(year) - if year.is_a?(Integer) - return (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) - end - raise TypeError, "invalid year (not numeric)" unless numeric?(year) - - _, ry = decode_year(year, -1) - - c_gregorian_leap_p?(ry) + raise TypeError, "expected numeric" unless year.is_a?(Numeric) + internal_gregorian_leap?(year) end alias_method :leap?, :gregorian_leap? @@ -365,14 +140,8 @@ def gregorian_leap?(year) # # Related: Date.gregorian_leap?. def julian_leap?(year) - if year.is_a?(Integer) - return (year % 4).zero? - end - raise TypeError, "invalid year (not numeric)" unless numeric?(year) - - _, ry = decode_year(year, +1) - - c_julian_leap_p?(ry) + raise TypeError, "expected numeric" unless year.is_a?(Numeric) + internal_julian_leap?(year) end # call-seq: @@ -404,59 +173,21 @@ def julian_leap?(year) # # Related: Date.jd, Date.new. def ordinal(year = -4712, yday = 1, start = DEFAULT_SG) - # Fast path: Integer args, Gregorian calendar - if year.is_a?(Integer) && year.abs < 579000 && yday.is_a?(Integer) - gregorian_fast = if start.is_a?(Float) && start.infinite? - start < 0 - elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD - year > REFORM_END_YEAR - end - - if gregorian_fast - leap = (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) - days_in_year = leap ? 366 : 365 - d = yday - d = days_in_year + d + 1 if d < 0 - raise Error unless d >= 1 && d <= days_in_year - - rjd = c_gregorian_civil_to_jd(year, 1, 1) + d - 1 - - obj = allocate - obj.instance_variable_set(:@nth, 0) - obj.instance_variable_set(:@jd, rjd) - obj.instance_variable_set(:@sg, start) - obj.instance_variable_set(:@has_jd, true) - return obj - end - end - - # Original path - y = year - d = yday - fr2 = 0 - sg = start - - if y - raise TypeError, "invalid year (not numeric)" unless year.is_a?(Numeric) - end - if d - raise TypeError, "invalid yday (not numeric)" unless yday.is_a?(Numeric) - d_trunc, fr = value_trunc(d) - d = d_trunc - fr2 = fr if fr.nonzero? + if Integer === year && Integer === yday && yday >= 1 && yday <= 365 + gy = year - 1 + gjd_base = (1461 * (gy + 4716)) / 4 + 429 # GJD_MONTH_OFFSET[1] + 1 + a = gy / 100 + gjd = gjd_base - 1524 + 2 - a + a / 4 + jd1 = gjd >= start ? gjd : gjd_base - 1524 + obj = allocate + obj.__send__(:_init_from_jd, jd1 + yday - 1, start) + return obj end - - result = valid_ordinal_p(year, yday, start) - raise Error unless result - - nth = result[:nth] - rjd = result[:rjd] - - obj = d_simple_new_internal(nth, rjd, sg, 0, 0, 0, HAVE_JD) - - obj = obj + fr2 if fr2.nonzero? - - obj + year = Integer(year) + yday = Integer(yday) + jd = internal_valid_ordinal?(year, yday, start) + raise Date::Error, "invalid date" unless jd + _new_from_jd(jd, start) end # call-seq: @@ -472,29 +203,8 @@ def ordinal(year = -4712, yday = 1, start = DEFAULT_SG) # # Related: Date.jd, Date.ordinal. def valid_ordinal?(year, day, start = DEFAULT_SG) - # Fast path: Integer args, non-Julian start - if year.is_a?(Integer) && day.is_a?(Integer) - gregorian_fast = if start.is_a?(Float) && start.infinite? - start < 0 - elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD - true - end - - if gregorian_fast - leap = (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) - days_in_year = leap ? 366 : 365 - d = day - d = days_in_year + d + 1 if d < 0 - return d >= 1 && d <= days_in_year - end - end - - return false unless numeric?(year) - return false unless numeric?(day) - - result = valid_ordinal_sub(year, day, start, false) - - !result.nil? + return false unless year.is_a?(Numeric) && day.is_a?(Numeric) + !!internal_valid_ordinal?(year, day, start) end # call-seq: @@ -540,81 +250,28 @@ def valid_ordinal?(year, day, start = DEFAULT_SG) # # Related: Date.jd, Date.new, Date.ordinal. def commercial(cwyear = -4712, cweek = 1, cwday = 1, start = DEFAULT_SG) - # Fast path: Integer args, Gregorian calendar - if cwyear.is_a?(Integer) && cwyear.abs < 579000 && cweek.is_a?(Integer) && cwday.is_a?(Integer) - gregorian_fast = if start.is_a?(Float) && start.infinite? - start < 0 - elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD - cwyear > REFORM_END_YEAR - end - - if gregorian_fast - # Validate cwday (handle negative) - d = cwday - d += 8 if d < 0 - raise Error unless d >= 1 && d <= 7 - - # JD of Jan 1 and ISO week metadata - jd_jan1 = c_gregorian_civil_to_jd(cwyear, 1, 1) - - # Max ISO weeks: 53 if Jan 1 is Thursday, or leap year and Jan 1 is Wednesday - p_val = (jd_jan1 + 1) % 7 # 0=Sun..6=Sat - p_val = 7 if p_val == 0 # Convert to ISO (1=Mon..7=Sun) - leap = (cwyear % 4 == 0) && (cwyear % 100 != 0 || cwyear % 400 == 0) - max_weeks = (p_val == 4 || (leap && p_val == 3)) ? 53 : 52 - - # Handle negative week - w = cweek - w = max_weeks + w + 1 if w < 0 - raise Error unless w >= 1 && w <= max_weeks - - # Compute JD: Monday of week 1 + offset - rjd2 = jd_jan1 + 3 - rjd = (rjd2 - (rjd2 % 7)) + 7 * (w - 1) + (d - 1) - - obj = allocate - obj.instance_variable_set(:@nth, 0) - obj.instance_variable_set(:@jd, rjd) - obj.instance_variable_set(:@sg, start) - obj.instance_variable_set(:@has_jd, true) - return obj - end - end - - # Original path - y = cwyear - w = cweek - d = cwday - fr2 = 0 - sg = start - - if y - raise TypeError, "invalid year (not numeric)" unless cwyear.is_a?(Numeric) - end - if w - raise TypeError, "invalid cweek (not numeric)" unless cweek.is_a?(Numeric) - w = w.to_i - end - if d - raise TypeError, "invalid cwday (not numeric)" unless cwday.is_a?(Numeric) - d_trunc, fr = value_trunc(d) - d = d_trunc - fr2 = fr if fr.nonzero? + if Integer === cwyear && Integer === cweek && Integer === cwday && + cweek >= 1 && cweek <= 52 && cwday >= 1 && cwday <= 7 + # ISO 8601: every year has at least 52 weeks, so weeks 1-52 are always valid. + # Inline civil_to_jd(cwyear, 1, 4, start): month=1, day=4 + gy = cwyear - 1 + gjd_base4 = (1461 * (gy + 4716)) / 4 + 432 # GJD_MONTH_OFFSET[1] + 4 + a = gy / 100 + gjd4 = gjd_base4 - 1524 + 2 - a + a / 4 + jd_jan4 = gjd4 >= start ? gjd4 : gjd_base4 - 1524 + wday_jan4 = (jd_jan4 + 1) % 7 + mon_wk1 = jd_jan4 - (wday_jan4 == 0 ? 6 : wday_jan4 - 1) + jd = mon_wk1 + (cweek - 1) * 7 + (cwday - 1) + obj = allocate + obj.__send__(:_init_from_jd, jd, start) + return obj end - - sg = valid_sg(start) if start - - result = valid_commercial_p(y, w, d, sg) - raise Error unless result - - nth = result[:nth] - rjd = result[:rjd] - - obj = d_simple_new_internal(nth, rjd, sg, 0, 0, 0, HAVE_JD) - - obj = obj + fr2 if fr2.nonzero? - - obj + cwyear = Integer(cwyear) + cweek = Integer(cweek) + cwday = Integer(cwday) + jd = internal_valid_commercial?(cwyear, cweek, cwday, start) + raise Date::Error, "invalid date" unless jd + _new_from_jd(jd, start) end # call-seq: @@ -632,41 +289,42 @@ def commercial(cwyear = -4712, cweek = 1, cwday = 1, start = DEFAULT_SG) # # Related: Date.jd, Date.commercial. def valid_commercial?(year, week, day, start = DEFAULT_SG) - # Fast path: Integer args, non-Julian start - if year.is_a?(Integer) && week.is_a?(Integer) && day.is_a?(Integer) - gregorian_fast = if start.is_a?(Float) && start.infinite? - start < 0 - elsif start.is_a?(Integer) && start >= REFORM_BEGIN_JD && start <= REFORM_END_JD - true - end - - if gregorian_fast - # Validate cwday (handle negative) - d = day - d += 8 if d < 0 - return false unless d >= 1 && d <= 7 - - # Max ISO weeks: 53 if Jan 1 is Thursday, or leap year and Jan 1 is Wednesday - jd_jan1 = c_gregorian_civil_to_jd(year, 1, 1) - p_val = (jd_jan1 + 1) % 7 # 0=Sun..6=Sat - p_val = 7 if p_val == 0 # Convert to ISO (1=Mon..7=Sun) - leap = (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0) - max_weeks = (p_val == 4 || (leap && p_val == 3)) ? 53 : 52 - - # Handle negative week - w = week - w = max_weeks + w + 1 if w < 0 - return w >= 1 && w <= max_weeks - end - end - - return false unless numeric?(year) - return false unless numeric?(week) - return false unless numeric?(day) + return false unless year.is_a?(Numeric) && week.is_a?(Numeric) && day.is_a?(Numeric) + !!internal_valid_commercial?(year, week, day, start) + end - result = valid_commercial_sub(year, week, day, start, false) + # call-seq: + # Date.weeknum(year, week, wday, wstart = 0, start = Date::ITALY) -> date + def weeknum(year = -4712, week = 0, wday = 1, wstart = 0, start = DEFAULT_SG) + year = Integer(year) + week = Integer(week) + wday = Integer(wday) + wstart = Integer(wstart) + # Validate wday range + raise Date::Error, "invalid date" unless wday >= 0 && wday <= 6 + # Validate week: reconstruct and check round-trip + jd = weeknum_to_jd(year, week, wday, wstart, start) + # Verify the resulting date is in the same year (week must be valid) + y2, = jd_to_civil(jd, start) + raise Date::Error, "invalid date" if y2 != year + _new_from_jd(jd, start) + end - !result.nil? + # call-seq: + # Date.nth_kday(year, month, n, k, start = Date::ITALY) -> date + def nth_kday(year = -4712, month = 1, n = 1, k = 1, start = DEFAULT_SG) + year = Integer(year) + month = Integer(month) + n = Integer(n) + k = Integer(k) + raise Date::Error, "invalid date" unless month >= 1 && month <= 12 + raise Date::Error, "invalid date" unless k >= 0 && k <= 6 + raise Date::Error, "invalid date" if n == 0 + jd = nth_kday_to_jd(year, month, n, k, start) + # Verify the result is in the same month + y2, m2, = jd_to_civil(jd, start) + raise Date::Error, "invalid date" if y2 != year || m2 != month + _new_from_jd(jd, start) end # call-seq: @@ -677,24 +335,14 @@ def valid_commercial?(year, week, day, start = DEFAULT_SG) # Date.today.to_s # => "2022-07-06" # # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # def today(start = DEFAULT_SG) - time = Time.now - - obj = allocate - obj.instance_variable_set(:@nth, 0) - obj.instance_variable_set(:@year, time.year) - obj.instance_variable_set(:@month, time.mon) - obj.instance_variable_set(:@day, time.mday) - obj.instance_variable_set(:@jd, nil) - obj.instance_variable_set(:@sg, start) - obj.instance_variable_set(:@has_jd, false) - obj.instance_variable_set(:@has_civil, true) - - obj + t = Time.now + jd = civil_to_jd(t.year, t.mon, t.mday, start) + _new_from_jd(jd, start) end # :nodoc: - # C: date_s__load — for Marshal format 1.4, 1.6, 1.8 (u: prefix) def _load(s) a = Marshal.load(s) obj = allocate @@ -702,3621 +350,1634 @@ def _load(s) obj end - private - - # Optimized: Gregorian date -> Julian Day Number - def gregorian_civil_to_jd(year, month, day) - # Shift epoch to March 1 of year 0 (Jan/Feb belong to previous year) - j = (month < 3) ? 1 : 0 - y0 = year - j - m0 = j == 1 ? month + 12 : month - d0 = day - 1 - - # Calculate year contribution with leap year correction - q1 = y0 / NS_YEARS_PER_CENTURY - yc = (NS_DAYS_IN_4_YEARS * y0) / 4 - q1 + (q1 / 4) - - # Calculate month contribution using integer arithmetic - mc = (NS_CIVIL_MONTH_COEFF * m0 - NS_CIVIL_MONTH_OFFSET) / NS_CIVIL_MONTH_DIVISOR - - # Combine and add epoch offset to get JDN - yc + mc + d0 + NS_EPOCH + # :nodoc: + def new!(ajd = 0, of = 0, sg = DEFAULT_SG) + # ajd is Astronomical Julian Day (may be Rational) + # Convert to integer JD and day fraction (same as C's old_to_new) + raw_jd = ajd + Rational(1, 2) + jd = raw_jd.floor + df = raw_jd - jd + obj = allocate + obj.__send__(:_init_from_jd, jd, sg, df == 0 ? nil : df) + obj end - def julian_civil_to_jd(y, m, d) - # Traditional Julian calendar algorithm - y2 = y - m2 = m + private - if m2 <= 2 - y2 -= 1 - m2 += 12 - end + # --------------------------------------------------------------------------- + # Internal calendar arithmetic (pure Ruby, no C dependency) + # --------------------------------------------------------------------------- - (365.25 * (y2 + 4716)).floor + (30.6001 * (m2 + 1)).floor + d - 1524 + # Floor division that works correctly for negative numbers. + def idiv(a, b) + a.div(b) end - def validate_ordinal(year, yday, sg) - # Handling negative day of year - if yday < 0 - # Counting backwards from the end of the year - last_jd, _ = c_find_ldoy(year, sg) - return nil unless last_jd - - # Recalculate the total number of days in the year from the calculated JD - adjusted_jd = last_jd + yday + 1 - y, d = jd_to_ordinal(adjusted_jd, sg) - - # Invalid if the year does not match - return nil if y != year - - yday = d - end - - # Calculate jd from the day of the year - nth, ry, _, _ = decode_year(year, sg) - first_jd, ns = c_find_fdoy(ry, sg) - - return nil unless first_jd - - jd = first_jd + yday - 1 - - # Verify that the calculated jd actually belongs to the specified year - verify_y, verify_d = jd_to_ordinal(jd, sg) - return nil if verify_y != ry || verify_d != yday + # Gregorian leap year? + def internal_gregorian_leap?(y) + (y % 4 == 0 && y % 100 != 0) || y % 400 == 0 + end - [nth, ry, yday, jd, ns] + # Julian leap year? + def internal_julian_leap?(y) + y % 4 == 0 end - def extract_fraction(value) - if value.is_a?(Rational) || value.is_a?(Float) - int_part = value.floor - frac_part = value - int_part - [int_part, frac_part] + def days_in_month_gregorian(y, m) + if m == 2 && internal_gregorian_leap?(y) + 29 else - [value.to_i, 0] + DAYS_IN_MONTH_GREGORIAN[m] end end - def jd_to_ordinal(jd, sg) - year, _, _ = jd_to_civil_internal(jd, sg) - first_jd, _ = c_find_fdoy(year, sg) - yday = jd - first_jd + 1 - - [year, yday] - end - - def validate_commercial(year, week, day, sg) - if day < 0 - day += 8 # -1 -> 7 (Sun), -7 -> 1 (Mon) - end - - return nil if day < 1 || day > 7 - - if week < 0 - next_year_jd, ns = commercial_to_jd_internal(year + 1, 1, 1, sg) - return nil unless next_year_jd - - adjusted_jd = next_year_jd + week * 7 - y2, w2, _ = jd_to_commercial_internal(adjusted_jd, sg) - - return nil if y2 != year - - week = w2 + # Days in month for Julian calendar. + def days_in_month_julian(y, m) + if m == 2 && internal_julian_leap?(y) + 29 + else + DAYS_IN_MONTH_GREGORIAN[m] + end + end + + # Gregorian civil (year, month, day) -> Julian Day Number + def gregorian_to_jd(y, m, d) + if m <= 2 + y -= 1 + m += 12 + end + a = y / 100 + b = 2 - a + a / 4 + (1461 * (y + 4716)) / 4 + (306001 * (m + 1)) / 10000 + d + b - 1524 + end + + # Julian civil (year, month, day) -> Julian Day Number + def julian_to_jd(y, m, d) + if m <= 2 + y -= 1 + m += 12 + end + (1461 * (y + 4716)) / 4 + (306001 * (m + 1)) / 10000 + d - 1524 + end + + # Civil (year, month, day) -> JD, respecting start (cutover). + # Uses a unified formula: gjd >= sg -> Gregorian JD, else Julian JD. + # Works for all sg values: Float::INFINITY (always Julian), + # -Float::INFINITY (always Gregorian), or integer cutover JD. + def civil_to_jd(y, m, d, sg) + offset = GJD_MONTH_OFFSET[m] + y -= 1 if m <= 2 + gjd_base = (1461 * (y + 4716)) / 4 + offset + d + a = y / 100 + gjd = gjd_base - 1524 + 2 - a + a / 4 + gjd >= sg ? gjd : gjd_base - 1524 + end + + # Gregorian JD -> (year, month, day) + def jd_to_gregorian(jd) + a = jd + 32044 + b = idiv(4 * a + 3, 146097) + c = a - idiv(146097 * b, 4) + d = idiv(4 * c + 3, 1461) + e = c - idiv(1461 * d, 4) + m = idiv(5 * e + 2, 153) + day = e - idiv(153 * m + 2, 5) + 1 + mon = m + 3 - 12 * idiv(m, 10) + year = 100 * b + d - 4800 + idiv(m, 10) + [year, mon, day] + end + + # Julian JD -> (year, month, day) + def jd_to_julian(jd) + c = jd + 32082 + d = idiv(4 * c + 3, 1461) + e = c - idiv(1461 * d, 4) + m = idiv(5 * e + 2, 153) + day = e - idiv(153 * m + 2, 5) + 1 + mon = m + 3 - 12 * idiv(m, 10) + year = d - 4800 + idiv(m, 10) + [year, mon, day] + end + + # JD -> (year, month, day), respecting start (cutover). + def jd_to_civil(jd, sg) + if sg == Float::INFINITY + jd_to_julian(jd) + elsif sg == -Float::INFINITY || jd >= sg + jd_to_gregorian(jd) + else + jd_to_julian(jd) end - - # Calculate jd from ISO week date - nth, ry, _, _ = decode_year(year, sg) - jd, ns = commercial_to_jd_internal(ry, week, day, sg) - - return nil unless jd - - verify_y, verify_w, verify_d = jd_to_commercial_internal(jd, sg) - return nil if verify_y != ry || verify_w != week || verify_d != day - - [nth, ry, week, day, jd, ns] - end - - def commercial_to_jd_internal(cwyear, cweek, cwday, sg) - # Calculating ISO week date(The week containing January 4 is week 1) - jan4_jd = gregorian_civil_to_jd(cwyear, 1, 4) - - # Day of the week on which January 4th falls - # (0 = Sun, 1 = Mon, ..., 6 = Sat) - jan4_wday = (jan4_jd + 1) % 7 - - # Monday of week 1 - week1_mon = jan4_jd - jan4_wday + 1 - - # jd for a specified weekday - jd = week1_mon + (cweek - 1) * 7 + (cwday - 1) - - # If before sg, it is the Julian calendar - ns = jd >= sg ? 1 : 0 - - [jd, ns] end - def jd_to_commercial_internal(jd, sg) - # get date from jd - year, _, _ = jd_to_civil_internal(jd, sg) - - # calculate jd for January 4 of that year - jan4_jd = gregorian_civil_to_jd(year, 1, 4) - jan4_wday = (jan4_jd + 1) % 7 - week1_mon = jan4_jd - jan4_wday + 1 - - # If jd is before the first week, it belongs to the previous year - if jd < week1_mon - year -= 1 - jan4_jd = gregorian_civil_to_jd(year, 1, 4) - jan4_wday = (jan4_jd + 1) % 7 - week1_mon = jan4_jd - jan4_wday + 1 - end - - # check the first week of the next year - next_jan4 = gregorian_civil_to_jd(year + 1, 1, 4) - next_jan4_wday = (next_jan4 + 1) % 7 - next_week1_mon = next_jan4 - next_jan4_wday + 1 - - if jd >= next_week1_mon - year += 1 - week1_mon = next_week1_mon - end - - # Calculate the week number - week = (jd - week1_mon) / 7 + 1 - - # week(1 = mon, ..., 7 = sun） - cwday = (jd + 1) % 7 - cwday = 7 if cwday.zero? - - [year, week, cwday] + # Ordinal (year, day-of-year) -> JD + def ordinal_to_jd(y, d, sg) + civil_to_jd(y, 1, 1, sg) + d - 1 end - def jd_to_civil_internal(jd, sg) - # Does it overlap with jd_to_civil? - # Calculate the date from jd (using existing methods) - # simple version - r0 = jd - NS_EPOCH - - n1 = 4 * r0 + 3 - q1 = n1 / NS_DAYS_IN_400_YEARS - r1 = (n1 % NS_DAYS_IN_400_YEARS) / 4 - - n2 = 4 * r1 + 3 - u2 = NS_YEAR_MULTIPLIER * n2 - q2 = u2 >> 32 - r2 = (u2 & 0xFFFFFFFF) / NS_YEAR_MULTIPLIER / 4 - - n3 = NS_MONTH_COEFF * r2 + NS_MONTH_OFFSET - q3 = n3 >> 16 - r3 = (n3 & 0xFFFF) / NS_MONTH_COEFF - - y0 = NS_YEARS_PER_CENTURY * q1 + q2 - j = (r2 >= NS_DAYS_BEFORE_NEW_YEAR) ? 1 : 0 - - year = y0 + j - month = j == 1 ? q3 - 12 : q3 - day = r3 + 1 - - [year, month, day] + # JD -> (year, day-of-year) + def jd_to_ordinal(jd, sg) + y, = jd_to_civil(jd, sg) + jd_jan1 = civil_to_jd(y, 1, 1, sg) + [y, jd - jd_jan1 + 1] end - def valid_civil_date?(year, month, day, sg) - return false if month < 1 || month > 12 - - if sg == GREGORIAN || sg < 0 - last_day = last_day_of_month_gregorian(year, month) - elsif sg == JULIAN || sg > 0 - last_day = last_day_of_month_julian(year, month) + # Commercial (ISO week: cwyear, cweek, cwday) -> JD + def commercial_to_jd(y, w, d, sg = -Float::INFINITY) + # Jan 4 is always in week 1 (ISO 8601) + jd_jan4 = civil_to_jd(y, 1, 4, sg) + # Monday of week 1 + wday_jan4 = (jd_jan4 + 1) % 7 # 0=Sun + iso_wday_jan4 = wday_jan4 == 0 ? 7 : wday_jan4 + mon_wk1 = jd_jan4 - (iso_wday_jan4 - 1) + mon_wk1 + (w - 1) * 7 + (d - 1) + end + + # JD -> (cwyear, cweek, cwday) + def jd_to_commercial(jd, sg = -Float::INFINITY) + wday = (jd + 1) % 7 # 0=Sun + cwday = wday == 0 ? 7 : wday # 1=Mon..7=Sun + # Thursday of the same ISO week + thursday = jd + (4 - cwday) + y, = thursday >= sg ? jd_to_gregorian(thursday) : jd_to_julian(thursday) + jd_jan4 = civil_to_jd(y, 1, 4, sg) + wday_jan4 = (jd_jan4 + 1) % 7 + iso_wday_jan4 = wday_jan4 == 0 ? 7 : wday_jan4 + mon_wk1 = jd_jan4 - (iso_wday_jan4 - 1) + cweek = (jd - mon_wk1) / 7 + 1 + [y, cweek, cwday] + end + + # Weeknum (year, week, wday, week_start, sg) -> JD + # week_start: 0=Sun-based (%U), 1=Mon-based (%W) + def weeknum_to_jd(y, w, d, ws, sg = -Float::INFINITY) + jd_jan1 = civil_to_jd(y, 1, 1, sg) + wday_jan1 = (jd_jan1 + 1) % 7 # 0=Sun + j = jd_jan1 - wday_jan1 + j += 1 if ws == 1 + j + 7 * w + d + end + + # n-th k-day (nth occurrence of weekday k in year y, month m) -> JD + # k: 0=Sun..6=Sat, n: positive from beginning, negative from end + def nth_kday_to_jd(y, m, n, k, sg) + if n > 0 + jd_m1 = civil_to_jd(y, m, 1, sg) + wday = (jd_m1 + 1) % 7 + diff = (k - wday + 7) % 7 + jd_m1 + diff + (n - 1) * 7 else - # Calculate (calendar reform period - jd) and determine - jd = gregorian_civil_to_jd(year, month, day) - - if jd < sg - last_day = last_day_of_month_julian(year, month) + # Last day of month + if m == 12 + jd_last = civil_to_jd(y + 1, 1, 1, sg) - 1 else - last_day = last_day_of_month_gregorian(year, month) + jd_last = civil_to_jd(y, m + 1, 1, sg) - 1 end + wday = (jd_last + 1) % 7 + diff = (wday - k + 7) % 7 + jd_last - diff + (n + 1) * 7 end - - return false if day < 1 || day > last_day - - true end - def last_day_of_month_gregorian(y, m) - return nil if m < 1 || m > 12 + # --------------------------------------------------------------------------- + # Validation helpers + # --------------------------------------------------------------------------- - leap_index = gregorian_leap?(y) ? 1 : 0 - MONTH_DAYS[leap_index][m] + def internal_valid_jd?(jd, _sg) + jd.is_a?(Numeric) ? jd.to_i : nil end - def last_day_of_month_julian(y, m) + def internal_valid_civil?(y, m, d, sg) + return nil unless y.is_a?(Numeric) && m.is_a?(Numeric) && d.is_a?(Numeric) + y = y.to_i + m = m.to_i + d = d.to_i + # Handle negative month/day + m += 13 if m < 0 return nil if m < 1 || m > 12 - - leap_index = julian_leap?(y) ? 1 : 0 - MONTH_DAYS[leap_index][m] - end - - def civil_to_jd_with_check(year, month, day, sg) - return nil unless valid_civil_date?(year, month, day, sg) - - jd, ns = civil_to_jd(year, month, day, sg) - - [jd, ns] - end - - def civil_to_jd(year, month, day, sg) - if sg == GREGORIAN - jd = gregorian_civil_to_jd(year, month, day) - - return [jd, 1] - end - - jd = gregorian_civil_to_jd(year, month, day) - - if jd < sg - jd = julian_civil_to_jd(year, month, day) - ns = 0 + # Days in that month + if sg == Float::INFINITY + dim = days_in_month_julian(y, m) else - ns = 1 - end - - [jd, ns] - end - - def last_day_of_month_for_sg(year, month, sg) - last_day_of_month_gregorian(year, month) - end - - def validate_civil(year, month, day, sg) - month += 13 if month < 0 - return nil if month < 1 || month > 12 - - if day < 0 - last_day = last_day_of_month_gregorian(year, month) - return nil unless last_day - day = last_day + day + 1 + dim = days_in_month_gregorian(y, m) end - - last_day = last_day_of_month_gregorian(year, month) - return nil if day < 1 || day > last_day - - nth, ry = decode_year(year, -1) - - jd, ns = civil_to_jd_with_style(ry, month, day, sg) - - [nth, ry, month, day, jd, ns] + d += dim + 1 if d < 0 + return nil if d < 1 || d > dim + civil_to_jd(y, m, d, sg) end - def civil_to_jd_with_style(year, month, day, sg) - jd = gregorian_civil_to_jd(year, month, day) - - if jd < sg - jd = julian_civil_to_jd(year, month, day) - ns = 0 + def internal_valid_ordinal?(y, yday, sg) + return nil unless y.is_a?(Numeric) && yday.is_a?(Numeric) + y = y.to_i + yday = yday.to_i + # Days in year + if sg == Float::INFINITY + diy = internal_julian_leap?(y) ? 366 : 365 else - ns = 1 - end - - [jd, ns] + diy = internal_gregorian_leap?(y) ? 366 : 365 + end + yday += diy + 1 if yday < 0 + return nil if yday < 1 || yday > diy + ordinal_to_jd(y, yday, sg) + end + + def internal_valid_commercial?(y, w, d, sg) + return nil unless y.is_a?(Numeric) && w.is_a?(Numeric) && d.is_a?(Numeric) + y = y.to_i + w = w.to_i + d = d.to_i + # ISO cwday: 1=Mon..7=Sun + d += 8 if d < 0 + return nil if d < 1 || d > 7 + # Weeks in year: Dec 28 is always in the last ISO week + jd_dec28 = civil_to_jd(y, 12, 28, sg) + _, max_week, = jd_to_commercial(jd_dec28, sg) + w += max_week + 1 if w < 0 + return nil if w < 1 || w > max_week + commercial_to_jd(y, w, d, sg) + end + + # --------------------------------------------------------------------------- + # Internal object factory + # --------------------------------------------------------------------------- + + # Build a Date from a Julian Day Number (integer part), start, and optional day fraction. + def _new_from_jd(jd, sg, df = nil) + obj = allocate + obj.__send__(:_init_from_jd, jd, sg, df) + obj end - def convert_to_integer(value) - if value.respond_to?(:to_int) - value.to_int - elsif value.is_a?(Numeric) - value.to_i + # Parse offset string like "+09:00", "-07:30", "Z" to seconds. + def _offset_str_to_sec(str) + case str + when 'Z', 'z', 'UTC', 'GMT' + 0 + when /\A([+-])(\d{1,2}):?(\d{2})(?::(\d{2}))?\z/ + sign = $1 == '+' ? 1 : -1 + h, m, s = $2.to_i, $3.to_i, ($4 || '0').to_i + sign * (h * 3600 + m * 60 + s) + when /\A([+-])(\d{2})(\d{2})\z/ + sign = $1 == '+' ? 1 : -1 + h, m = $2.to_i, $3.to_i + sign * (h * 3600 + m * 60) else - value + 0 end end - def numeric?(value) - value.is_a?(Numeric) || value.respond_to?(:to_int) - end - - def valid_civil_sub(year, month, day, start, need_jd) - year = convert_to_integer(year) - month = convert_to_integer(month) - day = convert_to_integer(day) - - start = valid_sg(start) - - return nil if month < 1 || month > 12 - - leap_year = start == JULIAN ? julian_leap?(year) : gregorian_leap?(year) - max_day = MONTH_DAYS[leap_year ? 1 : 0][month] - - return nil if day < 1 || day > max_day + end - need_jd ? civil_to_jd(year, month, day, start) : 0 - end - - def valid_sg(start) - unless c_valid_start_p(start) - warn "invalid start is ignored" - return 0 - end - - start - end - - def c_valid_start_p(start) - return false unless start.is_a?(Numeric) - - return false if start.respond_to?(:nan?) && start.nan? - - return true if start.respond_to?(:infinite?) && start.infinite? - - return false if start < REFORM_BEGIN_JD || start > REFORM_END_JD - - true - end - - def valid_jd_sub(jd, start, need_jd) - valid_sg(start) - - jd - end - - def valid_commercial_sub(year, week, day, start, need_jd) - week = convert_to_integer(week) - day = convert_to_integer(day) - - valid_sg(start) - - result = valid_commercial_p(year, week, day, start) - - return nil unless result - - return 0 unless need_jd - - encode_jd(result[:nth], result[:rjd]) - end - - def valid_commercial_p(year, week, day, start) - style = guess_style(year, start) - - if style.zero? - int_year = year.to_i - result = c_valid_commercial_p(int_year, week, day, start) - return nil unless result - - nth, rjd = decode_jd(result[:jd]) - - if f_zero_p?(nth) - ry = int_year - else - ns = result[:ns] - _, ry = decode_year(year, ns.nonzero? ? -1 : 1) - end - - { nth: nth, ry: ry, rw: result[:rw], rd: result[:rd], rjd: rjd, ns: result[:ns] } - else - nth, ry = decode_year(year, style) - result = c_valid_commercial_p(ry, week, day, style) - return nil unless result - - { nth: nth, ry: ry, rw: result[:rw], rd: result[:rd], rjd: result[:jd], ns: result[:ns] } - end - end - - def guess_style(year, sg) - return sg if sg.infinite? - return year >= 0 ? GREGORIAN : JULIAN unless year.is_a?(Integer) && year.abs < (1 << 62) - - int_year = year.to_i - if int_year < REFORM_BEGIN_YEAR - JULIAN - elsif int_year > REFORM_END_YEAR - GREGORIAN - else - 0 - end - end - - def c_valid_commercial_p(year, week, day, sg) - day += 8 if day < 0 - - if week < 0 - rjd2, _ = c_commercial_to_jd(year + 1, 1, 1, sg) - ry2, rw2, _ = c_jd_to_commercial(rjd2 + week * 7, sg) - return nil if ry2 != year - - week = rw2 - end - - rjd, ns = c_commercial_to_jd(year, week, day, sg) - ry2, rw, rd = c_jd_to_commercial(rjd, sg) - - return nil if year != ry2 || week != rw || day != rd - - { jd: rjd, ns: ns, rw: rw, rd: rd } - end - - def c_commercial_to_jd(year, week, day, sg) - rjd2, _ = c_find_fdoy(year, sg) - rjd2 += 3 - - # Calcurate ISO week number. - rjd = (rjd2 - ((rjd2 - 1 + 1) % 7)) + 7 * (week - 1) + (day - 1) - ns = (rjd < sg) ? 0 : 1 - - [rjd, ns] - end - - def c_jd_to_commercial(jd, sg) - ry2, _, _ = c_jd_to_civil(jd - 3, sg) - a = ry2 - - rjd2, _ = c_commercial_to_jd(a + 1, 1, 1, sg) - if jd >= rjd2 - ry = a + 1 - else - rjd2, _ = c_commercial_to_jd(a, 1, 1, sg) - ry = a - end - - rw = 1 + (jd - rjd2) / 7 - rd = (jd + 1) % 7 - rd = 7 if rd.zero? - - [ry, rw, rd] - end - - def c_find_fdoy(year, sg) - if c_gregorian_only_p?(sg) - jd = c_gregorian_fdoy(year) - - return [jd, 1] - end - - # Keep existing loop for Julian/reform period - (1..30).each do |d| - result = c_valid_civil_p(year, 1, d, sg) - - return [result[:jd], result[:ns]] if result - end - - [nil, nil] - end - - def c_find_ldom(year, month, sg) - if c_gregorian_only_p?(sg) - jd = c_gregorian_ldom_jd(year, month) - - return [jd, 1] - end - - # Keep existing loop for Julian/reform period - (0..29).each do |i| - result = c_valid_civil_p(year, month, 31 - i, sg) - return [result[:jd], result[:ns]] if result - end - - nil - end - - def c_gregorian_fdoy(year) - c_gregorian_civil_to_jd(year, 1, 1) - end - - def c_jd_to_civil(jd, sg) - # Fast path: pure Gregorian or date after switchover, within safe range - if (c_gregorian_only_p?(sg) || jd >= sg) && ns_jd_in_range(jd) - return c_gregorian_jd_to_civil(jd) - end - - # Original algorithm for Julian calendar or extreme dates - if jd < sg - a = jd - else - x = ((jd - 1867216.25) / 36524.25).floor - a = jd + 1 + x - (x / 4.0).floor - end - - b = a + 1524 - c = ((b - 122.1) / 365.25).floor - d = (365.25 * c).floor - e = ((b - d) / 30.6001).floor - dom = b - d - (30.6001 * e).floor - - if e <= 13 - m = e - 1 - y = c - 4716 - else - m = e - 13 - y = c - 4715 - end - - [y.to_i, m.to_i, dom.to_i] - end - - # Optimized: Julian Day Number -> Gregorian date - def c_gregorian_jd_to_civil(jd) - # The argument jd of c_gregorian_jd_to_civil implemented in C is of type int, - # so it is converted to Integer. - jd = jd.to_i unless jd.is_a?(Integer) - - # Convert JDN to rata die (March 1, Year 0 epoch) - r0 = jd - NS_EPOCH - - # Extract century and day within 400-year cycle - # Use Euclidean (floor) division for negative values - n1 = 4 * r0 + 3 - q1 = n1 / NS_DAYS_IN_400_YEARS - r1 = (n1 % NS_DAYS_IN_400_YEARS) / 4 - - # Calculate year within century and day of year - n2 = 4 * r1 + 3 - # Use 64-bit arithmetic to avoid overflow - u2 = NS_YEAR_MULTIPLIER * n2 - q2 = u2 >> 32 - r2 = (u2 & 0xFFFFFFFF) / NS_YEAR_MULTIPLIER / 4 - - # Calculate month and day using integer arithmetic - n3 = NS_MONTH_COEFF * r2 + NS_MONTH_OFFSET - q3 = n3 >> 16 - r3 = (n3 & 0xFFFF) / NS_MONTH_COEFF - - # Combine century and year - y0 = NS_YEARS_PER_CENTURY * q1 + q2 - - # Adjust for January/February (shift from fiscal year) - j = (r2 >= NS_DAYS_BEFORE_NEW_YEAR) ? 1 : 0 - - ry = y0 + j - rm = j.nonzero? ? q3 - 12 : q3 - rd = r3 + 1 - - [ry, rm, rd] - end - - def c_gregorian_civil_to_jd(year, month, day) - j = (month < 3) ? 1 : 0 - y0 = year - j - m0 = j.nonzero? ? month + 12 : month - d0 = day - 1 - - q1 = y0 / 100 - yc = (NS_DAYS_IN_4_YEARS * y0) / 4 - q1 + q1 / 4 - - mc = (NS_DAYS_BEFORE_NEW_YEAR * m0 - 914) / 10 - - yc + mc + d0 + NS_EPOCH - end - - def valid_civil_p(y, m, d, sg) - style = guess_style(y, sg) - - if style.zero? - # If year is a Fixnum - int_year = y.to_i - - # Validate with c_valid_civil_p - result = c_valid_civil_p(int_year, m, d, sg) - return nil unless result - - # decode_jd - nth, rjd = decode_jd(result[:jd]) - - if f_zero_p?(nth) - ry = int_year - else - ns = result[:ns] - _, ry = decode_year(y, ns.nonzero? ? -1 : 1) - end - - return { nth: nth, ry: ry, rm: result[:rm], rd: result[:rd], rjd: rjd, ns: result[:ns] } - else - # If year is a large number - nth, ry = decode_year(y, style) - - result = style < 0 ? c_valid_gregorian_p(ry, m, d) : result = c_valid_julian_p(ry, m, d) - return nil unless result - - # Calculate JD from civil - rjd, ns = c_civil_to_jd(ry, result[:rm], result[:rd], style) - - return { nth: nth, ry: ry, rm: result[:rm], rd: result[:rd], rjd: rjd, ns: ns } - end - end - - def c_valid_civil_p(year, month, day, sg) - month += 13 if month < 0 - return nil if month < 1 || month > 12 - - rd = day - if rd < 0 - result = c_find_ldom(year, month, sg) - return nil unless result - - rjd2, _ = result - ry2, rm2, rd2 = c_jd_to_civil(rjd2 + rd + 1, sg) - return nil if ry2 != year || rm2 != month - - rd = rd2 - end - - rjd, ns = c_civil_to_jd(year, month, rd, sg) - ry2, rm2, rd2 = c_jd_to_civil(rjd, sg) - - return nil if ry2 != year || rm2 != month || rd2 != rd - - { jd: rjd, ns: ns, rm: rm2, rd: rd } - end - - def c_gregorian_ldom_jd(year, month) - last_day = c_gregorian_last_day_of_month(year, month) - c_gregorian_civil_to_jd(year, month, last_day) - end - - def c_gregorian_last_day_of_month(year, month) - MONTH_DAYS[gregorian_leap?(year) ? 1 : 0][month] - end - - def c_civil_to_jd(year, month, day, sg) - if c_gregorian_only_p?(sg) - jd = c_gregorian_civil_to_jd(year, month, day) - - return [jd, 1] - end - - # Calculate Gregorian JD using optimized algorithm - jd = c_gregorian_civil_to_jd(year, month, day) - - if jd < sg - y2 = year - m2 = month - if m2 <= 2 - y2 -= 1 - m2 += 12 - end - jd = (365.25 * (y2 + 4716)).floor + (30.6001 * (m2 + 1)).floor + day - 1524 - ns = 0 - else - ns = 1 - end - - [jd, ns] - end - - def decode_jd(jd) - nth = jd / CM_PERIOD - rjd = f_zero_p?(nth) ? jd : jd % CM_PERIOD - - [nth, rjd] - end - - def encode_jd(nth, rjd) - f_zero_p?(nth) ? rjd : nth * CM_PERIOD + rjd - end - - def decode_year(year, style) - period = (style < 0) ? CM_PERIOD_GCY : CM_PERIOD_JCY - - if year.is_a?(Integer) && year.abs < (1 << 30) - shifted = year + 4712 - nth = shifted / period - - shifted = shifted % period if f_nonzero_p?(nth) - - ry = shifted - 4712 - else - shifted = year + 4712 - nth = shifted / period - - shifted = shifted % period if f_nonzero_p?(nth) - - ry = shifted.to_i - 4712 - end - - [nth, ry] - end - - # Check if using pure Gregorian calendar (sg == -Infinity) - def c_gregorian_only_p?(sg) - sg.infinite? && sg < 0 - end - - def valid_ordinal_sub(year, day, start, need_jd) - day = convert_to_integer(day) - - valid_sg(start) - - result = valid_ordinal_p(year, day, start) - - return nil unless result - - return 0 unless need_jd - - encode_jd(result[:nth], result[:rjd]) - end - - def valid_ordinal_p(year, day, start) - style = guess_style(year, start) - - if style.zero? - int_year = year.to_i - result = c_valid_ordinal_p(int_year, day, start) - - return nil unless result - - nth, rjd = decode_jd(result[:jd]) - - if f_zero_p?(nth) - ry = int_year - else - ns = result[:ns] - _, ry = decode_year(year, ns.nonzero? ? -1 : 1) - end - - return { nth: nth, ry: ry, rd: result[:rd], rjd: rjd, ns: result[:ns] } - else - nth, ry = decode_year(year, style) - result = c_valid_ordinal_p(ry, day, style) - return nil unless result - - return { nth: nth, ry: ry, rd: result[:rd], rjd: result[:jd], ns: result[:ns] } - end - end - - def c_valid_ordinal_p(year, day, sg) - rd = day - if rd < 0 - result = c_find_ldoy(year, sg) - return nil unless result - - rjd2, _ = result - ry2, rd2 = c_jd_to_ordinal(rjd2 + rd + 1, sg) - return nil if ry2 != year - - rd = rd2 - end - - rjd, ns = c_ordinal_to_jd(year, rd, sg) - ry2, rd2 = c_jd_to_ordinal(rjd, sg) - - return nil if ry2 != year || rd2 != rd - - { jd: rjd, ns: ns, rd: rd } - end - - def c_find_ldoy(year, sg) - if c_gregorian_only_p?(sg) - jd = c_gregorian_ldoy(year) - - return [jd, 1] - end - - # Keep existing loop for Julian/reform period - (0..29).each do |i| - result = c_valid_civil_p(year, 12, 31 - i, sg) - - return [result[:jd], result[:ns]] if result - end - - nil - end - - # O(1) last day of year for Gregorian calendar - def c_gregorian_ldoy(year) - c_gregorian_civil_to_jd(year, 12, 31) - end - - def c_jd_to_ordinal(jd, sg) - ry, _, _ = c_jd_to_civil(jd, sg) - rjd, _ = c_find_fdoy(ry, sg) - - rd = (jd - rjd) + 1 - - [ry, rd] - end - - def c_ordinal_to_jd(year, day, sg) - rjd, _ = c_find_fdoy(year, sg) - rjd += day - 1 - ns = (rjd < sg) ? 0 : 1 - - [rjd, ns] - end - - def f_zero_p?(x) - case x - when Integer - x.zero? - when Rational - x.numerator == 0 - else - x == 0 - end - end - - def f_nonzero_p?(x) - !f_zero_p?(x) - end - - def c_gregorian_leap_p?(year) - !!(((year % 4).zero? && (year % 100).nonzero?) || (year % 400).zero?) - end - - def c_julian_leap_p?(year) - (year % 4).zero? - end - - def new_with_jd(nth, jd, start) - new_with_jd_and_time(nth, jd, nil, nil, nil, start) - end - - def new_with_jd_and_time(nth, jd, df, sf, of, start) - obj = allocate - obj.send(:_init_with_jd, nth, jd, df, sf, of, start) - obj - end - - def valid_gregorian_p(y, m, d) - decode_year(y, -1) - - c_valid_gregorian_p(y, m, d) - end - - def c_valid_gregorian_p(y, m, d) - m += 13 if m < 0 - return nil if m < 1 || m > 12 - - last = c_gregorian_last_day_of_month(y, m) - d = last + d + 1 if d < 0 - return nil if d < 1 || d > last - - { rm: m, rd: d } - end - - def c_valid_julian_p(y, m, d) - m += 13 if m < 0 - return nil if m < 1 || m > 12 - - last = c_julian_last_day_of_month(y, m) - d = last + d + 1 if d < 0 - return nil if d < 1 || d > last - - { rm: m, rd: d } - end - - def c_julian_last_day_of_month(y, m) - raise Error unless m >= 1 && m <= 12 - - MONTH_DAYS[julian_leap?(y) ? 1 : 0][m] - end - - # Create a simple Date object. - def d_lite_s_alloc_simple - obj = allocate - obj.instance_variable_set(:@nth, 0) - obj.instance_variable_set(:@jd, 0) - obj.instance_variable_set(:@sg, DEFAULT_SG) - obj.instance_variable_set(:@df, nil) - obj.instance_variable_set(:@sf, nil) - obj.instance_variable_set(:@of, nil) - obj.instance_variable_set(:@year, nil) - obj.instance_variable_set(:@month, nil) - obj.instance_variable_set(:@day, nil) - obj.instance_variable_set(:@has_jd, true) - obj.instance_variable_set(:@has_civil, false) - - obj - end - - # Create a complex Date object. - def d_lite_s_alloc_complex - obj = allocate - obj.instance_variable_set(:@nth, 0) - obj.instance_variable_set(:@jd, 0) - obj.instance_variable_set(:@sg, DEFAULT_SG) - obj.instance_variable_set(:@df, nil) - obj.instance_variable_set(:@sf, nil) - obj.instance_variable_set(:@of, nil) - obj.instance_variable_set(:@year, nil) - obj.instance_variable_set(:@month, nil) - obj.instance_variable_set(:@day, nil) - obj.instance_variable_set(:@hour, nil) - obj.instance_variable_set(:@min, nil) - obj.instance_variable_set(:@sec, nil) - obj.instance_variable_set(:@has_jd, true) - obj.instance_variable_set(:@has_civil, false) - - obj - end - - def value_trunc(value) - if value.is_a?(Integer) - [value, 0] - elsif value.is_a?(Float) || value.is_a?(Rational) - trunc = value.truncate - frac = value - trunc - - [trunc, frac] - else - [value.to_i, 0] - end - end - - def d_simple_new_internal(nth, jd, sg, year, mon, mday, flags) - obj = allocate - obj.instance_variable_set(:@nth, canon(nth)) - obj.instance_variable_set(:@jd, jd) - obj.instance_variable_set(:@sg, sg) - obj.instance_variable_set(:@year, year) - obj.instance_variable_set(:@month, mon) - obj.instance_variable_set(:@day, mday) - obj.instance_variable_set(:@has_jd, (flags & HAVE_JD).nonzero?) - obj.instance_variable_set(:@has_civil, (flags & HAVE_CIVIL).nonzero?) - obj.instance_variable_set(:@df, nil) - obj.instance_variable_set(:@sf, nil) - obj.instance_variable_set(:@of, nil) - - obj - end - - def canon(x) - x.is_a?(Rational) && x.denominator == 1 ? x.numerator : x - end - - def ns_jd_in_range(jd) - jd >= NS_JD_MIN && jd <= NS_JD_MAX - end - - def check_limit(str, limit) - unless str.is_a?(String) - begin - str = str.to_str - rescue NoMethodError - raise TypeError, "no implicit conversion of #{str.class} into String" - end - end - - if limit && str.length > limit - raise ArgumentError, "string length (#{str.length}) exceeds the limit #{limit}" - end - - str - end - end - - # Instance methods - - # call-seq: - # year -> integer - # - # Returns the year: - # - # Date.new(2001, 2, 3).year # => 2001 - # (Date.new(1, 1, 1) - 1).year # => 0 - def year - # Hot path: inline m_real_year for the common case (@nth=0, civil cached) - return @year if @nth == 0 && @has_civil - m_real_year - end - - # call-seq: - # mon -> integer - # - # Returns the month in range (1..12): - # - # Date.new(2001, 2, 3).mon # => 2 - def month - # Hot path: inline m_mon for the common case (civil cached) - return @month if @has_civil - m_mon - end - alias mon month - - def day - # Hot path: inline m_mday for the common case (civil cached) - return @day if @has_civil - m_mday - end - alias mday day - - # call-seq: - # d.jd -> integer - # - # Returns the Julian day number. This is a whole number, which is - # adjusted by the offset as the local time. - # - # DateTime.new(2001,2,3,4,5,6,'+7').jd #=> 2451944 - # DateTime.new(2001,2,3,4,5,6,'-7').jd #=> 2451944 - def jd - return @jd if @nth == 0 && @has_jd - m_real_jd - end - - # call-seq: - # start -> float - # - # Returns the Julian start date for calendar reform; - # if not an infinity, the returned value is suitable - # for passing to Date#jd: - # - # d = Date.new(2001, 2, 3, Date::ITALY) - # s = d.start # => 2299161.0 - # Date.jd(s).to_s # => "1582-10-15" - # - # d = Date.new(2001, 2, 3, Date::ENGLAND) - # s = d.start # => 2361222.0 - # Date.jd(s).to_s # => "1752-09-14" - # - # Date.new(2001, 2, 3, Date::GREGORIAN).start # => -Infinity - # Date.new(2001, 2, 3, Date::JULIAN).start # => Infinity - # - # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. - def start - @sg - end - - # call-seq: - # self <=> other -> -1, 0, 1 or nil - # - # Compares +self+ and +other+, returning: - # - # - -1 if +other+ is larger. - # - 0 if the two are equal. - # - 1 if +other+ is smaller. - # - +nil+ if the two are incomparable. - # - # Argument +other+ may be: - # - # - Another \Date object: - # - # d = Date.new(2022, 7, 27) # => # - # prev_date = d.prev_day # => # - # next_date = d.next_day # => # - # d <=> next_date # => -1 - # d <=> d # => 0 - # d <=> prev_date # => 1 - # - # - A DateTime object: - # - # d <=> DateTime.new(2022, 7, 26) # => 1 - # d <=> DateTime.new(2022, 7, 27) # => 0 - # d <=> DateTime.new(2022, 7, 28) # => -1 - # - # - A numeric (compares self.ajd to +other+): - # - # d <=> 2459788 # => -1 - # d <=> 2459787 # => 1 - # d <=> 2459786 # => 1 - # d <=> d.ajd # => 0 - # - # - Any other object: - # - # d <=> Object.new # => nil - def <=>(other) - if other.is_a?(Date) && - @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && - other.instance_variable_get(:@nth) == 0 && - other.instance_variable_get(:@has_jd) && - other.instance_variable_get(:@df).nil? && - other.instance_variable_get(:@sf).nil? && - other.instance_variable_get(:@of).nil? - return @jd <=> other.instance_variable_get(:@jd) - end - - case other - when Date - m_canonicalize_jd - other.send(:m_canonicalize_jd) - - a_nth = m_nth - b_nth = other.send(:m_nth) - - cmp = a_nth <=> b_nth - return cmp if cmp.nonzero? - - a_jd = m_jd - b_jd = other.send(:m_jd) - - cmp = a_jd <=> b_jd - return cmp if cmp.nonzero? - - a_df = m_df - b_df = other.send(:m_df) - - cmp = a_df <=> b_df - return cmp if cmp.nonzero? - - a_sf = m_sf - b_sf = other.send(:m_sf) - - a_sf <=> b_sf - when Numeric - ajd <=> other - else - begin - l, r = other.coerce(self) - l <=> r - rescue NoMethodError - nil - end - end - end - - def <(other) # :nodoc: - if other.is_a?(Date) && - @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && - other.instance_variable_get(:@nth) == 0 && - other.instance_variable_get(:@has_jd) && - other.instance_variable_get(:@df).nil? && - other.instance_variable_get(:@sf).nil? && - other.instance_variable_get(:@of).nil? - return @jd < other.instance_variable_get(:@jd) - end - super - end - - def >(other) # :nodoc: - if other.is_a?(Date) && - @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && - other.instance_variable_get(:@nth) == 0 && - other.instance_variable_get(:@has_jd) && - other.instance_variable_get(:@df).nil? && - other.instance_variable_get(:@sf).nil? && - other.instance_variable_get(:@of).nil? - return @jd > other.instance_variable_get(:@jd) - end - super - end - - # call-seq: - # self === other -> true, false, or nil. - # - # Returns +true+ if +self+ and +other+ represent the same date, - # +false+ if not, +nil+ if the two are not comparable. - # - # Argument +other+ may be: - # - # - Another \Date object: - # - # d = Date.new(2022, 7, 27) # => # - # prev_date = d.prev_day # => # - # next_date = d.next_day # => # - # d === prev_date # => false - # d === d # => true - # d === next_date # => false - # - # - A DateTime object: - # - # d === DateTime.new(2022, 7, 26) # => false - # d === DateTime.new(2022, 7, 27) # => true - # d === DateTime.new(2022, 7, 28) # => false - # - # - A numeric (compares self.jd to +other+): - # - # d === 2459788 # => true - # d === 2459787 # => false - # d === 2459786 # => false - # d === d.jd # => true - # - # - An object not comparable: - # - # d === Object.new # => nil - def ===(other) - if other.is_a?(Date) && - @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && - @jd >= 0 && @jd < CM_PERIOD && - other.instance_variable_get(:@nth) == 0 && - other.instance_variable_get(:@has_jd) && - other.instance_variable_get(:@df).nil? && - other.instance_variable_get(:@sf).nil? && - other.instance_variable_get(:@of).nil? - return @jd == other.instance_variable_get(:@jd) - end - - return equal_gen(other) unless other.is_a?(Date) - - # Call equal_gen even if the Gregorian calendars do not match. - return equal_gen(other) unless m_gregorian_p? == other.send(:m_gregorian_p?) - - m_canonicalize_jd - other.send(:m_canonicalize_jd) - - a_nth = m_nth - b_nth = other.send(:m_nth) - a_jd = m_local_jd - b_jd = other.send(:m_local_jd) - - a_nth == b_nth && a_jd == b_jd - end - - # call-seq: - # d >> n -> new_date - # - # Returns a new \Date object representing the date - # +n+ months later; +n+ should be a numeric: - # - # (Date.new(2001, 2, 3) >> 1).to_s # => "2001-03-03" - # (Date.new(2001, 2, 3) >> -2).to_s # => "2000-12-03" - # - # When the same day does not exist for the new month, - # the last day of that month is used instead: - # - # (Date.new(2001, 1, 31) >> 1).to_s # => "2001-02-28" - # (Date.new(2001, 1, 31) >> -4).to_s # => "2000-09-30" - # - # This results in the following, possibly unexpected, behaviors: - # - # d0 = Date.new(2001, 1, 31) - # d1 = d0 >> 1 # => # - # d2 = d1 >> 1 # => # - # - # d0 = Date.new(2001, 1, 31) - # d1 = d0 >> 1 # => # - # d2 = d1 >> -1 # => # - def >>(n) - if n.is_a?(Integer) && @of.nil? && @nth == 0 && @has_civil - sg = @sg - gregorian_fast = if sg.is_a?(Float) && sg.infinite? - sg < 0 - elsif sg.is_a?(Integer) && sg >= REFORM_BEGIN_JD && sg <= REFORM_END_JD - @year > REFORM_END_YEAR - end - if gregorian_fast - t = @year * 12 + (@month - 1) + n - y = t / 12 - m = (t % 12) + 1 - d = @day - - leap = (y % 4 == 0) && (y % 100 != 0 || y % 400 == 0) - last = MONTH_DAYS[leap ? 1 : 0][m] - d = last if d > last - - obj = self.class.allocate - obj._init_simple_with_civil(y, m, d, sg) - return obj - end - end - - # Calculate years and months - t = m_real_year * 12 + (m_mon - 1) + n - - if t.is_a?(Integer) && t.abs < (1 << 62) - # Fixnum - y = t / 12 - m = (t % 12) + 1 - else - # Bignum - y = t.div(12) - m = (t % 12).to_i + 1 - end - - d = m_mday - sg = m_sg - - # Decrement days until a valid date. - result = nil - loop do - result = self.class.send(:valid_civil_p, y, m, d, sg) - break if result - - d -= 1 - raise Error if d < 1 - end - - nth = result[:nth] - rjd = result[:rjd] - rjd2 = self.class.send(:encode_jd, nth, rjd) - - self + (rjd2 - m_real_local_jd) - end - - # call-seq: - # d << n -> date - # - # Returns a new \Date object representing the date - # +n+ months earlier; +n+ should be a numeric: - # - # (Date.new(2001, 2, 3) << 1).to_s # => "2001-01-03" - # (Date.new(2001, 2, 3) << -2).to_s # => "2001-04-03" - # - # When the same day does not exist for the new month, - # the last day of that month is used instead: - # - # (Date.new(2001, 3, 31) << 1).to_s # => "2001-02-28" - # (Date.new(2001, 3, 31) << -6).to_s # => "2001-09-30" - # - # This results in the following, possibly unexpected, behaviors: - # - # d0 = Date.new(2001, 3, 31) - # d0 << 2 # => # - # d0 << 1 << 1 # => # - # - # d0 = Date.new(2001, 3, 31) - # d1 = d0 << 1 # => # - # d2 = d1 << -1 # => # - def <<(n) - if n.is_a?(Integer) && @of.nil? && @nth == 0 && @has_civil - sg = @sg - gregorian_fast = if sg.is_a?(Float) && sg.infinite? - sg < 0 - elsif sg.is_a?(Integer) && sg >= REFORM_BEGIN_JD && sg <= REFORM_END_JD - @year > REFORM_END_YEAR - end - if gregorian_fast - t = @year * 12 + (@month - 1) - n - y = t / 12 - m = (t % 12) + 1 - d = @day - - leap = (y % 4 == 0) && (y % 100 != 0 || y % 400 == 0) - last = MONTH_DAYS[leap ? 1 : 0][m] - d = last if d > last - - obj = self.class.allocate - obj._init_simple_with_civil(y, m, d, sg) - return obj - end - end - - raise TypeError, "expected numeric" unless n.is_a?(Numeric) - - t = m_real_year * 12 + (m_mon - 1) - n - - if t.is_a?(Integer) && t.abs < (1 << 62) - y = t / 12 - m = (t % 12) + 1 - else - y = t.div(12) - m = (t % 12).to_i + 1 - end - - d = m_mday - sg = m_sg - - result = nil - loop do - result = self.class.send(:valid_civil_p, y, m, d, sg) - break if result - - d -= 1 - raise Error if d < 1 - end - - nth = result[:nth] - rjd = result[:rjd] - rjd2 = self.class.send(:encode_jd, nth, rjd) - - self + (rjd2 - m_real_local_jd) - end - - def ==(other) # :nodoc: - if other.is_a?(Date) && - @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && - other.instance_variable_get(:@nth) == 0 && - other.instance_variable_get(:@has_jd) && - other.instance_variable_get(:@df).nil? && - other.instance_variable_get(:@sf).nil? && - other.instance_variable_get(:@of).nil? - return @jd == other.instance_variable_get(:@jd) - end - - return false unless other.is_a?(Date) - - m_canonicalize_jd - other.send(:m_canonicalize_jd) - - m_nth == other.send(:m_nth) && - m_jd == other.send(:m_jd) && - m_df == other.send(:m_df) && - m_sf == other.send(:m_sf) - end - - def eql?(other) # :nodoc: - if other.is_a?(Date) && - @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && - other.instance_variable_get(:@nth) == 0 && - other.instance_variable_get(:@has_jd) && - other.instance_variable_get(:@df).nil? && - other.instance_variable_get(:@sf).nil? && - other.instance_variable_get(:@of).nil? - return @jd == other.instance_variable_get(:@jd) && - @sg == other.instance_variable_get(:@sg) - end - - return false unless other.is_a?(Date) - - m_canonicalize_jd - other.send(:m_canonicalize_jd) - - m_nth == other.send(:m_nth) && - m_jd == other.send(:m_jd) && - @sg == other.instance_variable_get(:@sg) - end - - def hash # :nodoc: - if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_jd && - @jd >= 0 && @jd < CM_PERIOD - return [0, @jd, @sg].hash - end - m_canonicalize_jd - [m_nth, m_jd, @sg].hash - end - - # call-seq: - # d + other -> date - # - # Returns a date object pointing +other+ days after self. The other - # should be a numeric value. If the other is a fractional number, - # assumes its precision is at most nanosecond. - # - # Date.new(2001,2,3) + 1 #=> # - # DateTime.new(2001,2,3) + Rational(1,2) - # #=> # - # DateTime.new(2001,2,3) + Rational(-1,2) - # #=> # - # DateTime.jd(0,12) + DateTime.new(2001,2,3).ajd - # #=> # - def +(other) - if other.is_a?(Integer) && @of.nil? && @nth == 0 - if @has_jd - jd = @jd + other - elsif @has_civil - sg = @sg - gregorian_fast = if sg.is_a?(Float) && sg.infinite? - sg < 0 - elsif sg.is_a?(Integer) && sg >= REFORM_BEGIN_JD && sg <= REFORM_END_JD - @year > REFORM_END_YEAR - end - if gregorian_fast - j = (@month < 3) ? 1 : 0 - y0 = @year - j - m0 = j.nonzero? ? @month + 12 : @month - d0 = @day - 1 - q1 = y0 / 100 - yc = (NS_DAYS_IN_4_YEARS * y0) / 4 - q1 + q1 / 4 - mc = (NS_DAYS_BEFORE_NEW_YEAR * m0 - 914) / 10 - jd = yc + mc + d0 + NS_EPOCH + other - end - end - if jd && jd >= 0 && jd < CM_PERIOD - obj = self.class.allocate - obj._init_simple_with_jd(jd, @sg) - return obj - end - end - - case other - when Integer - nth = m_nth - jd = m_jd - - if (other / CM_PERIOD).nonzero? - nth = nth + (other / CM_PERIOD) - other = other % CM_PERIOD - end - - if other.nonzero? - jd = jd + other - nth, jd = canonicalize_jd(nth, jd) - end - - obj = self.class.allocate - if simple_dat_p? - obj._init_with_jd(nth, jd, nil, nil, nil, @sg) - else - obj._init_with_jd(nth, jd, @df || 0, @sf || 0, @of || 0, @sg) - end - obj - when Float - s = other >= 0 ? 1 : -1 - o = other.abs - - tmp, o = o.divmod(1.0) - - if (tmp / CM_PERIOD).floor.zero? - nth = 0 - jd = tmp.to_i - else - i, f = (tmp / CM_PERIOD).divmod(1.0) - nth = i.floor - jd = (f * CM_PERIOD).to_i - end - - o *= DAY_IN_SECONDS - df, o = o.divmod(1.0) - df = df.to_i - o *= SECOND_IN_NANOSECONDS - sf = o.round - - if s < 0 - jd = -jd - df = -df - sf = -sf - end - - if sf.nonzero? - sf = 0 + sf - if sf < 0 - df -= 1 - sf += SECOND_IN_NANOSECONDS - elsif sf >= SECOND_IN_NANOSECONDS - df += 1 - sf -= SECOND_IN_NANOSECONDS - end - end - - if df.nonzero? - df = 0 + df - if df < 0 - jd -= 1 - df += DAY_IN_SECONDS - elsif df >= DAY_IN_SECONDS - jd += 1 - df -= DAY_IN_SECONDS - end - end - - if jd.nonzero? - jd = m_jd + jd - nth, jd = canonicalize_jd(nth, jd) - else - jd = m_jd - end - - nth = nth.nonzero? ? @nth + nth : @nth - - obj = self.class.allocate - if df.zero? && sf.zero? && (@of.nil? || @of.zero?) - obj._init_with_jd(nth, jd, nil, nil, nil, @sg) - else - obj._init_with_jd(nth, jd, df, sf, @of || 0, @sg) - end - obj - when Rational - return self + other.numerator if other.denominator == 1 - - s = other >= 0 ? 1 : -1 - other = other.abs - - nth = other.div(CM_PERIOD) - t = other % CM_PERIOD - - jd = t.div(1).to_i - t = t % 1 - - t = t * DAY_IN_SECONDS - df = t.div(1).to_i - t = t % 1 - - sf = t * SECOND_IN_NANOSECONDS - - if s < 0 - nth = -nth - jd = -jd - df = -df - sf = -sf - end - - if sf.nonzero? - sf = (@sf || 0) + sf - if sf < 0 - df -= 1 - sf += SECOND_IN_NANOSECONDS - elsif sf >= SECOND_IN_NANOSECONDS - df += 1 - sf -= SECOND_IN_NANOSECONDS - end - else - sf = @sf || 0 - end - - if df.nonzero? - df = (@df || 0) + df - if df < 0 - jd -= 1 - df += DAY_IN_SECONDS - elsif df >= DAY_IN_SECONDS - jd += 1 - df -= DAY_IN_SECONDS - end - else - df = @df || 0 - end - - if jd.nonzero? - jd = m_jd + jd - nth, jd = canonicalize_jd(nth, jd) - else - jd = m_jd - end - - nth = nth.nonzero? ? @nth + nth : @nth - - obj = self.class.allocate - if df.zero? && sf.zero? - obj._init_with_jd(nth, jd, nil, nil, nil, @sg) - else - obj._init_with_jd(nth, jd, df, sf, @of || 0, @sg) - end - obj - else - raise TypeError, "expected numeric" unless other.is_a?(Numeric) - - other = other.to_r - raise TypeError, "expected numeric" unless other.is_a?(Rational) - - self + other - end - end - - # call-seq: - # d - other -> date or rational - # - # If the other is a date object, returns a Rational - # whose value is the difference between the two dates in days. - # If the other is a numeric value, returns a date object - # pointing +other+ days before self. - # If the other is a fractional number, - # assumes its precision is at most nanosecond. - # - # Date.new(2001,2,3) - 1 #=> # - # DateTime.new(2001,2,3) - Rational(1,2) #=> # - # Date.new(2001,2,3) - Date.new(2001) #=> (33/1) - # DateTime.new(2001,2,3) - DateTime.new(2001,2,2,12) #=> (1/2) - def -(other) - if other.is_a?(Integer) && @of.nil? && @nth == 0 && @has_jd - jd = @jd - other - if jd >= 0 && jd < CM_PERIOD - obj = self.class.allocate - obj._init_simple_with_jd(jd, @sg) - return obj - end - end - - if other.is_a?(Date) - # Hot path: both simple dates with @nth=0 and JD set. - # Result is always Rational(jd_self - jd_other, 1). - if @df.nil? && @sf.nil? && @of.nil? && @has_jd && @nth == 0 && - other.send(:simple_dat_p?) && - other.instance_variable_get(:@has_jd) && - other.instance_variable_get(:@nth) == 0 - return Rational(@jd - other.instance_variable_get(:@jd), 1) - end - return minus_dd(other) - end - - raise TypeError, "expected numeric" unless other.is_a?(Numeric) - - # Add a negative value for numbers. - # Works with all types: Integer, Float, Rational, Bignum, etc. - self + (-other) - end - - # call-seq: - # gregorian -> new_date - # - # Equivalent to Date#new_start with argument Date::GREGORIAN. - def gregorian - dup_obj_with_new_start(GREGORIAN) - end - - # call-seq: - # gregorian? -> true or false - # - # Returns +true+ if the date is on or after - # the date of calendar reform, +false+ otherwise: - # - # Date.new(1582, 10, 15).gregorian? # => true - # (Date.new(1582, 10, 15) - 1).gregorian? # => false - def gregorian? - m_gregorian_p? - end - - # call-seq: - # italy -> new_date - # - # Equivalent to Date#new_start with argument Date::ITALY. - def italy - dup_obj_with_new_start(ITALY) - end - - # call-seq: - # england -> new_date - # - # Equivalent to Date#new_start with argument Date::ENGLAND. - def england - dup_obj_with_new_start(ENGLAND) - end - - # call-seq: - # julian -> new_date - # - # Equivalent to Date#new_start with argument Date::JULIAN. - def julian - dup_obj_with_new_start(JULIAN) - end - - # call-seq: - # d.julian? -> true or false - # - # Returns +true+ if the date is before the date of calendar reform, - # +false+ otherwise: - # - # (Date.new(1582, 10, 15) - 1).julian? # => true - # Date.new(1582, 10, 15).julian? # => false - def julian? - m_julian_p? - end - - # call-seq: - # ld -> integer - # - # Returns the - # {Lilian day number}[https://en.wikipedia.org/wiki/Lilian_date], - # which is the number of days since the beginning of the Gregorian - # calendar, October 15, 1582. - # - # Date.new(2001, 2, 3).ld # => 152784 - def ld - # Hot path: simple Date with @nth=0 and JD already set. - if @df.nil? && @sf.nil? && @of.nil? && @has_jd && @nth == 0 - return @jd - 2299160 - end - m_real_local_jd - 2299160 - end - - # call-seq: - # leap? -> true or false - # - # Returns +true+ if the year is a leap year, +false+ otherwise: - # - # Date.new(2000).leap? # => true - # Date.new(2001).leap? # => false - def leap? - return @leap unless @leap.nil? - result = if gregorian? - self.class.send(:c_gregorian_leap_p?, m_year) - else - # For the Julian calendar, calculate JD for March 1st. - y = m_year - sg = m_virtual_sg - rjd, _ = self.class.send(:c_civil_to_jd, y, 3, 1, sg) - - # Get the date of the day before March 1st (the last day of February). - _, _, rd = self.class.send(:c_jd_to_civil, rjd - 1, sg) - - # If February 29th exists, it is a leap year. - rd == 29 - end - @leap = result unless frozen? - result - end - - # call-seq: - # new_start(start = Date::ITALY]) -> new_date - # - # Returns a copy of +self+ with the given +start+ value: - # - # d0 = Date.new(2000, 2, 3) - # d0.julian? # => false - # d1 = d0.new_start(Date::JULIAN) - # d1.julian? # => true - # - # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. - def new_start(start = DEFAULT_SG) - sg = start ? val2sg(start) : DEFAULT_SG - - dup_obj_with_new_start(sg) - end - - # call-seq: - # next_day(n = 1) -> new_date - # - # Equivalent to Date#+ with argument +n+. - def next_day(n = 1) - self + n - end - - # call-seq: - # prev_day(n = 1) -> new_date - # - # Equivalent to Date#- with argument +n+. - def prev_day(n = 1) - self - n - end - - # call-seq: - # d.next -> new_date - # - # Returns a new \Date object representing the following day: - # - # d = Date.new(2001, 2, 3) - # d.to_s # => "2001-02-03" - # d.next.to_s # => "2001-02-04" - def next - next_day - end - alias_method :succ, :next - - # call-seq: - # next_year(n = 1) -> new_date - # - # Equivalent to #>> with argument n * 12. - def next_year(n = 1) - self >> (n * 12) - end - - # call-seq: - # prev_year(n = 1) -> new_date - # - # Equivalent to #<< with argument n * 12. - def prev_year(n = 1) - self << (n * 12) - end - - # call-seq: - # next_month(n = 1) -> new_date - # - # Equivalent to #>> with argument +n+. - def next_month(n = 1) - self >> n - end - - # call-seq: - # prev_month(n = 1) -> new_date - # - # Equivalent to #<< with argument +n+. - def prev_month(n = 1) - self << n - end - - # call-seq: - # sunday? -> true or false - # - # Returns +true+ if +self+ is a Sunday, +false+ otherwise. - def sunday? - m_wday.zero? - end - - # call-seq: - # monday? -> true or false - # - # Returns +true+ if +self+ is a Monday, +false+ otherwise. - def monday? - m_wday == 1 - end - - # call-seq: - # tuesday? -> true or false - # - # Returns +true+ if +self+ is a Tuesday, +false+ otherwise. - def tuesday? - m_wday == 2 - end - - # call-seq: - # wednesday? -> true or false - # - # Returns +true+ if +self+ is a Wednesday, +false+ otherwise. - def wednesday? - m_wday == 3 - end - - # call-seq: - # thursday? -> true or false - # - # Returns +true+ if +self+ is a Thursday, +false+ otherwise. - def thursday? - m_wday == 4 - end - - # call-seq: - # friday? -> true or false - # - # Returns +true+ if +self+ is a Friday, +false+ otherwise. - def friday? - m_wday == 5 - end - - # call-seq: - # saturday? -> true or false - # - # Returns +true+ if +self+ is a Saturday, +false+ otherwise. - def saturday? - m_wday == 6 - end - - # call-seq: - # wday -> integer - # - # Returns the day of week in range (0..6); Sunday is 0: - # - # Date.new(2001, 2, 3).wday # => 6 - def wday - # Hot path: inline m_wday for simple Date (C: (jd + 1) % 7) - return (@jd + 1) % 7 if @has_jd && @of.nil? - m_wday - end - - # call-seq: - # yday -> integer - # - # Returns the day of the year, in range (1..366): - # - # Date.new(2001, 2, 3).yday # => 34 - def yday - return @yday if @yday - val = m_yday - @yday = val unless frozen? - val - end - - # call-seq: - # deconstruct_keys(array_of_names_or_nil) -> hash - # - # Returns a hash of the name/value pairs, to use in pattern matching. - # Possible keys are: :year, :month, :day, - # :wday, :yday. - # - # Possible usages: - # - # d = Date.new(2022, 10, 5) - # - # if d in wday: 3, day: ..7 # uses deconstruct_keys underneath - # puts "first Wednesday of the month" - # end - # #=> prints "first Wednesday of the month" - # - # case d - # in year: ...2022 - # puts "too old" - # in month: ..9 - # puts "quarter 1-3" - # in wday: 1..5, month: - # puts "working day in month #{month}" - # end - # #=> prints "working day in month 10" - # - # Note that deconstruction by pattern can also be combined with class check: - # - # if d in Date(wday: 3, day: ..7) - # puts "first Wednesday of the month" - # end - def deconstruct_keys(keys) - if keys.nil? - return { - year: year, - month: month, - day: day, - yday: yday, - wday: wday - } - end - - raise TypeError, "wrong argument type #{keys.class} (expected Array or nil)" unless keys.is_a?(Array) - - h = {} - keys.each do |key| - case key - when :year then h[:year] = year - when :month then h[:month] = month - when :day then h[:day] = day - when :yday then h[:yday] = yday - when :wday then h[:wday] = wday - when :zone then h[:zone] = zone - end - end - h - end - - # call-seq: - # step(limit, step = 1){|date| ... } -> self - # - # Calls the block with specified dates; - # returns +self+. - # - # - The first +date+ is +self+. - # - Each successive +date+ is date + step, - # where +step+ is the numeric step size in days. - # - The last date is the last one that is before or equal to +limit+, - # which should be a \Date object. - # - # Example: - # - # limit = Date.new(2001, 12, 31) - # Date.new(2001).step(limit){|date| p date.to_s if date.mday == 31 } - # - # Output: - # - # "2001-01-31" - # "2001-03-31" - # "2001-05-31" - # "2001-07-31" - # "2001-08-31" - # "2001-10-31" - # "2001-12-31" - # - # Returns an Enumerator if no block is given. - def step(limit, step = 1) - raise ArgumentError, "step must be numeric" unless step.respond_to?(:<=>) - - return to_enum(:step, limit, step) unless block_given? - - date = self - cmp = step <=> 0 - - raise ArgumentError, "step must be numeric" if cmp.nil? - - case cmp - when -1 - # If step is negative (reverse order) - while (date <=> limit) >= 0 - yield date - date = date + step - end - when 0 - # If step is 0 (infinite loop) - loop do - yield date - end - else - # If step is positive (forward direction) - while (date <=> limit) <= 0 - yield date - date = date + step - end - end - - self - end - - # call-seq: - # upto(max){|date| ... } -> self - # - # Equivalent to #step with arguments +max+ and +1+. - def upto(max) - return to_enum(:upto, max) unless block_given? - - date = self - - while (date <=> max) <= 0 - yield date - date = date + 1 - end - - self - end - - # call-seq: - # downto(min){|date| ... } -> self - # - # Equivalent to #step with arguments +min+ and -1. - def downto(min) - return to_enum(:downto, min) unless block_given? - - date = self - - while (date <=> min) >= 0 - yield date - date = date - 1 - end - - self - end - - # call-seq: - # day_fraction -> rational - # - # Returns the fractional part of the day in range (Rational(0, 1)...Rational(1, 1)): - # - # DateTime.new(2001,2,3,12).day_fraction # => (1/2) - def day_fraction - simple_dat_p? ? 0 : m_fr - end - - # call-seq: - # d.mjd -> integer - # - # Returns the modified Julian day number. This is a whole number, - # which is adjusted by the offset as the local time. - # - # DateTime.new(2001,2,3,4,5,6,'+7').mjd #=> 51943 - # DateTime.new(2001,2,3,4,5,6,'-7').mjd #=> 51943 - def mjd - # Hot path: simple Date with @nth=0 and JD already set. - if @df.nil? && @sf.nil? && @of.nil? && @has_jd && @nth == 0 - return @jd - 2_400_001 - end - m_real_local_jd - 2_400_001 - end - - # call-seq: - # cwyear -> integer - # - # Returns commercial-date year for +self+ - # (see Date.commercial): - # - # Date.new(2001, 2, 3).cwyear # => 2001 - # Date.new(2000, 1, 1).cwyear # => 1999 - def cwyear - m_real_cwyear - end - - # call-seq: - # cweek -> integer - # - # Returns commercial-date week index for +self+ - # (see Date.commercial): - # - # Date.new(2001, 2, 3).cweek # => 5 - def cweek - m_cweek - end - - # call-seq: - # cwday -> integer - # - # Returns the commercial-date weekday index for +self+ - # (see Date.commercial); - # 1 is Monday: - # - # Date.new(2001, 2, 3).cwday # => 6 - def cwday - m_cwday - end - - # call-seq: - # to_time -> time - # - # Returns a new Time object with the same value as +self+; - # if +self+ is a Julian date, derives its Gregorian date - # for conversion to the \Time object: - # - # Date.new(2001, 2, 3).to_time # => 2001-02-03 00:00:00 -0600 - # Date.new(2001, 2, 3, Date::JULIAN).to_time # => 2001-02-16 00:00:00 -0600 - def to_time - # Julian calendar converted to Gregorian calendar. - date = m_julian_p? ? gregorian : self - - # Create a Time object using Time.local. - Time.local( - date.send(:m_real_year), - date.send(:m_mon), - date.send(:m_mday) - ) - end - - # call-seq: - # to_date -> self - # - # Returns +self+. - def to_date - self - end - - # call-seq: - # to_datetime -> datetime - # - # Returns a DateTime whose value is the same as +self+. - def to_datetime - # Hot path: simple Date with JD already set. - # C: d_lite_to_datetime passes @nth, @jd, @sg directly (no civil->JD conversion). - if @df.nil? && @sf.nil? && @of.nil? && @has_jd - return DateTime.send(:new_with_jd_and_time, @nth, @jd, 0, 0, 0, @sg) - end - - # Original path for complex dates or JD-less simple dates. - nth, ry = self.class.send(:decode_year, year, -1) - rjd, _ = self.class.send(:c_civil_to_jd, ry, month, day, Date::GREGORIAN) - obj = DateTime.send(:new_with_jd_and_time, nth, rjd, 0, 0, 0, Date::GREGORIAN) - obj.send(:set_sg, start) - obj - end - - # call-seq: - # d.ajd -> rational - # - # Returns the astronomical Julian day number. This is a fractional - # number, which is not adjusted by the offset. - # - # DateTime.new(2001,2,3,4,5,6,'+7').ajd #=> (11769328217/4800) - # DateTime.new(2001,2,2,14,5,6,'-7').ajd #=> (11769328217/4800) - def ajd - # Hot path: simple Date with @nth=0 and JD already set. - # ajd = jd - 1/2 = Rational(jd * 2 - 1, 2) - if @df.nil? && @sf.nil? && @of.nil? && @has_jd && @nth == 0 - return Rational(@jd * 2 - 1, 2) - end - m_ajd - end - - # call-seq: - # d.amjd -> rational - # - # Returns the astronomical modified Julian day number. This is - # a fractional number, which is not adjusted by the offset. - # - # DateTime.new(2001,2,3,4,5,6,'+7').amjd #=> (249325817/4800) - # DateTime.new(2001,2,2,14,5,6,'-7').amjd #=> (249325817/4800) - def amjd - # Hot path: simple Date with @nth=0 and JD already set. - # amjd = jd - 2400001 as Rational - if @df.nil? && @sf.nil? && @of.nil? && @has_jd && @nth == 0 - return Rational(@jd - 2400001, 1) - end - m_amjd - end - - # :nodoc: - # C: d_lite_initialize_copy - def initialize_copy(other) - unless other.is_a?(Date) - raise TypeError, "initialize_copy should take same class object" - end - @nth = other.instance_variable_get(:@nth) - @jd = other.instance_variable_get(:@jd) - @sg = other.instance_variable_get(:@sg) - @df = other.instance_variable_get(:@df) - @sf = other.instance_variable_get(:@sf) - @of = other.instance_variable_get(:@of) - @year = other.instance_variable_get(:@year) - @month = other.instance_variable_get(:@month) - @day = other.instance_variable_get(:@day) - @has_jd = other.instance_variable_get(:@has_jd) - @has_civil = other.instance_variable_get(:@has_civil) - self - end - - # :nodoc: - def marshal_dump - [ - m_nth, - m_jd, - m_df, - m_sf, - m_of, - @sg - ] - end - - # :nodoc: - # C: d_lite_marshal_load - # Supports 3 historical formats: - # 2 elements (1.4/1.6): [jd_like, sg_or_bool] - # 3 elements (1.8/1.9.2): [ajd, of, sg] - # 6 elements (current): [nth, jd, df, sf, of, sg] - def marshal_load(array) - raise TypeError, "expected an array" unless array.is_a?(Array) - - case array.size - when 2 # Ruby 1.4/1.6 - # C: ajd = f_sub(a[0], half_days_in_day); vof = 0; vsg = a[1] - ajd = array[0] - Rational(1, 2) - vof = 0 - vsg = array[1] - unless vsg.is_a?(Numeric) - vsg = vsg ? -Float::INFINITY : Float::INFINITY - end - nth, jd, df, sf, of_sec, sg = old_to_new(ajd, vof, vsg) - - when 3 # Ruby 1.8 / 1.9.2 - ajd = array[0] - vof = array[1] - vsg = array[2] - nth, jd, df, sf, of_sec, sg = old_to_new(ajd, vof, vsg) - - when 6 # Current format - nth, jd, df, sf, of_sec, sg = array - - else - raise TypeError, "invalid size" - end - - @nth = nth - @jd = jd - @df = (!df || df == 0) ? nil : df - @sf = (!sf || sf == 0) ? nil : sf - @of = (!of_sec || of_sec == 0) ? nil : of_sec - @sg = sg - - @has_jd = true - @has_civil = false - @year = nil - @month = nil - @day = nil - end + # --------------------------------------------------------------------------- + # Initializer + # --------------------------------------------------------------------------- # call-seq: - # asctime -> string + # Date.new(year = -4712, month = 1, mday = 1, start = Date::ITALY) -> date # - # Equivalent to #strftime with argument '%a %b %e %T %Y' - # (or its {shorthand form}[rdoc-ref:language/strftime_formatting.rdoc@Shorthand+Conversion+Specifiers] - # '%c'): + # Returns a new \Date object constructed from the given arguments: # - # Date.new(2001, 2, 3).asctime # => "Sat Feb 3 00:00:00 2001" + # Date.new(2022).to_s # => "2022-01-01" + # Date.new(2022, 2).to_s # => "2022-02-01" + # Date.new(2022, 2, 4).to_s # => "2022-02-04" # - # See {asctime}[https://linux.die.net/man/3/asctime]. + # Argument +month+ should be in range (1..12) or range (-12..-1); + # when the argument is negative, counts backward from the end of the year: # - def asctime - if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil && @has_jd - y = @year - wday = (@jd + 1) % 7 - ed = @day < 10 ? " #{@day}" : @day.to_s - y_str = if y >= 0 && y <= 9999 - FOUR_DIGIT[y] - elsif y >= 0 - sprintf("%04d", y) - else - sprintf("%05d", y) - end - str = "#{ABBR_DAYNAMES[wday]} #{ABBR_MONTHNAMES[@month]} #{ed} 00:00:00 #{y_str}" - str.force_encoding(Encoding::US_ASCII) - else - strftime('%a %b %e %H:%M:%S %Y') + # Date.new(2022, -11, 4).to_s # => "2022-02-04" + # + # Argument +mday+ should be in range (1..n) or range (-n..-1) + # where +n+ is the number of days in the month; + # when the argument is negative, counts backward from the end of the month. + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + # Related: Date.jd. + def initialize(year = -4712, month = 1, day = 1, start = DEFAULT_SG) + if Integer === year && Integer === month && Integer === day + m = month + m += 13 if m < 0 + if m >= 1 && m <= 12 + dim = if m == 2 + if start == Float::INFINITY + year % 4 == 0 ? 29 : 28 + else + (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? 29 : 28 + end + else + DAYS_IN_MONTH_GREGORIAN[m] + end + d = day + d += dim + 1 if d < 0 + if d >= 1 && d <= dim + gy = m <= 2 ? year - 1 : year + gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[m] + d + if start == Float::INFINITY + @jd = gjd_base - 1524 + elsif start == -Float::INFINITY + a = gy / 100 + @jd = gjd_base - 1524 + 2 - a + a / 4 + else + a = gy / 100 + gjd = gjd_base - 1524 + 2 - a + a / 4 + @jd = gjd >= start ? gjd : gjd_base - 1524 + end + @sg = start + @year = year + @month = m + @day = d + return + end + end + raise Date::Error, "invalid date" end + year = Integer(year) + month = Integer(month) + day = Integer(day) + jd = self.class.__send__(:internal_valid_civil?, year, month, day, start) + raise Date::Error, "invalid date" unless jd + _init_from_jd(jd, start) end - alias_method :ctime, :asctime + + # --------------------------------------------------------------------------- + # Instance methods - basic attributes + # --------------------------------------------------------------------------- # call-seq: - # iso8601 -> string + # year -> integer # - # Equivalent to #strftime with argument '%Y-%m-%d' - # (or its {shorthand form}[rdoc-ref:language/strftime_formatting.rdoc@Shorthand+Conversion+Specifiers] - # '%F'); + # Returns the year: # - # Date.new(2001, 2, 3).iso8601 # => "2001-02-03" - def iso8601 - if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil - y = @year - str = if y >= 0 && y <= 9999 - "#{FOUR_DIGIT[y]}-#{TWO_DIGIT[@month]}-#{TWO_DIGIT[@day]}" - elsif y >= 0 - sprintf("%04d-%02d-%02d", y, @month, @day) - else - sprintf("%05d-%02d-%02d", y, @month, @day) - end - str.force_encoding(Encoding::US_ASCII) - else - strftime('%Y-%m-%d') - end + # Date.new(2001, 2, 3).year # => 2001 + # (Date.new(1, 1, 1) - 1).year # => 0 + # + def year + _civil unless @year + @year end - alias_method :xmlschema, :iso8601 # call-seq: - # rfc3339 -> string + # mon -> integer # - # Equivalent to #strftime with argument '%FT%T%:z'; - # see {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]: + # Returns the month in range (1..12): # - # Date.new(2001, 2, 3).rfc3339 # => "2001-02-03T00:00:00+00:00" - def rfc3339 - if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil - y = @year - str = if y >= 0 && y <= 9999 - "#{FOUR_DIGIT[y]}-#{TWO_DIGIT[@month]}-#{TWO_DIGIT[@day]}T00:00:00+00:00" - elsif y >= 0 - sprintf("%04d-%02d-%02dT00:00:00+00:00", y, @month, @day) - else - sprintf("%05d-%02d-%02dT00:00:00+00:00", y, @month, @day) - end - str.force_encoding(Encoding::US_ASCII) - else - strftime('%Y-%m-%dT%H:%M:%S%:z') - end + # Date.new(2001, 2, 3).mon # => 2 + # + def month + _civil unless @year + @month end + alias mon month # call-seq: - # rfc2822 -> string + # mday -> integer # - # Equivalent to #strftime with argument '%a, %-d %b %Y %T %z'; - # see {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]: + # Returns the day of the month in range (1..31): # - # Date.new(2001, 2, 3).rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000" - def rfc2822 - if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil && @has_jd - y = @year - wday = (@jd + 1) % 7 - y_str = if y >= 0 && y <= 9999 - FOUR_DIGIT[y] - elsif y >= 0 - sprintf("%04d", y) - else - sprintf("%05d", y) - end - str = "#{ABBR_DAYNAMES[wday]}, #{@day} #{ABBR_MONTHNAMES[@month]} #{y_str} 00:00:00 +0000" - str.force_encoding(Encoding::US_ASCII) - else - strftime('%a, %-d %b %Y %T %z') - end + # Date.new(2001, 2, 3).mday # => 3 + # + def day + _civil unless @year + @day end - alias_method :rfc822, :rfc2822 + alias mday day # call-seq: - # httpdate -> string - # - # Equivalent to #strftime with argument '%a, %d %b %Y %T GMT'; - # see {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]: + # d.jd -> integer # - # Date.new(2001, 2, 3).httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT" + # Returns the Julian day number. This is a whole number, which is + # adjusted by the offset as the local time. # - def httpdate - if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil - get_s_jd - y = @year - wday = (@jd + 1) % 7 - y_str = if y >= 0 && y <= 9999 - FOUR_DIGIT[y] - elsif y >= 0 - sprintf("%04d", y) - else - sprintf("%05d", y) - end - str = "#{ABBR_DAYNAMES[wday]}, #{TWO_DIGIT[@day]} #{ABBR_MONTHNAMES[@month]} #{y_str} 00:00:00 GMT" - str.force_encoding(Encoding::US_ASCII) - else - strftime('%a, %d %b %Y %T GMT') - end + # DateTime.new(2001,2,3,4,5,6,'+7').jd #=> 2451944 + # DateTime.new(2001,2,3,4,5,6,'-7').jd #=> 2451944 + def jd + @jd end # call-seq: - # jisx0301 -> string + # start -> float # - # Returns a string representation of the date in +self+ - # in JIS X 0301 format. + # Returns the Julian start date for calendar reform; + # if not an infinity, the returned value is suitable + # for passing to Date#jd: # - # Date.new(2001, 2, 3).jisx0301 # => "H13.02.03" + # d = Date.new(2001, 2, 3, Date::ITALY) + # s = d.start # => 2299161.0 + # Date.jd(s).to_s # => "1582-10-15" # - def jisx0301 - if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil - get_s_jd - jd = @jd - y = @year - mm = TWO_DIGIT[@month] - dd = TWO_DIGIT[@day] - str = if !jd.is_a?(Integer) || jd < 2405160 - # Pre-Meiji or non-integer JD: ISO format - if y >= 0 && y <= 9999 - "#{FOUR_DIGIT[y]}-#{mm}-#{dd}" - elsif y >= 0 - sprintf("%04d-%02d-%02d", y, @month, @day) - else - sprintf("%05d-%02d-%02d", y, @month, @day) - end - elsif jd < 2419614 - ey = y - 1867 - "M#{ey < 100 ? TWO_DIGIT[ey] : sprintf('%02d', ey)}.#{mm}.#{dd}" - elsif jd < 2424875 - ey = y - 1911 - "T#{ey < 100 ? TWO_DIGIT[ey] : sprintf('%02d', ey)}.#{mm}.#{dd}" - elsif jd < 2447535 - ey = y - 1925 - "S#{ey < 100 ? TWO_DIGIT[ey] : sprintf('%02d', ey)}.#{mm}.#{dd}" - elsif jd < 2458605 - ey = y - 1988 - "H#{ey < 100 ? TWO_DIGIT[ey] : sprintf('%02d', ey)}.#{mm}.#{dd}" - else - ey = y - 2018 - "R#{ey < 100 ? TWO_DIGIT[ey] : sprintf('%02d', ey)}.#{mm}.#{dd}" - end - str.force_encoding(Encoding::US_ASCII) - else - jd = m_real_local_jd - y = m_real_year - fmt = jisx0301_date_format(jd, y) - strftime(fmt) - end - end - - def to_s - s = sprintf("%04d-%02d-%02d", year, month, day) - s.force_encoding(Encoding::US_ASCII) + # d = Date.new(2001, 2, 3, Date::ENGLAND) + # s = d.start # => 2361222.0 + # Date.jd(s).to_s # => "1752-09-14" + # + # Date.new(2001, 2, 3, Date::GREGORIAN).start # => -Infinity + # Date.new(2001, 2, 3, Date::JULIAN).start # => Infinity + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + def start + @sg end # call-seq: - # inspect -> string + # d.ajd -> rational # - # Returns a string representation of +self+: + # Returns the astronomical Julian day number. This is a fractional + # number, which is not adjusted by the offset. # - # Date.new(2001, 2, 3).inspect - # # => "#" - def inspect - s = if simple_dat_p? - inspect_raw - else - # In the case of complex, time information is also displayed. - strftime("%Y-%m-%d %H:%M:%S") - end - s.force_encoding(Encoding::US_ASCII) if s.ascii_only? - s - end - - # override - def freeze - # Force lazy computation before freezing so Ractor-shared objects work. - if simple_dat_p? - get_s_jd - get_s_civil - canonicalize_s_jd - else - get_c_jd - get_c_civil - get_c_df - get_c_time - canonicalize_c_jd - end - super - end - - private - - def inspect_raw - # If @sg is infinity - if @sg.infinite? - if @sg < 0 - return "#" - else - return "#" - end - end - - date_str = strftime("%Y-%m-%d") - jd_val = @jd || 0 - sg_val = @sg.infinite? ? (@sg < 0 ? "Inf" : "-Inf") : @sg.to_i - - "#" - end - - def valid_civil?(y, m, d) - return false if m < 1 || m > 12 - - last = last_day_of_month(y, m) - d >= 1 && d <= last - end - - def last_day_of_month(y, m) - last_day_of_month_gregorian(y, m) - end - - def civil_to_jd(y, m, d, sg) - self.class.send(:gregorian_civil_to_jd, y, m, d) - end - - def jd_to_civil(jd, sg) - decode_jd(jd) - self.class.send(:c_jd_to_civil, jd, sg) - end - - def extract_fraction(value) - self.class.send(:extract_fraction, value) - end - - def decode_year(year, style) - self.class.send(:decode_year, year, style) - end - - def valid_gregorian?(y, m, d) - return false if m < 1 || m > 12 - - # Handling negative months and days - m = m + 13 if m < 0 - return false if m < 1 || m > 12 - - last_day = last_day_of_month_gregorian(y, m) - d = last_day + d + 1 if d < 0 - - d >= 1 && d <= last_day - end - - def add_with_fraction(n) - int_part = n.floor - frac_part = n - int_part - - result = add_days(int_part) - - result = result.send(:add_fraction, frac_part) if frac_part.nonzero? - - result - end - - def add_days(days) - new_jd = @jd + days - new_nth = @nth - - while new_jd < 0 - new_nth -= 1 - new_jd += CM_PERIOD - end - - while new_jd >= CM_PERIOD - new_nth += 1 - new_jd -= CM_PERIOD - end - - obj = self.class.allocate - obj.instance_variable_set(:@nth, new_nth) - obj.instance_variable_set(:@jd, new_jd) - obj.instance_variable_set(:@sg, @sg) - obj.instance_variable_set(:@flags, HAVE_JD) - obj.instance_variable_set(:@year, nil) - obj.instance_variable_set(:@month, nil) - obj.instance_variable_set(:@day, nil) - - obj - end - - def add_fraction(frac) - # In the C implementation, Date.jd(2451944.5) becomes 2451945, - # so if there is a decimal point, it will be rounded up by one day. - if frac > 0 - add_days(1) - else - self - end - end - - def last_day_of_month_gregorian(y, m) - self.class.send(:last_day_of_month_gregorian, y, m) - end - - def last_day_of_month_julian(y, m) - self.class.send(:last_day_of_month_julian, y, m) - end - - def valid_civil_date?(year, month, day, sg) - self.class.send(:valid_civil_date?, year, month, day, sg) - end - - protected - - def _init_with_jd(nth, jd, df, sf, of, start) - @nth = nth - @jd = jd - @sg = start - @df = df - @sf = sf - @of = of - @year = nil - @month = nil - @day = nil - @has_jd = true - @has_civil = false - end - - def _init_simple_with_jd(jd, start) - @nth = 0 - @jd = jd - @sg = start - @has_jd = true - end - - def _init_simple_with_civil(year, month, day, start) - @nth = 0 - @sg = start - @year = year - @month = month - @day = day - @has_civil = true - end - - private - - def canonicalize_jd(nth, jd) - if jd < 0 - nth = nth - 1 - jd += CM_PERIOD - end - if jd >= CM_PERIOD - nth = nth + 1 - jd -= CM_PERIOD - end - - [nth, jd] - end - - # If any of @df, @sf, or @of is not nil, it is considered complex. - def simple_dat_p? - @df.nil? && @sf.nil? && @of.nil? - end - - def complex_dat_p? - !simple_dat_p? - end - - def m_gregorian_p? - !m_julian_p? - end - - def m_julian_p? - # Divide the processing into simple and complex. - if simple_dat_p? - get_s_jd - jd = @jd - sg = s_virtual_sg - else - get_c_jd - jd = @jd - sg = c_virtual_sg - end - - return sg == JULIAN if sg.infinite? - - jd < sg - end - - def m_year - simple_dat_p? ? get_s_civil : get_c_civil - - @year + # DateTime.new(2001,2,3,4,5,6,'+7').ajd #=> (11769328217/4800) + # DateTime.new(2001,2,2,14,5,6,'-7').ajd #=> (11769328217/4800) + def ajd + r = Rational(@jd * 2 - 1, 2) + @df ? r + @df : r end - def m_virtual_sg - simple_dat_p? ? s_virtual_sg : c_virtual_sg + # call-seq: + # d.amjd -> rational + # + # Returns the astronomical modified Julian day number. This is + # a fractional number, which is not adjusted by the offset. + # + # DateTime.new(2001,2,3,4,5,6,'+7').amjd #=> (249325817/4800) + # DateTime.new(2001,2,2,14,5,6,'-7').amjd #=> (249325817/4800) + def amjd + ajd - Rational(4800001, 2) end - def get_s_jd - # For simple data, if JD has not yet been calculated. - return if @has_jd - - return unless simple_dat_p? - - return unless @has_civil - - # Calculate JD from civil. - jd, _ = self.class.send(:c_civil_to_jd, @year, @month, @day, s_virtual_sg) - @jd = jd - @has_jd = true + # call-seq: + # d.mjd -> integer + # + # Returns the modified Julian day number. This is a whole number, + # which is adjusted by the offset as the local time. + # + # DateTime.new(2001,2,3,4,5,6,'+7').mjd #=> 51943 + # DateTime.new(2001,2,3,4,5,6,'-7').mjd #=> 51943 + def mjd + @jd - 2400001 end - def get_s_civil - # For simple data, if civil has not yet been calculated. - return if @has_civil - - # If not simple or there is no JD, do nothing. - return unless simple_dat_p? - return unless @has_jd - - # Calculate civil from JD. - y, m, d = self.class.send(:c_jd_to_civil, @jd, s_virtual_sg) - @year = y - @month = m - @day = d - @has_civil = true + # call-seq: + # ld -> integer + # + # Returns the + # {Lilian day number}[https://en.wikipedia.org/wiki/Lilian_date], + # which is the number of days since the beginning of the Gregorian + # calendar, October 15, 1582. + # + # Date.new(2001, 2, 3).ld # => 152784 + # + def ld + @jd - 2299160 end - def get_c_jd - # For complex data, if JD has not yet been calculated. - return if @has_jd - - # Make sure you have civil data. - raise "No civil data" unless @has_civil - - # Calculate JD from civil. - jd, _ = self.class.send(:c_civil_to_jd, @year, @month, @day, c_virtual_sg) - - # Consider time data. - get_c_time - - # Convert from local to UTC. - @jd = jd_local_to_utc(jd, time_to_df(@hour || 0, @min || 0, @sec || 0), @of || 0) - @has_jd = true + # call-seq: + # yday -> integer + # + # Returns the day of the year, in range (1..366): + # + # Date.new(2001, 2, 3).yday # => 34 + # + def yday + return @yday if @yday + _civil unless @year + # inline civil_to_jd(@year, 1, 1, @sg): month=1 (<= 2 so y-=1), day=1 + yy = @year - 1 + gjd_base = (1461 * (yy + 4716)) / 4 + 429 # GJD_MONTH_OFFSET[1](=428) + 1 + a = yy / 100 + gjd = gjd_base - 1524 + 2 - a + a / 4 + jd_jan1 = gjd >= @sg ? gjd : gjd_base - 1524 + val = @jd - jd_jan1 + 1 + @yday = val unless frozen? + val end - def get_c_civil - # For complex data, if civil has not yet been calculated. - return if @has_civil - - # Make sure you have a JD. - raise "No JD data" unless @has_jd - - get_c_df - - # Convert UTC to local. - jd = jd_utc_to_local(@jd, @df || 0, @of || 0) - - # Calculate civil from JD. - y, m, d = self.class.send(:c_jd_to_civil, jd, c_virtual_sg) - @year = y - @month = m - @day = d - @has_civil = true + # call-seq: + # wday -> integer + # + # Returns the day of week in range (0..6); Sunday is 0: + # + # Date.new(2001, 2, 3).wday # => 6 + # + def wday + (@jd + 1) % 7 end - def get_c_df - # If df (day fraction) has not yet been calculated. - return if @df - - # Check that time data is available. - raise "No time data" if @hour.nil? && @min.nil? && @sec.nil? - - # Convert time to df - @df = df_local_to_utc(time_to_df(@hour, @min, @sec), @of || 0) + # call-seq: + # cwday -> integer + # + # Returns the commercial-date weekday index for +self+ + # (see Date.commercial); + # 1 is Monday: + # + # Date.new(2001, 2, 3).cwday # => 6 + # + def cwday + w = wday + w == 0 ? 7 : w end - def get_c_time - # If the time data has not yet been calculated. - return unless @hour.nil? - - # Make sure df exists. - raise "No df data" if @df.nil? - - # Convert df to time. - r = df_utc_to_local(@df, @of || 0) - - @hour, @min, @sec = df_to_time(r) + # call-seq: + # cweek -> integer + # + # Returns commercial-date week index for +self+ + # (see Date.commercial): + # + # Date.new(2001, 2, 3).cweek # => 5 + # + def cweek + @cweek || _compute_commercial[1] end - # For SimpleDateData (effectively a common implementation) - def s_virtual_sg - return @sg if @sg.infinite? - return @sg if self.class.send(:f_zero_p?, @nth) - - @nth < 0 ? JULIAN : GREGORIAN + # call-seq: + # cwyear -> integer + # + # Returns commercial-date year for +self+ + # (see Date.commercial): + # + # Date.new(2001, 2, 3).cwyear # => 2001 + # Date.new(2000, 1, 1).cwyear # => 1999 + # + def cwyear + @cwyear || _compute_commercial[0] end - # For ComplexDateData (effectively a common implementation) - def c_virtual_sg - return @sg if @sg.infinite? - return @sg if self.class.send(:f_zero_p?, @nth) - - @nth < 0 ? JULIAN : GREGORIAN + # call-seq: + # day_fraction -> rational + # + # Returns the fractional part of the day in range (Rational(0, 1)...Rational(1, 1)): + # + # DateTime.new(2001,2,3,12).day_fraction # => (1/2) + # + def day_fraction + @df || Rational(0) end - def jd_local_to_utc(jd, df, of) - df -= of - if df < 0 - jd -= 1 - elsif df >= DAY_IN_SECONDS - jd += 1 + # call-seq: + # leap? -> true or false + # + # Returns +true+ if the year is a leap year, +false+ otherwise: + # + # Date.new(2000).leap? # => true + # Date.new(2001).leap? # => false + # + def leap? + _civil unless @year + if @jd < @sg # julian? + @year % 4 == 0 + else + (@year % 4 == 0 && @year % 100 != 0) || @year % 400 == 0 end - - jd end - def jd_utc_to_local(jd, df, of) - df += of - if df < 0 - jd -= 1 - elsif df >= DAY_IN_SECONDS - jd += 1 - end - - jd + # call-seq: + # gregorian? -> true or false + # + # Returns +true+ if the date is on or after + # the date of calendar reform, +false+ otherwise: + # + # Date.new(1582, 10, 15).gregorian? # => true + # (Date.new(1582, 10, 15) - 1).gregorian? # => false + # + def gregorian? + jd >= @sg end - def df_local_to_utc(df, of) - df -= of - if df < 0 - df += DAY_IN_SECONDS - elsif df >= DAY_IN_SECONDS - df -= DAY_IN_SECONDS - end - - df + # call-seq: + # d.julian? -> true or false + # + # Returns +true+ if the date is before the date of calendar reform, + # +false+ otherwise: + # + # (Date.new(1582, 10, 15) - 1).julian? # => true + # Date.new(1582, 10, 15).julian? # => false + # + def julian? + !gregorian? end - def df_utc_to_local(df, of) - df += of - if df < 0 - df += DAY_IN_SECONDS - elsif df >= DAY_IN_SECONDS - df -= DAY_IN_SECONDS - end - - df + # call-seq: + # new_start(start = Date::ITALY]) -> new_date + # + # Returns a copy of +self+ with the given +start+ value: + # + # d0 = Date.new(2000, 2, 3) + # d0.julian? # => false + # d1 = d0.new_start(Date::JULIAN) + # d1.julian? # => true + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # + def new_start(start = DEFAULT_SG) + obj = self.class.allocate + obj.instance_variable_set(:@jd, @jd) + obj.instance_variable_set(:@sg, start) + obj end - def time_to_df(h, min, s) - h * HOUR_IN_SECONDS + min * MINUTE_IN_SECONDS + s + # call-seq: + # gregorian -> new_date + # + # Equivalent to Date#new_start with argument Date::GREGORIAN. + def gregorian + new_start(GREGORIAN) end - def df_to_time(df) - h = df / HOUR_IN_SECONDS - df %= HOUR_IN_SECONDS - min = df / MINUTE_IN_SECONDS - s = df % MINUTE_IN_SECONDS - - [h, min, s] + # call-seq: + # italy -> new_date + # + # Equivalent to Date#new_start with argument Date::ITALY. + # + def italy + new_start(ITALY) end - def minus_dd(other) - n = m_nth - other.send(:m_nth) - d = m_jd - other.send(:m_jd) - df = m_df - other.send(:m_df) - sf = m_sf - other.send(:m_sf) - - n, d = canonicalize_jd(n, d) - - # Canonicalize df - if df < 0 - d -= 1 - df += DAY_IN_SECONDS - elsif df >= DAY_IN_SECONDS - d += 1 - df -= DAY_IN_SECONDS - end - - # Canonicalize sf - if sf < 0 - df -= 1 - sf += SECOND_IN_NANOSECONDS - elsif sf >= SECOND_IN_NANOSECONDS - df += 1 - sf -= SECOND_IN_NANOSECONDS - end - - r = n.zero? ? 0 : n * CM_PERIOD - r = r + Rational(d, 1) if d.nonzero? - r = r + isec_to_day(df) if df.nonzero? - r = r + ns_to_day(sf) if sf.nonzero? - - r.is_a?(Rational) ? r : Rational(r, 1) + # call-seq: + # england -> new_date + # + # Equivalent to Date#new_start with argument Date::ENGLAND. + def england + new_start(ENGLAND) end - def m_jd - simple_dat_p? ? get_s_jd : get_c_jd - - @jd + # call-seq: + # julian -> new_date + # + # Equivalent to Date#new_start with argument Date::JULIAN. + def julian + new_start(JULIAN) end - def m_df - if simple_dat_p? - 0 - else - get_c_df - @df || 0 - end + # call-seq: + # sunday? -> true or false + # + # Returns +true+ if +self+ is a Sunday, +false+ otherwise. + def sunday? + wday == 0 end - - def m_sf - simple_dat_p? ? 0 : @sf || 0 + # call-seq: + # monday? -> true or false + # + # Returns +true+ if +self+ is a Monday, +false+ otherwise. + def monday? + wday == 1 end - - def m_of - if simple_dat_p? - 0 - else - get_c_jd - @of || 0 - end + # call-seq: + # tuesday? -> true or false + # + # Returns +true+ if +self+ is a Tuesday, +false+ otherwise. + def tuesday? + wday == 2 end - - def m_real_year - return @year if @nth == 0 && @has_civil - - nth = @nth - year = m_year - - return year if self.class.send(:f_zero_p?, nth) - - encode_year(nth, year, gregorian? ? -1 : 1) + # call-seq: + # wednesday? -> true or false + # + # Returns +true+ if +self+ is a Wednesday, +false+ otherwise. + def wednesday? + wday == 3 end - - def m_mon - return @month if @has_civil - - simple_dat_p? ? get_s_civil : get_c_civil - @month + # call-seq: + # thursday? -> true or false + # + # Returns +true+ if +self+ is a Thursday, +false+ otherwise. + def thursday? + wday == 4 end - - def m_mday - return @day if @has_civil - - simple_dat_p? ? get_s_civil : get_c_civil - @day + # call-seq: + # friday? -> true or false + # + # Returns +true+ if +self+ is a Friday, +false+ otherwise. + def friday? + wday == 5 end - - def m_sg - get_c_jd unless simple_dat_p? - - @sg + # call-seq: + # saturday? -> true or false + # + # Returns +true+ if +self+ is a Saturday, +false+ otherwise. + def saturday? + wday == 6 end - def encode_year(nth, y, style) - period = (style < 0) ? CM_PERIOD_GCY : CM_PERIOD_JCY - - self.class.send(:f_zero_p?, nth) ? y : period * nth + y + # :nodoc: + def nth_kday?(n, k) + return false if k != wday + jd_ref = self.class.__send__(:nth_kday_to_jd, year, month, n, k, @sg) + jd_ref == @jd end - def m_real_local_jd - nth = m_nth - jd = m_local_jd + # --------------------------------------------------------------------------- + # Comparison + # --------------------------------------------------------------------------- - self.class.send(:encode_jd, nth, jd) - end - - def m_local_jd - if simple_dat_p? - get_s_jd - @jd + # call-seq: + # self <=> other -> -1, 0, 1 or nil + # + # Compares +self+ and +other+, returning: + # + # - -1 if +other+ is larger. + # - 0 if the two are equal. + # - 1 if +other+ is smaller. + # - +nil+ if the two are incomparable. + # + # Argument +other+ may be: + # + # - Another \Date object: + # + # d = Date.new(2022, 7, 27) # => # + # prev_date = d.prev_day # => # + # next_date = d.next_day # => # + # d <=> next_date # => -1 + # d <=> d # => 0 + # d <=> prev_date # => 1 + # + # - A DateTime object: + # + # d <=> DateTime.new(2022, 7, 26) # => 1 + # d <=> DateTime.new(2022, 7, 27) # => 0 + # d <=> DateTime.new(2022, 7, 28) # => -1 + # + # - A numeric (compares self.ajd to +other+): + # + # d <=> 2459788 # => -1 + # d <=> 2459787 # => 1 + # d <=> 2459786 # => 1 + # d <=> d.ajd # => 0 + # + # - Any other object: + # + # d <=> Object.new # => nil + # + def <=>(other) + case other + when Date + d = @jd <=> other.jd + d != 0 ? d : day_fraction <=> other.day_fraction + when Numeric + ajd <=> other else - get_c_jd - get_c_df - local_jd + nil end end - def local_jd - jd = @jd - df = @df || 0 - of = @of || 0 - - df += of - if df < 0 - jd -= 1 - elsif df >= DAY_IN_SECONDS - jd += 1 + def <(other) + case other + when Date + d = @jd <=> other.jd + d != 0 ? d < 0 : day_fraction < other.day_fraction + when Numeric + r = ajd <=> other + raise ArgumentError, "comparison of #{self.class} with #{other.class} failed" if r.nil? + r < 0 + else + raise ArgumentError, "comparison of #{self.class} with #{other.class} failed" end - - jd - end - - def m_nth - # For complex, get civil data and then return nth. - get_c_civil unless simple_dat_p? - - @nth end - def equal_gen(other) - if other.is_a?(Numeric) - m_real_local_jd == other - elsif other.is_a?(Date) - m_real_local_jd == other.send(:m_real_local_jd) + def >(other) + case other + when Date + d = @jd <=> other.jd + d != 0 ? d > 0 : day_fraction > other.day_fraction + when Numeric + r = ajd <=> other + raise ArgumentError, "comparison of #{self.class} with #{other.class} failed" if r.nil? + r > 0 else - begin - coerced = other.coerce(self) - coerced[0] == coerced[1] - rescue - false - end + raise ArgumentError, "comparison of #{self.class} with #{other.class} failed" end end - def m_canonicalize_jd - if simple_dat_p? - get_s_jd - canonicalize_s_jd + def ==(other) + case other + when Date + @jd == other.jd && day_fraction == other.day_fraction + when Numeric + ajd == other else - get_c_jd - canonicalize_c_jd + false end end - # Simple - def canonicalize_s_jd - return if frozen? - - j = @jd - - @nth, @jd = canonicalize_jd(@nth, @jd) - - # Invalidate civil data if JD changes. - @has_civil = false if @jd != j + def eql?(other) + other.is_a?(Date) && @jd == other.jd && day_fraction == other.day_fraction end - # Complex - def canonicalize_c_jd - return if frozen? - - j = @jd - - @nth, @jd = canonicalize_jd(@nth, @jd) - - # Invalidate civil data if JD changes. - @has_civil = false if @jd != j + def hash + [@jd, @sg].hash end - def f_jd(other) - # Get JD from another Date object. - other.send(:m_real_local_jd) + # call-seq: + # self === other -> true, false, or nil. + # + # Returns +true+ if +self+ and +other+ represent the same date, + # +false+ if not, +nil+ if the two are not comparable. + # + # Argument +other+ may be: + # + # - Another \Date object: + # + # d = Date.new(2022, 7, 27) # => # + # prev_date = d.prev_day # => # + # next_date = d.next_day # => # + # d === prev_date # => false + # d === d # => true + # d === next_date # => false + # + # - A DateTime object: + # + # d === DateTime.new(2022, 7, 26) # => false + # d === DateTime.new(2022, 7, 27) # => true + # d === DateTime.new(2022, 7, 28) # => false + # + # - A numeric (compares self.jd to +other+): + # + # d === 2459788 # => true + # d === 2459787 # => false + # d === 2459786 # => false + # d === d.jd # => true + # + # - An object not comparable: + # + # d === Object.new # => nil + # + def ===(other) + case other + when Numeric + jd == other.to_i + when Date + jd == other.jd + else + nil + end end - def dup_obj_with_new_start(sg) - if @df.nil? && @sf.nil? && @of.nil? - # Fast path for simple Date (no time/offset components). - # Absolute hot path: nth==0 (common Gregorian date) with JD already cached. - if @nth == 0 && @has_jd - new_obj = self.class.send(:allocate) - new_obj.instance_variable_set(:@nth, 0) - new_obj.instance_variable_set(:@jd, @jd) - new_obj.instance_variable_set(:@sg, sg) - new_obj.instance_variable_set(:@df, nil) - new_obj.instance_variable_set(:@sf, nil) - new_obj.instance_variable_set(:@of, nil) - new_obj.instance_variable_set(:@year, nil) - new_obj.instance_variable_set(:@month, nil) - new_obj.instance_variable_set(:@day, nil) - new_obj.instance_variable_set(:@has_jd, true) - new_obj.instance_variable_set(:@has_civil, false) - return new_obj - end - # General simple path: inline get_s_jd and canon(@nth). - unless @has_jd - if @has_civil - jd, _ = self.class.send(:c_civil_to_jd, @year, @month, @day, s_virtual_sg) - @jd = jd - @has_jd = true - end + # --------------------------------------------------------------------------- + # Arithmetic + # --------------------------------------------------------------------------- + + # call-seq: + # d + other -> date + # + # Returns a date object pointing +other+ days after self. The other + # should be a numeric value. If the other is a fractional number, + # assumes its precision is at most nanosecond. + # + # Date.new(2001,2,3) + 1 #=> # + # DateTime.new(2001,2,3) + Rational(1,2) + # #=> # + # DateTime.new(2001,2,3) + Rational(-1,2) + # #=> # + # DateTime.jd(0,12) + DateTime.new(2001,2,3).ajd + # #=> # + def +(other) + case other + when Integer + if instance_of?(Date) + obj = Date.allocate + obj.instance_variable_set(:@jd, @jd + other) + obj.instance_variable_set(:@sg, @sg) + obj + else + self.class.__send__(:_new_from_jd, @jd + other, @sg, @df) end - nth = @nth - nth = nth.numerator if nth.is_a?(Rational) && nth.denominator == 1 - new_obj = self.class.send(:allocate) - new_obj.instance_variable_set(:@nth, nth) - new_obj.instance_variable_set(:@jd, @jd) - new_obj.instance_variable_set(:@sg, sg) - new_obj.instance_variable_set(:@df, nil) - new_obj.instance_variable_set(:@sf, nil) - new_obj.instance_variable_set(:@of, nil) - new_obj.instance_variable_set(:@year, nil) - new_obj.instance_variable_set(:@month, nil) - new_obj.instance_variable_set(:@day, nil) - new_obj.instance_variable_set(:@has_jd, @has_jd) - new_obj.instance_variable_set(:@has_civil, false) - new_obj + when Numeric + r = other.to_r + raise TypeError, "#{other.class} can't be coerced into Integer" unless r.is_a?(Rational) + total = r + (@df || 0) + days = total.floor + frac = total - days + self.class.__send__(:_new_from_jd, @jd + days, @sg, frac == 0 ? nil : frac) else - dup = dup_obj - dup.send(:set_sg, sg) - dup + raise TypeError, "expected numeric" end end - def dup_obj - if simple_dat_p? - # Simple data replication: allocate directly, avoid d_lite_s_alloc_simple overhead - new_obj = self.class.send(:allocate) - - new_obj.instance_variable_set(:@nth, canon(@nth)) - new_obj.instance_variable_set(:@jd, @jd) - new_obj.instance_variable_set(:@sg, @sg) - new_obj.instance_variable_set(:@df, nil) - new_obj.instance_variable_set(:@sf, nil) - new_obj.instance_variable_set(:@of, nil) - new_obj.instance_variable_set(:@year, @year) - new_obj.instance_variable_set(:@month, @month) - new_obj.instance_variable_set(:@day, @day) - new_obj.instance_variable_set(:@has_jd, @has_jd) - new_obj.instance_variable_set(:@has_civil, @has_civil) + # call-seq: + # d - other -> date or rational + # + # If the other is a date object, returns a Rational + # whose value is the difference between the two dates in days. + # If the other is a numeric value, returns a date object + # pointing +other+ days before self. + # If the other is a fractional number, + # assumes its precision is at most nanosecond. + # + # Date.new(2001,2,3) - 1 #=> # + # DateTime.new(2001,2,3) - Rational(1,2) + # #=> # + # Date.new(2001,2,3) - Date.new(2001) + # #=> (33/1) + # DateTime.new(2001,2,3) - DateTime.new(2001,2,2,12) + # #=> (1/2) + def -(other) + case other + when Date + Rational(@jd - other.jd) + (@df || 0) - other.day_fraction + when Integer + if instance_of?(Date) + obj = Date.allocate + obj.instance_variable_set(:@jd, @jd - other) + obj.instance_variable_set(:@sg, @sg) + obj + else + self.class.__send__(:_new_from_jd, @jd - other, @sg, @df) + end + when Numeric + r = other.to_r + raise TypeError, "#{other.class} can't be coerced into Integer" unless r.is_a?(Rational) + total = (@df || 0) - r + days = total.floor + frac = total - days + self.class.__send__(:_new_from_jd, @jd + days, @sg, frac == 0 ? nil : frac) + else + raise TypeError, "expected numeric" + end + end - new_obj + # call-seq: + # d >> n -> new_date + # + # Returns a new \Date object representing the date + # +n+ months later; +n+ should be a numeric: + # + # (Date.new(2001, 2, 3) >> 1).to_s # => "2001-03-03" + # (Date.new(2001, 2, 3) >> -2).to_s # => "2000-12-03" + # + # When the same day does not exist for the new month, + # the last day of that month is used instead: + # + # (Date.new(2001, 1, 31) >> 1).to_s # => "2001-02-28" + # (Date.new(2001, 1, 31) >> -4).to_s # => "2000-09-30" + # + # This results in the following, possibly unexpected, behaviors: + # + # d0 = Date.new(2001, 1, 31) + # d1 = d0 >> 1 # => # + # d2 = d1 >> 1 # => # + # + # d0 = Date.new(2001, 1, 31) + # d1 = d0 >> 1 # => # + # d2 = d1 >> -1 # => # + # + def >>(n) + _civil unless @year + m2 = @month + n.to_i + y2 = @year + (m2 - 1).div(12) + m2 = (m2 - 1) % 12 + 1 + # inline days_in_month + if m2 == 2 + if @sg == Float::INFINITY + dim = y2 % 4 == 0 ? 29 : 28 + else + dim = ((y2 % 4 == 0 && y2 % 100 != 0) || y2 % 400 == 0) ? 29 : 28 + end else - # Complex data replication - new_obj = self.class.send(:d_lite_s_alloc_complex) + dim = DAYS_IN_MONTH_GREGORIAN[m2] + end + d2 = @day < dim ? @day : dim + # inline civil_to_jd(y2, m2, d2, @sg) + offset = GJD_MONTH_OFFSET[m2] + yy = m2 <= 2 ? y2 - 1 : y2 + gjd_base = (1461 * (yy + 4716)) / 4 + offset + d2 + a = yy / 100 + gjd = gjd_base - 1524 + 2 - a + a / 4 + jd2 = gjd >= @sg ? gjd : gjd_base - 1524 + # inline _new_from_jd + obj = self.class.allocate + obj.instance_variable_set(:@jd, jd2) + obj.instance_variable_set(:@sg, @sg) + obj + end - new_obj.instance_variable_set(:@nth, canon(@nth)) - new_obj.instance_variable_set(:@jd, @jd) - new_obj.instance_variable_set(:@sg, @sg) - new_obj.instance_variable_set(:@year, @year) - new_obj.instance_variable_set(:@month, @month) - new_obj.instance_variable_set(:@day, @day) - new_obj.instance_variable_set(:@hour, @hour) - new_obj.instance_variable_set(:@min, @min) - new_obj.instance_variable_set(:@sec, @sec) - new_obj.instance_variable_set(:@df, @df) - new_obj.instance_variable_set(:@sf, canon(@sf)) - new_obj.instance_variable_set(:@of, @of) - new_obj.instance_variable_set(:@has_jd, @has_jd) - new_obj.instance_variable_set(:@has_civil, @has_civil) + # call-seq: + # d << n -> date + # + # Returns a new \Date object representing the date + # +n+ months earlier; +n+ should be a numeric: + # + # (Date.new(2001, 2, 3) << 1).to_s # => "2001-01-03" + # (Date.new(2001, 2, 3) << -2).to_s # => "2001-04-03" + # + # When the same day does not exist for the new month, + # the last day of that month is used instead: + # + # (Date.new(2001, 3, 31) << 1).to_s # => "2001-02-28" + # (Date.new(2001, 3, 31) << -6).to_s # => "2001-09-30" + # + # This results in the following, possibly unexpected, behaviors: + # + # d0 = Date.new(2001, 3, 31) + # d0 << 2 # => # + # d0 << 1 << 1 # => # + # + # d0 = Date.new(2001, 3, 31) + # d1 = d0 << 1 # => # + # d2 = d1 << -1 # => # + # + def <<(n) + self >> -n + end - new_obj - end + # call-seq: + # next_day(n = 1) -> new_date + # + # Equivalent to Date#+ with argument +n+. + def next_day(n = 1) + self + n end - def set_sg(sg) - if simple_dat_p? - get_s_jd if @has_jd || @has_civil - else - get_c_jd - get_c_df - end + # call-seq: + # prev_day(n = 1) -> new_date + # + # Equivalent to Date#- with argument +n+. + def prev_day(n = 1) + self - n + end - clear_civil + # call-seq: + # d.next -> new_date + # + # Returns a new \Date object representing the following day: + # + # d = Date.new(2001, 2, 3) + # d.to_s # => "2001-02-03" + # d.next.to_s # => "2001-02-04" + # + def next + self + 1 + end + alias_method :succ, :next - @sg = sg + # call-seq: + # next_year(n = 1) -> new_date + # + # Equivalent to #>> with argument n * 12. + def next_year(n = 1) + self >> n * 12 end - def clear_civil - @has_civil = false - @year = nil - @month = nil - @day = nil + # call-seq: + # prev_year(n = 1) -> new_date + # + # Equivalent to #<< with argument n * 12. + def prev_year(n = 1) + self << n * 12 end - # If the argument is Rational and the denominator is 1, return the numerator. - def canon(x) - x.is_a?(Rational) && x.denominator == 1 ? x.numerator : x + # call-seq: + # next_month(n = 1) -> new_date + # + # Equivalent to #>> with argument +n+. + def next_month(n = 1) + self >> n end - def val2sg(vsg) - # Convert to Number. - sg = vsg.to_f + # call-seq: + # prev_month(n = 1) -> new_date + # + # Equivalent to #<< with argument +n+. + def prev_month(n = 1) + self << n + end - # Check for a valid start. - unless c_valid_start_p?(sg) - warn "invalid start is ignored" - sg = DEFAULT_SG + # call-seq: + # step(limit, step = 1){|date| ... } -> self + # + # Calls the block with specified dates; + # returns +self+. + # + # - The first +date+ is +self+. + # - Each successive +date+ is date + step, + # where +step+ is the numeric step size in days. + # - The last date is the last one that is before or equal to +limit+, + # which should be a \Date object. + # + # Example: + # + # limit = Date.new(2001, 12, 31) + # Date.new(2001).step(limit){|date| p date.to_s if date.mday == 31 } + # + # Output: + # + # "2001-01-31" + # "2001-03-31" + # "2001-05-31" + # "2001-07-31" + # "2001-08-31" + # "2001-10-31" + # "2001-12-31" + # + # Returns an Enumerator if no block is given. + def step(limit, step = 1) + return to_enum(:step, limit, step) unless block_given? + if Integer === step && instance_of?(Date) && limit.instance_of?(Date) + raise ArgumentError, "step can't be 0" if step == 0 + limit_jd = limit.jd + sg = @sg + if step > 0 + jd = @jd + while jd <= limit_jd + obj = Date.allocate + obj.instance_variable_set(:@jd, jd) + obj.instance_variable_set(:@sg, sg) + yield obj + jd += step + end + else + jd = @jd + while jd >= limit_jd + obj = Date.allocate + obj.instance_variable_set(:@jd, jd) + obj.instance_variable_set(:@sg, sg) + yield obj + jd += step + end + end + return self + end + d = self + cmp = step <=> 0 + raise ArgumentError, "comparison of #{step.class} with 0 failed" if cmp.nil? + if cmp > 0 + while d <= limit + yield d + d = d + step + end + elsif cmp < 0 + while d >= limit + yield d + d = d + step + end + else + raise ArgumentError, "step can't be 0" end - - sg - end - - def c_valid_start_p?(sg) - # Invalid for NaN. - return false if sg.respond_to?(:nan?) && sg.nan? - - # Valid for Infinity. - return true if sg.respond_to?(:infinite?) && sg.infinite? - - # If it is a finite value, check if it is within the range - # from REFORM_BEGIN_JD to REFORM_END_JD - return false if sg < REFORM_BEGIN_JD || sg > REFORM_END_JD - - true - end - - def m_wday - return (@jd + 1) % 7 if @has_jd && @of.nil? - - c_jd_to_wday(m_local_jd) - end - - def c_jd_to_wday(jd) - (jd + 1) % 7 + self end - def m_yday - if @has_civil && @of.nil? + # call-seq: + # upto(max){|date| ... } -> self + # + # Equivalent to #step with arguments +max+ and +1+. + def upto(max, &block) + return to_enum(:upto, max) unless block_given? + if instance_of?(Date) && max.instance_of?(Date) + jd = @jd + max_jd = max.jd sg = @sg - if (sg.is_a?(Float) && sg.infinite? && sg < 0) || - (sg.is_a?(Integer) && @has_jd && (@jd - sg) > 366) - leap = self.class.send(:c_gregorian_leap_p?, @year) - return YEARTAB[leap ? 1 : 0][@month] + @day + while jd <= max_jd + obj = Date.allocate + obj.instance_variable_set(:@jd, jd) + obj.instance_variable_set(:@sg, sg) + yield obj + jd += 1 end + return self end - - jd = m_local_jd - sg = m_virtual_sg - - # proleptic gregorian or if more than 366 days have passed since the calendar change - return c_gregorian_to_yday(m_year, m_mon, m_mday) if m_proleptic_gregorian_p? || (jd - sg) > 366 - - # proleptic Julian - return c_julian_to_yday(m_year, m_mon, m_mday) if m_proleptic_julian_p? - - # Otherwise, convert from JD to ordinal. - _, rd = self.class.send(:c_jd_to_ordinal, jd, sg) - - rd + step(max, 1, &block) end - def m_proleptic_gregorian_p? - sg = @sg - - sg.infinite? && sg < 0 + # call-seq: + # downto(min){|date| ... } -> self + # + # Equivalent to #step with arguments +min+ and -1. + def downto(min, &block) + return to_enum(:downto, min) unless block_given? + if instance_of?(Date) && min.instance_of?(Date) + jd = @jd + min_jd = min.jd + sg = @sg + while jd >= min_jd + obj = Date.allocate + obj.instance_variable_set(:@jd, jd) + obj.instance_variable_set(:@sg, sg) + yield obj + jd -= 1 + end + return self + end + step(min, -1, &block) end - def m_proleptic_julian_p? - sg = @sg + # --------------------------------------------------------------------------- + # Calendar conversion + # --------------------------------------------------------------------------- - sg.infinite? && sg > 0 + # call-seq: + # to_date -> self + # + # Returns +self+. + def to_date + self end - def c_gregorian_to_yday(year, month, day) - leap = self.class.send(:c_gregorian_leap_p?, year) - - YEARTAB[leap ? 1 : 0][month] + day + # call-seq: + # d.to_datetime -> datetime + # + # Returns a DateTime whose value is the same as +self+: + # + # Date.new(2001, 2, 3).to_datetime # => # + # + def to_datetime + DateTime.new(year, month, day, 0, 0, 0, 0, @sg) end - def c_julian_to_yday(year, month, day) - leap = self.class.send(:c_julian_leap_p?, year) + # call-seq: + # to_time -> time + # + # Returns a new Time object with the same value as +self+; + # if +self+ is a Julian date, derives its Gregorian date + # for conversion to the \Time object: + # + # Date.new(2001, 2, 3).to_time # => 2001-02-03 00:00:00 -0600 + # Date.new(2001, 2, 3, Date::JULIAN).to_time # => 2001-02-16 00:00:00 -0600 + # + def to_time + # Use Gregorian date for Time (inline jd_to_gregorian) + a = @jd + 32044 + b = (4 * a + 3) / 146097 + c = a - (146097 * b) / 4 + dd = (4 * c + 3) / 1461 + e = c - (1461 * dd) / 4 + m = (5 * e + 2) / 153 + day = e - (153 * m + 2) / 5 + 1 + month = m + 3 - 12 * (m / 10) + year = 100 * b + dd - 4800 + m / 10 + Time.local(year, month, day) + end + + # --------------------------------------------------------------------------- + # Serialization + # --------------------------------------------------------------------------- - YEARTAB[leap ? 1 : 0][month] + day + # :nodoc: + def initialize_copy(other) + @jd = other.instance_variable_get(:@jd) + @sg = other.instance_variable_get(:@sg) + @df = other.instance_variable_get(:@df) + @year = other.instance_variable_get(:@year) + @month = other.instance_variable_get(:@month) + @day = other.instance_variable_get(:@day) end - def d_trunc_with_frac(value) - if value.is_a?(Integer) - [value, 0] - elsif value.is_a?(Float) - trunc = value.truncate - frac = value - trunc - - [trunc, frac] - elsif value.is_a?(Rational) - trunc = value.truncate - frac = value - trunc - - [trunc, frac] + # :nodoc: + def marshal_dump + # 6-element format: [nth, jd, df, sf, of, sg] + # df = seconds into day (Integer), sf = sub-second fraction (Rational) + if @df + total_sec = @df * 86400 + df_int = total_sec.floor + sf = total_sec - df_int + [0, @jd, df_int, sf, 0, @sg] else - [value.to_i, 0] + [0, @jd, 0, 0, 0, @sg] end end - def m_real_jd - # C: m_real_jd uses m_jd (raw/UTC JD), NOT m_local_jd - nth = m_nth - if simple_dat_p? - get_s_jd + # :nodoc: + def marshal_load(array) + case array.length + when 2 + # Format 1.4/1.6: [jd_like, sg_or_bool] + jd_like, sg_or_bool = array + sg = sg_or_bool == true ? GREGORIAN : (sg_or_bool == false ? JULIAN : sg_or_bool.to_f) + _init_from_jd(jd_like.to_i, sg) + when 3 + # Format 1.8: [ajd, of, sg] + ajd, _of, sg = array + raw_jd = ajd + Rational(1, 2) + jd = raw_jd.floor + df = raw_jd - jd + _init_from_jd(jd, sg, df == 0 ? nil : df) + when 6 + # Current format: [nth, jd, df, sf, of, sg] + _nth, jd, df, sf, _of, sg = array + if df != 0 || sf != 0 + day_frac = (Rational(df) + sf) / 86400 + _init_from_jd(jd, sg, day_frac) + else + _init_from_jd(jd, sg) + end else - get_c_jd + raise TypeError, "invalid marshal data" end - self.class.send(:encode_jd, nth, @jd) end - def m_fr - if simple_dat_p? - 0 + # call-seq: + # deconstruct_keys(array_of_names_or_nil) -> hash + # + # Returns a hash of the name/value pairs, to use in pattern matching. + # Possible keys are: :year, :month, :day, + # :wday, :yday. + # + # Possible usages: + # + # d = Date.new(2022, 10, 5) + # + # if d in wday: 3, day: ..7 # uses deconstruct_keys underneath + # puts "first Wednesday of the month" + # end + # #=> prints "first Wednesday of the month" + # + # case d + # in year: ...2022 + # puts "too old" + # in month: ..9 + # puts "quarter 1-3" + # in wday: 1..5, month: + # puts "working day in month #{month}" + # end + # #=> prints "working day in month 10" + # + # Note that deconstruction by pattern can also be combined with class check: + # + # if d in Date(wday: 3, day: ..7) + # puts "first Wednesday of the month" + # end + # + def deconstruct_keys(keys) + if keys + if keys.size == 1 + case keys[0] + when :year + _civil unless @year + { year: @year } + when :month + _civil unless @year + { month: @month } + when :day + _civil unless @year + { day: @day } + when :wday then { wday: (@jd + 1) % 7 } + when :yday then { yday: yday } + else {} + end + else + _civil unless @year + h = {} + keys.each do |k| + case k + when :year then h[:year] = @year + when :month then h[:month] = @month + when :day then h[:day] = @day + when :wday then h[:wday] = (@jd + 1) % 7 + when :yday then h[:yday] = yday + end + end + h + end else - df = m_local_df - sf = m_sf - - fr = isec_to_day(df) - fr = fr + ns_to_day(sf) if sf.nonzero? - - fr + _civil unless @year + { year: @year, month: @month, day: @day, wday: (@jd + 1) % 7, yday: yday } end end - def m_local_df - if simple_dat_p? - 0 + # --------------------------------------------------------------------------- + # String formatting (delegated to strftime.rb) + # --------------------------------------------------------------------------- + + # call-seq: + # asctime -> string + # + # Equivalent to #strftime with argument '%a %b %e %T %Y' + # (or its {shorthand form}[rdoc-ref:language/strftime_formatting.rdoc@Shorthand+Conversion+Specifiers] + # '%c'): + # + # Date.new(2001, 2, 3).asctime # => "Sat Feb 3 00:00:00 2001" + # + # See {asctime}[https://linux.die.net/man/3/asctime]. + # + def asctime + _civil unless @year + d = @day + d_s = d < 10 ? " #{d}" : d.to_s + y = @year + y_s = y >= 1000 ? y.to_s : (y >= 0 ? format('%04d', y) : format('-%04d', -y)) + w = (@jd + 1) % 7 + if instance_of?(Date) + "#{ASCTIME_DAYS[w]} #{ASCTIME_MONS[@month]} #{d_s} 00:00:00 #{y_s}".force_encoding(Encoding::US_ASCII) else - get_c_df - local_df + "#{ASCTIME_DAYS[w]} #{ASCTIME_MONS[@month]} #{d_s} #{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]} #{y_s}".force_encoding(Encoding::US_ASCII) end end + alias_method :ctime, :asctime - def local_df - df_utc_to_local(@df || 0, @of || 0) - end - - def isec_to_day(s) - sec_to_day(s) + # call-seq: + # iso8601 -> string + # + # Equivalent to #strftime with argument '%Y-%m-%d' + # (or its {shorthand form}[rdoc-ref:language/strftime_formatting.rdoc@Shorthand+Conversion+Specifiers] + # '%F'); + # + # Date.new(2001, 2, 3).iso8601 # => "2001-02-03" + # + def iso8601 + to_s end + alias_method :xmlschema, :iso8601 - def sec_to_day(s) - s.is_a?(Integer) ? Rational(s, DAY_IN_SECONDS) : s.quo(DAY_IN_SECONDS) + # call-seq: + # rfc3339 -> string + # + # Equivalent to #strftime with argument '%FT%T%:z'; + # see {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]: + # + # Date.new(2001, 2, 3).rfc3339 # => "2001-02-03T00:00:00+00:00" + # + def rfc3339 + (to_s << 'T00:00:00+00:00').force_encoding(Encoding::US_ASCII) end - def ns_to_day(n) - if n.is_a?(Integer) - Rational(n, DAY_IN_SECONDS * SECOND_IN_NANOSECONDS) + # call-seq: + # rfc2822 -> string + # + # Equivalent to #strftime with argument '%a, %-d %b %Y %T %z'; + # see {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]: + # + # Date.new(2001, 2, 3).rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000" + # + def rfc2822 + _civil unless @year + w = (@jd + 1) % 7 + y = @year + y_s = y >= 1000 ? y.to_s : (y >= 0 ? format('%04d', y) : format('-%04d', -y)) + if instance_of?(Date) + "#{RFC2822_DAYS[w]}, #{@day}#{RFC_MON_SPACE[@month]}#{y_s} 00:00:00 +0000".force_encoding(Encoding::US_ASCII) else - n.quo(DAY_IN_SECONDS * SECOND_IN_NANOSECONDS) - end - end - - def m_real_cwyear - nth = m_nth - year = m_cwyear - - nth.zero? ? year : encode_year(nth, year, m_gregorian_p? ? -1 : 1) - end - - def m_cwyear - return @cwyear if @has_commercial - ry, rw, _ = self.class.send(:c_jd_to_commercial, m_local_jd, m_virtual_sg) - unless frozen? - @cwyear = ry - @cweek = rw - @has_commercial = true + "#{RFC2822_DAYS[w]}, #{@day}#{RFC_MON_SPACE[@month]}#{y_s} #{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]} +0000".force_encoding(Encoding::US_ASCII) end - ry end + alias_method :rfc822, :rfc2822 - def m_cweek - return @cweek if @has_commercial - ry, rw, _ = self.class.send(:c_jd_to_commercial, m_local_jd, m_virtual_sg) - unless frozen? - @cwyear = ry - @cweek = rw - @has_commercial = true + # call-seq: + # httpdate -> string + # + # Equivalent to #strftime with argument '%a, %d %b %Y %T GMT'; + # see {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]: + # + # Date.new(2001, 2, 3).httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT" + # + def httpdate + _civil unless @year + w = (@jd + 1) % 7 + y = @year + y_s = y >= 1000 ? y.to_s : (y >= 0 ? format('%04d', y) : format('-%04d', -y)) + if instance_of?(Date) + "#{ASCTIME_DAYS[w]}, #{PAD2[@day]}#{RFC_MON_SPACE[@month]}#{y_s} 00:00:00 GMT".force_encoding(Encoding::US_ASCII) + else + "#{ASCTIME_DAYS[w]}, #{PAD2[@day]}#{RFC_MON_SPACE[@month]}#{y_s} #{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]} GMT".force_encoding(Encoding::US_ASCII) end - rw - end - - def m_cwday - w = m_wday - # ISO 8601 places Sunday at 7. - w.zero? ? 7 : w end - def m_ajd - if simple_dat_p? - # For simple date: - r = m_real_jd - - # Optimization: Integer operations within Fixnum range - if r.is_a?(Integer) && r <= (2**62 - 1) / 2 && r >= (-(2**62) + 1) / 2 - ir = r * 2 - 1 - return Rational(ir, 2) - else - return Rational(r * 2 - 1, 2) - end + # call-seq: + # jisx0301 -> string + # + # Returns a string representation of the date in +self+ + # in JIS X 0301 format. + # + # Date.new(2001, 2, 3).jisx0301 # => "H13.02.03" + # + def jisx0301 + _civil unless @year + jd = @jd + m = @month + d = @day + md = "#{PAD2[m]}.#{PAD2[d]}" + if jd >= 2458605 # Reiwa (2019-05-01) + "R#{PAD2[@year - 2018]}.#{md}" + elsif jd >= 2447535 # Heisei (1989-01-08) + "H#{PAD2[@year - 1988]}.#{md}" + elsif jd >= 2424875 # Showa (1926-12-25) + "S#{PAD2[@year - 1925]}.#{md}" + elsif jd >= 2419614 # Taisho (1912-07-30) + "T#{PAD2[@year - 1911]}.#{md}" + elsif jd >= 2405160 # Meiji (1873-01-01) + "M#{PAD2[@year - 1867]}.#{md}" + else + to_s end - - # For complex date: - r = m_real_jd - df = m_df - - # Subtract half a day (12 hours) from df. - df -= HALF_DAYS_IN_SECONDS - - # If df is not zero, add. - r = r + isec_to_day(df) if df != 0 - - # If sf is not zero, add. - sf = m_sf - r = r + ns_to_day(sf) if sf != 0 - - r end - def m_amjd - r = m_real_jd - - # Optimization: Integer operations within Fixnum range - if r.is_a?(Integer) && r >= (-(2**62) + 2400001) - ir = r - 2400001 - r = Rational(ir, 1) + # call-seq: + # to_s -> string + # + # Returns a string representation of the date in +self+ + # in {ISO 8601 extended date format}[rdoc-ref:language/strftime_formatting.rdoc@ISO+8601+Format+Specifications] + # ('%Y-%m-%d'): + # + # Date.new(2001, 2, 3).to_s # => "2001-02-03" + # + def to_s + _civil + suffix = MONTH_DAY_SUFFIX[@month][@day] + y = @year + if y >= 1000 + # Fast path: 4-digit year needs no zero-padding (most common case). + (y.to_s << suffix).force_encoding(Encoding::US_ASCII) + elsif y >= 0 + (format('%04d', y) << suffix).force_encoding(Encoding::US_ASCII) else - r = Rational(m_real_jd - 2400001, 1) + (format('-%04d', -y) << suffix).force_encoding(Encoding::US_ASCII) end - - # For simple date, stop here. - return r if simple_dat_p? - - # For complex date, add df and sf. - df = m_df - r = r + isec_to_day(df) if df != 0 - - sf = m_sf - r = r + ns_to_day(sf) if sf != 0 - - r end - def m_wnumx(f) - _, rw, _ = c_jd_to_weeknum(m_local_jd, f, m_virtual_sg) - - rw + # call-seq: + # inspect -> string + # + # Returns a string representation of +self+: + # + # Date.new(2001, 2, 3).inspect + # # => "#" + # + def inspect + sg = @sg.is_a?(Float) ? @sg.to_s : @sg + "#".force_encoding(Encoding::US_ASCII) end - def c_jd_to_weeknum(jd, f, sg) - ry, _, _ = self.class.send(:c_jd_to_civil, jd, sg) - rjd, _ = self.class.send(:c_find_fdoy, ry, sg) - - rjd += 6 - - mod_val = euclidean_mod((rjd - f) + 1, 7) - j = jd - (rjd - mod_val) + 7 - - rw = euclidean_div(j, 7) - rd = euclidean_mod(j, 7) - - [ry, rw, rd] + # override + def freeze + _civil # compute and cache civil date before freezing + super end - # Euclidean division (equivalent to the DIV macro in C) - def euclidean_div(a, b) - q = a / b - r = a % b - # In Ruby, a remainder of a negative number is negative, so adjust it accordingly. - if r < 0 - if b > 0 - q -= 1 - else - q += 1 - end - end - - q - end + # --------------------------------------------------------------------------- + # Private helpers + # --------------------------------------------------------------------------- - # Euclidean modulo (equivalent to the MOD macro in C) - def euclidean_mod(a, b) - r = a % b - # In Ruby, a remainder of a negative number is negative, so adjust it accordingly. - if r < 0 - if b > 0 - r += b - else - r -= b - end - end + private - r + def _init_from_jd(jd, sg, df = nil) + @jd = jd + @sg = sg + @df = df end - def jisx0301_date_format(jd, year) - # If jd is not a Fixnum (Integer in Ruby), use ISO format - return '%Y-%m-%d' unless jd.is_a?(Integer) - - # Determine the era based on Julian Day Number - if jd < 2405160 - # Before Meiji era (before 1868-01-25) - '%Y-%m-%d' - elsif jd < 2419614 - # Meiji era (M) 1868-01-25 to 1912-07-29 - era_char = 'M' - era_start = 1867 - format_era(era_char, year, era_start) - elsif jd < 2424875 - # Taisho era (T) 1912-07-30 to 1926-12-24 - era_char = 'T' - era_start = 1911 - format_era(era_char, year, era_start) - elsif jd < 2447535 - # Showa era (S) 1926-12-25 to 1989-01-07 - era_char = 'S' - era_start = 1925 - format_era(era_char, year, era_start) - elsif jd < 2458605 - # Heisei era (H) 1989-01-08 to 2019-04-30 - era_char = 'H' - era_start = 1988 - format_era(era_char, year, era_start) + def _civil + return if @year + jd = @jd + if @sg == Float::INFINITY # always Julian + b = 0 + c = jd + 32082 + elsif jd >= @sg # Gregorian (handles -Infinity too) + a = jd + 32044 + b = (4 * a + 3) / 146097 + c = a - (146097 * b) / 4 + else # Julian (before reform date) + b = 0 + c = jd + 32082 + end + d = (4 * c + 3) / 1461 + e = c - (1461 * d) / 4 + m = (5 * e + 2) / 153 + @day = e - (153 * m + 2) / 5 + 1 + @month = m + 3 - 12 * (m / 10) + @year = 100 * b + d - 4800 + m / 10 + end + + # Inline jd_to_commercial: compute and cache cwyear/cweek + def _compute_commercial + jd = @jd + wday_val = (jd + 1) % 7 + cwday_val = wday_val == 0 ? 7 : wday_val + thursday = jd + (4 - cwday_val) + sg = @sg + # inline jd_to_gregorian/jd_to_julian to get year only + if sg == Float::INFINITY + # Julian + c = thursday + 32082 + d = (4 * c + 3) / 1461 + e = c - (1461 * d) / 4 + m = (5 * e + 2) / 153 + y = d - 4800 + m / 10 + elsif thursday >= sg + # Gregorian + a = thursday + 32044 + b = (4 * a + 3) / 146097 + c = a - (146097 * b) / 4 + d = (4 * c + 3) / 1461 + e = c - (1461 * d) / 4 + m = (5 * e + 2) / 153 + y = 100 * b + d - 4800 + m / 10 else - # Reiwa era (R) 2019-05-01 onwards - era_char = 'R' - era_start = 2018 - format_era(era_char, year, era_start) + # Julian + c = thursday + 32082 + d = (4 * c + 3) / 1461 + e = c - (1461 * d) / 4 + m = (5 * e + 2) / 153 + y = d - 4800 + m / 10 + end + # inline civil_to_jd(y, 1, 4, sg): month=1 (<= 2), day=4 + yy = y - 1 + gjd_base = (1461 * (yy + 4716)) / 4 + 432 # GJD_MONTH_OFFSET[1](=428) + 4 + a2 = yy / 100 + gjd = gjd_base - 1524 + 2 - a2 + a2 / 4 + jd_jan4 = gjd >= sg ? gjd : gjd_base - 1524 + wday_jan4 = (jd_jan4 + 1) % 7 + iso_wday_jan4 = wday_jan4 == 0 ? 7 : wday_jan4 + mon_wk1 = jd_jan4 - (iso_wday_jan4 - 1) + cw = (jd - mon_wk1) / 7 + 1 + unless frozen? + @cweek = cw + @cwyear = y end + [y, cw] end - def format_era(era_char, year, era_start) - era_year = year - era_start - "#{era_char}%02d.%%m.%%d" % era_year - end - - def zone - of = @parsed_offset || 0 - s = of < 0 ? '-' : '+' - a = of.abs - h = a / HOUR_IN_SECONDS - m = a % HOUR_IN_SECONDS / MINUTE_IN_SECONDS - "%c%02d:%02d" % [s, h, m] - end - - # C: old_to_new — converts old ajd/of/sg format to new nth/jd/df/sf/of/sg - def old_to_new(ajd, of, sg) - # C: decode_day(ajd + half_days_in_day, &jd, &df, &sf) - d = ajd + Rational(1, 2) - - # div_day: jd = floor(d), f = d mod 1 - jd_full = d.floor - f = d - jd_full - - # div_df: df = floor(f * DAY_IN_SECONDS), remainder - df_rational = f * 86400 - df = df_rational.floor - sf_frac = df_rational - df - - # sec_to_ns: sf = round(sf_frac * SECOND_IN_NANOSECONDS) - sf = (sf_frac * 1_000_000_000).round - - # C: day_to_sec(of) then round - of_sec = (of * 86400).round.to_i - - # C: decode_jd(jd, &nth, &rjd) - nth = jd_full.div(CM_PERIOD) - rjd = (jd_full % CM_PERIOD).to_i - - # Validations (C: old_to_new) - raise Error, "invalid day fraction" if df < 0 || df >= 86400 - if of_sec < -86400 || of_sec > 86400 - of_sec = 0 - warn "invalid offset is ignored" - end - - # Convert Infinity to Float (C: NUM2DBL(sg)) - if sg.is_a?(Infinity) - sg = case sg.send(:d) - when -1 then -Float::INFINITY - when 1 then Float::INFINITY - else DEFAULT_SG - end - end - - [nth, rjd, df, sf, of_sec, sg] - end end diff --git a/lib/date/datetime.rb b/lib/date/datetime.rb index 844447d6..aa68c08c 100644 --- a/lib/date/datetime.rb +++ b/lib/date/datetime.rb @@ -1,383 +1,486 @@ # frozen_string_literal: true -# Implementation of DateTime from ruby/date/ext/date/date_core.c -# DateTime is a subclass of Date that includes time-of-day and timezone. class DateTime < Date + + STRFTIME_DATETIME_DEFAULT_FMT = '%FT%T%:z'.encode(Encoding::US_ASCII) + private_constant :STRFTIME_DATETIME_DEFAULT_FMT + + # --------------------------------------------------------------------------- + # Initializer + # --------------------------------------------------------------------------- + # call-seq: # DateTime.new(year=-4712, month=1, day=1, hour=0, minute=0, second=0, offset=0, start=Date::ITALY) -> datetime - # - # Creates a new DateTime object. def initialize(year = -4712, month = 1, day = 1, hour = 0, minute = 0, second = 0, offset = 0, start = ITALY) - y = year - m = month - d = day - h = hour - min = minute - s = second - fr2 = 0 - - # argument type checking - raise TypeError, "invalid year (not numeric)" unless y.is_a?(Numeric) - raise TypeError, "invalid month (not numeric)" unless m.is_a?(Numeric) - raise TypeError, "invalid day (not numeric)" unless d.is_a?(Numeric) - raise TypeError, "invalid hour (not numeric)" unless h.is_a?(Numeric) - raise TypeError, "invalid minute (not numeric)" unless min.is_a?(Numeric) - raise TypeError, "invalid second (not numeric)" unless s.is_a?(Numeric) - - # Handle fractional day (C: d_trunc) - d_trunc, fr = d_trunc_with_frac(d) - d = d_trunc - fr2 = fr if fr.nonzero? - - # Handle fractional hour (C: h_trunc via num2int_with_frac) - h_int = h.to_i - h_frac = h - h_int - if h_frac.nonzero? - fr2 = fr2 + Rational(h_frac) / 24 - h = h_int - end + year = Integer(year) + month = Integer(month) + of_sec = _str_offset_to_sec(offset) - # Handle fractional minute (C: min_trunc) - min_int = min.to_i - min_frac = min - min_int - if min_frac.nonzero? - fr2 = fr2 + Rational(min_frac) / 1440 - min = min_int - end + raise TypeError, "expected numeric" unless day.is_a?(Numeric) - # Handle fractional second (C: s_trunc) - # C converts sub-second fraction to day fraction: fr2 = frac / DAY_IN_SECONDS - s_int = s.to_i - s_frac = s - s_int - if s_frac.nonzero? - fr2 = fr2 + Rational(s_frac) / DAY_IN_SECONDS - s = s_int - end + # Fractional day/hour/minute: propagate fraction to smaller units + day_r = day.to_r + day_i = day_r.floor + day_frac = day_r - day_i + day = day_i - # Convert offset to integer seconds (C: val2off → offset_to_sec) - rof = offset_to_sec(offset) + jd = self.class.__send__(:internal_valid_civil?, year, month, day, start) + raise Date::Error, "invalid date" unless jd - sg = self.class.send(:valid_sg, start) - style = self.class.send(:guess_style, y, sg) + raise TypeError, "expected numeric" unless hour.is_a?(Numeric) + raise TypeError, "expected numeric" unless minute.is_a?(Numeric) + raise TypeError, "expected numeric" unless second.is_a?(Numeric) - # Validate time (C: c_valid_time_p) - h, min, s = validate_time(h, min, s) + # Propagate fractions to smaller units + hour_r = hour.to_r + day_frac * 24 + hour_i = hour_r.floor + hour_frac = hour_r - hour_i - # Handle hour 24 (C: canon24oc) - if h == 24 - h = 0 - fr2 = fr2 + 1 - end - - if style < 0 - # gregorian calendar only - result = self.class.send(:valid_gregorian_p, y, m, d) - raise Error, "invalid date" unless result - - nth, ry = self.class.send(:decode_year, y, -1) - rm = result[:rm] - rd = result[:rd] - - rjd, _ = self.class.send(:c_civil_to_jd, ry, rm, rd, GREGORIAN) - rjd2 = jd_local_to_utc(rjd, time_to_df(h, min, s), rof) - - @nth = canon(nth) - @jd = rjd2 - @sg = sg - @year = ry - @month = rm - @day = rd - @has_jd = true - @has_civil = true - @hour = h - @min = min - @sec = s - @df = df_local_to_utc(time_to_df(h, min, s), rof) - @sf = 0 - @of = rof - else - # full validation - result = self.class.send(:valid_civil_p, y, m, d, sg) - raise Error, "invalid date" unless result - - nth = result[:nth] - ry = result[:ry] - rm = result[:rm] - rd = result[:rd] - rjd = result[:rjd] - - rjd2 = jd_local_to_utc(rjd, time_to_df(h, min, s), rof) - - @nth = canon(nth) - @jd = rjd2 - @sg = sg - @year = ry - @month = rm - @day = rd - @has_jd = true - @has_civil = true - @hour = h - @min = min - @sec = s - @df = df_local_to_utc(time_to_df(h, min, s), rof) - @sf = 0 - @of = rof - end + minute_r = minute.to_r + hour_frac * 60 + minute_i = minute_r.floor + minute_frac = minute_r - minute_i - # Add accumulated fractional parts (C: add_frac) - if fr2.nonzero? - new_date = self + fr2 - @nth = new_date.instance_variable_get(:@nth) - @jd = new_date.instance_variable_get(:@jd) - @sg = new_date.instance_variable_get(:@sg) - @year = new_date.instance_variable_get(:@year) - @month = new_date.instance_variable_get(:@month) - @day = new_date.instance_variable_get(:@day) - @has_jd = new_date.instance_variable_get(:@has_jd) - @has_civil = new_date.instance_variable_get(:@has_civil) - @hour = new_date.instance_variable_get(:@hour) - @min = new_date.instance_variable_get(:@min) - @sec = new_date.instance_variable_get(:@sec) - @df = new_date.instance_variable_get(:@df) || @df - @sf = new_date.instance_variable_get(:@sf) || @sf - @of = new_date.instance_variable_get(:@of) || @of - end + second_r = second.to_r + minute_frac * 60 + sec_i = second_r.floor + sec_f = second_r - sec_i + jd, hour, minute, sec_i = self.class.__send__(:_normalize_hms, jd, hour_i, minute_i, sec_i) - self + _init_datetime(jd, hour, minute, sec_i, sec_f, of_sec, start) end - # --- DateTime accessors (C: d_lite_hour etc.) --- + # --------------------------------------------------------------------------- + # Instance attributes + # --------------------------------------------------------------------------- # call-seq: # hour -> integer # - # Returns the hour in range (0..23). + # Returns the hour in range (0..23): + # + # DateTime.new(2001, 2, 3, 4, 5, 6).hour # => 4 def hour - if simple_dat_p? - 0 - else - get_c_time - @hour || 0 - end + @hour end # call-seq: # min -> integer # - # Returns the minute in range (0..59). + # Returns the minute in range (0..59): + # + # DateTime.new(2001, 2, 3, 4, 5, 6).min # => 5 def min - if simple_dat_p? - 0 - else - get_c_time - @min || 0 - end + @min end alias minute min # call-seq: # sec -> integer # - # Returns the second in range (0..59). + # Returns the second in range (0..59): + # + # DateTime.new(2001, 2, 3, 4, 5, 6).sec # => 6 def sec - if simple_dat_p? - 0 - else - get_c_time - @sec || 0 - end + @sec_i end alias second sec # call-seq: # sec_fraction -> rational # - # Returns the fractional part of the second: + # Returns the fractional part of the second in range + # (Rational(0, 1)...Rational(1, 1)): # # DateTime.new(2001, 2, 3, 4, 5, 6.5).sec_fraction # => (1/2) - # - # C: m_sf_in_sec = ns_to_sec(m_sf) def sec_fraction - ns = m_sf - ns.zero? ? Rational(0) : Rational(ns, SECOND_IN_NANOSECONDS) + @sec_frac end alias second_fraction sec_fraction # call-seq: - # offset -> rational - # - # Returns the offset as a fraction of day: + # d.offset -> rational # - # DateTime.parse('04pm+0730').offset # => (5/16) + # Returns the offset. # - # C: m_of_in_day = isec_to_day(m_of) + # DateTime.parse('04pm+0730').offset #=> (5/16) def offset - of = m_of - of.zero? ? Rational(0) : Rational(of, DAY_IN_SECONDS) + Rational(@of, 86400) end # call-seq: - # zone -> string + # d.zone -> string # - # Returns the timezone as a string: + # Returns the timezone. # - # DateTime.parse('04pm+0730').zone # => "+07:30" - # - # C: m_zone → of2str(m_of) + # DateTime.parse('04pm+0730').zone #=> "+07:30" def zone - if simple_dat_p? - "+00:00".encode(Encoding::US_ASCII) + _of2str(@of) + end + + # call-seq: + # day_fraction -> rational + # + # Returns the fractional part of the day in range (Rational(0, 1)...Rational(1, 1)): + # + # DateTime.new(2001,2,3,12).day_fraction # => (1/2) + def day_fraction + Rational(@hour * 3600 + @min * 60 + @sec_i, 86400) + + Rational(@sec_frac.numerator, @sec_frac.denominator * 86400) + end + + # call-seq: + # d.ajd -> rational + # + # Returns the astronomical Julian day number. This is a fractional + # number, which is not adjusted by the offset. + # + # DateTime.new(2001,2,3,4,5,6,'+7').ajd #=> (11769328217/4800) + # DateTime.new(2001,2,2,14,5,6,'-7').ajd #=> (11769328217/4800) + def ajd + jd_r = Rational(@jd) + time_r = Rational(@hour * 3600 + @min * 60 + @sec_i, 86400) + + Rational(@sec_frac.numerator, @sec_frac.denominator * 86400) + of_r = Rational(@of, 86400) + jd_r + time_r - of_r - Rational(1, 2) + end + + # --------------------------------------------------------------------------- + # Arithmetic (override for fractional day support) + # --------------------------------------------------------------------------- + + # call-seq: + # d + other -> date + # + # Returns a date object pointing +other+ days after self. The other + # should be a numeric value. If the other is a fractional number, + # assumes its precision is at most nanosecond. + # + # Date.new(2001,2,3) + 1 #=> # + # DateTime.new(2001,2,3) + Rational(1,2) + # #=> # + # DateTime.new(2001,2,3) + Rational(-1,2) + # #=> # + # DateTime.jd(0,12) + DateTime.new(2001,2,3).ajd + # #=> # + def +(other) + case other + when Integer + self.class.__send__(:_new_dt_from_jd_time,@jd + other, @hour, @min, @sec_i, @sec_frac, @of, @sg) + when Rational, Float + # other is days (may be fractional) — add as seconds + extra_sec = other.to_r * 86400 + total_r = Rational(@jd) * 86400 + @hour * 3600 + @min * 60 + @sec_i + @sec_frac + extra_sec + _from_total_sec_r(total_r) + when Numeric + r = other.to_r + raise TypeError, "#{other.class} can't be coerced into Integer" unless r.is_a?(Rational) + extra_sec = r * 86400 + total_r = Rational(@jd) * 86400 + @hour * 3600 + @min * 60 + @sec_i + @sec_frac + extra_sec + _from_total_sec_r(total_r) else - of = m_of - s = of < 0 ? '-' : '+' - a = of < 0 ? -of : of - h = a / HOUR_IN_SECONDS - m = a % HOUR_IN_SECONDS / MINUTE_IN_SECONDS - ("%c%02d:%02d" % [s, h, m]).encode(Encoding::US_ASCII) + raise TypeError, "expected numeric" end end - STRFTIME_DATETIME_DEFAULT_FMT = '%FT%T%:z'.encode(Encoding::US_ASCII) - private_constant :STRFTIME_DATETIME_DEFAULT_FMT + # call-seq: + # d - other -> date or rational + # + # If the other is a date object, returns a Rational + # whose value is the difference between the two dates in days. + # If the other is a numeric value, returns a date object + # pointing +other+ days before self. + # If the other is a fractional number, + # assumes its precision is at most nanosecond. + # + # Date.new(2001,2,3) - 1 #=> # + # DateTime.new(2001,2,3) - Rational(1,2) + # #=> # + # Date.new(2001,2,3) - Date.new(2001) + # #=> (33/1) + # DateTime.new(2001,2,3) - DateTime.new(2001,2,2,12) + # #=> (1/2) + def -(other) + case other + when Date + ajd - other.ajd + when Integer + self.class.__send__(:_new_dt_from_jd_time,@jd - other, @hour, @min, @sec_i, @sec_frac, @of, @sg) + when Rational, Float + self + (-other) + when Numeric + r = other.to_r + raise TypeError, "#{other.class} can't be coerced into Integer" unless r.is_a?(Rational) + self + (-r) + else + raise TypeError, "expected numeric" + end + end + + # call-seq: + # new_start(start = Date::ITALY]) -> new_date + # + # Returns a copy of +self+ with the given +start+ value: + # + # d0 = Date.new(2000, 2, 3) + # d0.julian? # => false + # d1 = d0.new_start(Date::JULIAN) + # d1.julian? # => true + # + # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + def new_start(start = Date::ITALY) + self.class.__send__(:_new_dt_from_jd_time, @jd, @hour, @min, @sec_i, @sec_frac, @of, start) + end + + # call-seq: + # d.new_offset([offset=0]) -> date + # + # Duplicates self and resets its offset. + # + # d = DateTime.new(2001,2,3,4,5,6,'-02:00') + # #=> # + # d.new_offset('+09:00') #=> # + def new_offset(of = 0) + of_sec = _str_offset_to_sec(of) + self.class.__send__(:_new_dt_from_jd_time,@jd, @hour, @min, @sec_i, @sec_frac, of_sec, @sg) + end + + # --------------------------------------------------------------------------- + # String formatting + # --------------------------------------------------------------------------- - # Override Date#strftime with DateTime default format + # call-seq: + # strftime(format = '%FT%T%:z') -> string + # + # Returns a string representation of +self+, + # formatted according the given +format: + # + # DateTime.now.strftime # => "2022-07-01T11:03:19-05:00" + # + # For other formats, + # see {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]: def strftime(format = STRFTIME_DATETIME_DEFAULT_FMT) super(format) end - # Override Date#jisx0301 for DateTime (includes time) + # call-seq: + # dt.jisx0301([n=0]) -> string + # + # Returns a string in a JIS X 0301 format. + # The optional argument +n+ is the number of digits for fractional seconds. + # + # DateTime.parse('2001-02-03T04:05:06.123456789+07:00').jisx0301(9) + # #=> "H13.02.03T04:05:06.123456789+07:00" def jisx0301(n = 0) n = n.to_i - if n == 0 - jd_val = send(:m_real_local_jd) - y = send(:m_real_year) - fmt = jisx0301_date_format(jd_val, y) + 'T%T%:z' - strftime(fmt) - else - s = jisx0301(0) - # insert fractional seconds before timezone - tz = s[-6..] # "+00:00" - base = s[0...-6] - frac = sec_fraction - if frac != 0 - f = format("%.#{n}f", frac.to_f)[1..] - base += f - else - base += '.' + '0' * n + ERA_TABLE.each do |start_jd, era, base_year| + if @jd >= start_jd + era_year = year - base_year + if n == 0 + return format('%s%02d.%02d.%02dT%02d:%02d:%02d%s', + era, era_year, month, day, hour, min, sec, zone) + else + sf = sec_fraction + frac = '.' + (sf * (10**n)).to_i.to_s.rjust(n, '0') + return format('%s%02d.%02d.%02dT%02d:%02d:%02d%s%s', + era, era_year, month, day, hour, min, sec, frac, zone) + end end - base + tz end + iso8601(n) end - # DateTime instance method - overrides Date#iso8601 + # call-seq: + # dt.iso8601([n=0]) -> string + # dt.xmlschema([n=0]) -> string + # + # This method is equivalent to strftime('%FT%T%:z'). + # The optional argument +n+ is the number of digits for fractional seconds. + # + # DateTime.parse('2001-02-03T04:05:06.123456789+07:00').iso8601(9) + # #=> "2001-02-03T04:05:06.123456789+07:00" def iso8601(n = 0) n = n.to_i if n == 0 - strftime('%FT%T%:z') + strftime('%Y-%m-%dT%H:%M:%S%:z') else - s = strftime('%FT%T') - frac = sec_fraction - if frac != 0 - f = format("%.#{n}f", frac.to_f)[1..] - s += f - else - s += '.' + '0' * n - end - s + strftime('%:z') + sf = sec_fraction + frac = '.' + (sf * (10**n)).to_i.to_s.rjust(n, '0') + strftime("%Y-%m-%dT%H:%M:%S#{frac}%:z") end end alias_method :xmlschema, :iso8601 - alias_method :rfc3339, :iso8601 # call-seq: - # deconstruct_keys(array_of_names_or_nil) -> hash + # dt.rfc3339([n=0]) -> string # - # Returns name/value pairs for pattern matching. - # Includes Date keys (:year, :month, :day, :wday, :yday) - # plus DateTime keys (:hour, :min, :sec, :sec_fraction, :zone). + # This method is equivalent to strftime('%FT%T%:z'). + # The optional argument +n+ is the number of digits for fractional seconds. # - # C: dt_lite_deconstruct_keys (is_datetime=true) - def deconstruct_keys(keys) - if keys.nil? - return { - year: year, - month: month, - day: day, - yday: yday, - wday: wday, - hour: hour, - min: min, - sec: sec, - sec_fraction: sec_fraction, - zone: zone - } - end + # DateTime.parse('2001-02-03T04:05:06.123456789+07:00').rfc3339(9) + # #=> "2001-02-03T04:05:06.123456789+07:00" + alias_method :rfc3339, :iso8601 - raise TypeError, "wrong argument type #{keys.class} (expected Array or nil)" unless keys.is_a?(Array) - - h = {} - keys.each do |key| - case key - when :year then h[:year] = year - when :month then h[:month] = month - when :day then h[:day] = day - when :yday then h[:yday] = yday - when :wday then h[:wday] = wday - when :hour then h[:hour] = hour - when :min then h[:min] = min - when :sec then h[:sec] = sec - when :sec_fraction then h[:sec_fraction] = sec_fraction - when :zone then h[:zone] = zone + # call-seq: + # deconstruct_keys(array_of_names_or_nil) -> hash + # + # Returns a hash of the name/value pairs, to use in pattern matching. + # Possible keys are: :year, :month, :day, + # :wday, :yday, :hour, :min, + # :sec, :sec_fraction, :zone. + # + # Possible usages: + # + # dt = DateTime.new(2022, 10, 5, 13, 30) + # + # if d in wday: 1..5, hour: 10..18 # uses deconstruct_keys underneath + # puts "Working time" + # end + # #=> prints "Working time" + # + # case dt + # in year: ...2022 + # puts "too old" + # in month: ..9 + # puts "quarter 1-3" + # in wday: 1..5, month: + # puts "working day in month #{month}" + # end + # #=> prints "working day in month 10" + # + # Note that deconstruction by pattern can also be combined with class check: + # + # if d in DateTime(wday: 1..5, hour: 10..18, day: ..7) + # puts "Working time, first week of the month" + # end + def deconstruct_keys(keys) + if keys + if keys.size == 1 + case keys[0] + when :year + _civil unless @year + { year: @year } + when :month + _civil unless @year + { month: @month } + when :day + _civil unless @year + { day: @day } + when :wday then { wday: (@jd + 1) % 7 } + when :yday then { yday: yday } + when :hour then { hour: @hour } + when :min then { min: @min } + when :sec then { sec: @sec_i } + when :sec_fraction then { sec_fraction: @sec_frac } + when :zone then { zone: _of2str(@of) } + else {} + end + else + _civil unless @year + h = {} + keys.each do |k| + case k + when :year then h[:year] = @year + when :month then h[:month] = @month + when :day then h[:day] = @day + when :wday then h[:wday] = (@jd + 1) % 7 + when :yday then h[:yday] = yday + when :hour then h[:hour] = @hour + when :min then h[:min] = @min + when :sec then h[:sec] = @sec_i + when :sec_fraction then h[:sec_fraction] = @sec_frac + when :zone then h[:zone] = _of2str(@of) + end + end + h end + else + _civil unless @year + { year: @year, month: @month, day: @day, wday: (@jd + 1) % 7, yday: yday, + hour: @hour, min: @min, sec: @sec_i, sec_fraction: @sec_frac, zone: _of2str(@of) } end - h end + DATETIME_TO_S_FMT = '%Y-%m-%dT%H:%M:%S%:z'.encode(Encoding::US_ASCII).freeze + private_constant :DATETIME_TO_S_FMT + # call-seq: - # to_s -> string + # dt.to_s -> string # - # Returns a string in ISO 8601 DateTime format: + # Returns a string in an ISO 8601 format. (This method doesn't use the + # expanded representations.) # - # DateTime.new(2001, 2, 3, 4, 5, 6, '+7').to_s - # # => "2001-02-03T04:05:06+07:00" + # DateTime.new(2001,2,3,4,5,6,'-7').to_s + # #=> "2001-02-03T04:05:06-07:00" def to_s - sprintf("%04d-%02d-%02dT%02d:%02d:%02d%s".encode(Encoding::US_ASCII), year, month, day, hour, min, sec, zone) + strftime(DATETIME_TO_S_FMT) end - # call-seq: - # new_offset(offset = 0) -> datetime - # - # Returns a new DateTime object with the same date and time, - # but with the given +offset+. - # - # C: d_lite_new_offset - def new_offset(of = 0) - if of.is_a?(String) - of = Rational(offset_to_sec(of), DAY_IN_SECONDS) - elsif of.is_a?(Integer) && of == 0 - of = Rational(0) + def hash + if @hour == 0 && @min == 0 && @sec_i == 0 + [@jd, @sg].hash + else + [@jd, @hour, @min, @sec_i, @sg].hash end - raise TypeError, "invalid offset" unless of.is_a?(Rational) || of.is_a?(Integer) || of.is_a?(Float) - of = Rational(of) unless of.is_a?(Rational) - self.class.new(year, month, day, hour, min, sec + sec_fraction, of, start) end + # --------------------------------------------------------------------------- + # Serialization override + # --------------------------------------------------------------------------- + + # :nodoc: + def marshal_dump + # 6-element format: [nth, jd, df, sf, of, sg] + df = @hour * 3600 + @min * 60 + @sec_i + sf = (@sec_frac * 1_000_000_000).to_r # nanoseconds as Rational + [0, @jd, df, sf, @of, @sg] + end + + # :nodoc: + def marshal_load(array) + case array.length + when 2 + jd_like, sg_or_bool = array + sg = sg_or_bool == true ? ITALY : (sg_or_bool == false ? JULIAN : sg_or_bool.to_f) + _init_datetime(jd_like.to_i, 0, 0, 0, Rational(0), 0, sg) + when 3 + ajd, of_r, sg = array + of_sec = (of_r * 86400).to_i + # Reconstruct local JD and time from AJD + local_r = ajd + Rational(1, 2) + of_r + jd = local_r.floor + rem_r = (local_r - jd) * 86400 + h = rem_r.to_i / 3600 + rem_r -= h * 3600 + m = rem_r.to_i / 60 + s_r = rem_r - m * 60 + s_i, s_f = _split_second(s_r) + _init_datetime(jd, h, m, s_i, s_f, of_sec, sg) + when 6 + _nth, jd, df, sf, of, sg = array + h = df / 3600 + df -= h * 3600 + m = df / 60 + s = df % 60 + sf_r = sf.is_a?(Rational) ? (sf / 1_000_000_000) : Rational(sf.to_i, 1_000_000_000) + _init_datetime(jd, h, m, s, sf_r, of, sg) + else + raise TypeError, "invalid marshal data" + end + end + + # --------------------------------------------------------------------------- + # Type conversions + # --------------------------------------------------------------------------- + # call-seq: - # to_date -> date + # dt.to_date -> date # - # Returns a Date for this DateTime (time information is discarded). - # C: dt_lite_to_date → copy civil, reset time + # Returns a Date object which denotes self. def to_date - nth, ry = self.class.send(:decode_year, year, -1) - Date.send(:d_simple_new_internal, - nth, 0, - @sg, - ry, month, day, - 0x04) # HAVE_CIVIL + Date.__send__(:_new_from_jd, @jd, @sg) end # call-seq: - # to_datetime -> self + # dt.to_datetime -> self # # Returns self. def to_datetime @@ -385,442 +488,482 @@ def to_datetime end # call-seq: - # to_time -> time + # dt.to_time -> time # - # Returns a Time for this DateTime. - # C: dt_lite_to_time + # Returns a Time object which denotes self. def to_time - # C: dt_lite_to_time — converts Julian dates to Gregorian for Time compatibility - d = julian? ? gregorian : self - Time.new(d.year, d.month, d.day, d.hour, d.min, d.sec + d.sec_fraction, d.send(:m_of)) + y, m, d = self.class.__send__(:jd_to_gregorian, @jd) + if @of == 0 + Time.utc(y, m, d, @hour, @min, @sec_i + @sec_frac) + else + Time.new(y, m, d, @hour, @min, @sec_i + @sec_frac, @of) + end end + # --------------------------------------------------------------------------- + # Class methods + # --------------------------------------------------------------------------- + class << self - # Same as DateTime.new alias_method :civil, :new undef_method :today # call-seq: - # DateTime.jd(jd=0, hour=0, minute=0, second=0, offset=0, start=Date::ITALY) -> datetime + # DateTime._strptime(string[, format='%FT%T%z']) -> hash # - # Creates a new DateTime from a Julian Day Number. - # C: dt_lite_s_jd - def jd(jd = 0, hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) - # Validate jd - raise TypeError, "invalid jd (not numeric)" unless jd.is_a?(Numeric) - raise TypeError, "invalid hour (not numeric)" unless hour.is_a?(Numeric) - raise TypeError, "invalid minute (not numeric)" unless minute.is_a?(Numeric) - raise TypeError, "invalid second (not numeric)" unless second.is_a?(Numeric) - - j, fr = value_trunc(jd) - nth, rjd = decode_jd(j) - - sg = valid_sg(start) - - # Validate time - h = hour.to_i - h_frac = hour - h - min_i = minute.to_i - min_frac = minute - min_i - s_i = second.to_i - s_frac = second - s_i - - fr2 = fr - fr2 = fr2 + Rational(h_frac) / 24 if h_frac.nonzero? - fr2 = fr2 + Rational(min_frac) / 1440 if min_frac.nonzero? - fr2 = fr2 + Rational(s_frac) / 86400 if s_frac.nonzero? - - rof = _offset_to_sec(offset) + # Parses the given representation of date and time with the given + # template, and returns a hash of parsed elements. _strptime does + # not support specification of flags and width unlike strftime. + # + # See also strptime(3) and #strftime. + def _strptime(string = JULIAN_EPOCH_DATETIME, format = '%FT%T%z') + Date._strptime(string, format) + end - h += 24 if h < 0 - min_i += 60 if min_i < 0 - s_i += 60 if s_i < 0 - unless (0..24).cover?(h) && (0..59).cover?(min_i) && (0..59).cover?(s_i) && - !(h == 24 && (min_i > 0 || s_i > 0)) - raise Date::Error, "invalid date" - end - if h == 24 - h = 0 - fr2 = fr2 + 1 - end + # call-seq: + # DateTime.strptime([string='-4712-01-01T00:00:00+00:00'[, format='%FT%T%z'[ ,start=Date::ITALY]]]) -> datetime + # + # Parses the given representation of date and time with the given + # template, and creates a DateTime object. strptime does not support + # specification of flags and width unlike strftime. + # + # DateTime.strptime('2001-02-03T04:05:06+07:00', '%Y-%m-%dT%H:%M:%S%z') + # #=> # + # DateTime.strptime('03-02-2001 04:05:06 PM', '%d-%m-%Y %I:%M:%S %p') + # #=> # + # DateTime.strptime('2001-W05-6T04:05:06+07:00', '%G-W%V-%uT%H:%M:%S%z') + # #=> # + # DateTime.strptime('2001 04 6 04 05 06 +7', '%Y %U %w %H %M %S %z') + # #=> # + # DateTime.strptime('2001 05 6 04 05 06 +7', '%Y %W %u %H %M %S %z') + # #=> # + # DateTime.strptime('-1', '%s') + # #=> # + # DateTime.strptime('-1000', '%Q') + # #=> # + # DateTime.strptime('sat3feb014pm+7', '%a%d%b%y%H%p%z') + # #=> # + # + # See also strptime(3) and #strftime. + def strptime(string = JULIAN_EPOCH_DATETIME, format = '%FT%T%z', start = Date::ITALY) + hash = _strptime(string, format) + _dt_new_by_frags(hash, start) + end - df = h * 3600 + min_i * 60 + s_i - df_utc = df - rof - jd_utc = rjd - if df_utc < 0 - jd_utc -= 1 - df_utc += 86400 - elsif df_utc >= 86400 - jd_utc += 1 - df_utc -= 86400 + # call-seq: + # DateTime.jd([jd=0[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]) -> datetime + # + # Creates a DateTime object denoting the given chronological Julian + # day number. + # + # DateTime.jd(2451944) #=> # + # DateTime.jd(2451945) #=> # + # DateTime.jd(Rational('0.5')) + # #=> # + def jd(jd = 0, hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) + raise TypeError, "no implicit conversion of #{jd.class} into Integer" unless jd.is_a?(Numeric) + jd_r = jd.to_r + jd_i = jd_r.floor + h = Integer(hour) + m = Integer(minute) + of_sec = _parse_of(offset) + if jd_i != jd_r + # Fractional JD: convert fraction to extra seconds and handle overflow + frac_sec = (jd_r - jd_i) * 86400 + second = second.to_r + frac_sec + sec_i, sec_f = _split_sec(second) + if sec_i >= 60 + carry_m, sec_i = sec_i.divmod(60) + m += carry_m + end + if m >= 60 + carry_h, m = m.divmod(60) + h += carry_h + end + if h >= 24 + carry_d, h = h.divmod(24) + jd_i += carry_d + end + else + # Integer JD: pass raw values to _normalize_hms (non-cascading) + sec_i, sec_f = _split_sec(second) end - - obj = new_with_jd_and_time(nth, jd_utc, df_utc, 0, rof, sg) - - obj = obj + fr2 if fr2.nonzero? - - obj + _new_dt_from_jd_time(jd_i, h, m, sec_i, sec_f, of_sec, start) end # call-seq: - # DateTime.ordinal(year=-4712, yday=1, hour=0, minute=0, second=0, offset=0, start=Date::ITALY) -> datetime + # DateTime.ordinal([year=-4712[, yday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]) -> datetime + # + # Creates a DateTime object denoting the given ordinal date. # - # Creates a new DateTime from an ordinal date. - # C: dt_lite_s_ordinal + # DateTime.ordinal(2001,34) #=> # + # DateTime.ordinal(2001,34,4,5,6,'+7') + # #=> # + # DateTime.ordinal(2001,-332,-20,-55,-54,'+7') + # #=> # def ordinal(year = -4712, yday = 1, hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) - raise TypeError, "invalid year (not numeric)" unless year.is_a?(Numeric) - raise TypeError, "invalid yday (not numeric)" unless yday.is_a?(Numeric) - raise TypeError, "invalid hour (not numeric)" unless hour.is_a?(Numeric) - raise TypeError, "invalid minute (not numeric)" unless minute.is_a?(Numeric) - raise TypeError, "invalid second (not numeric)" unless second.is_a?(Numeric) - - # Truncate fractional yday - yday_int = yday.to_i - yday_frac = yday.is_a?(Integer) ? 0 : yday - yday_int - - result = valid_ordinal_p(year, yday_int, start) - raise Date::Error, "invalid date" unless result + jd_v = internal_valid_ordinal?(Integer(year), Integer(yday), start) + raise Date::Error, "invalid date" unless jd_v + of_sec = _parse_of(offset) + sec_i, sec_f = _split_sec(second) + _new_dt_from_jd_time(jd_v, Integer(hour), Integer(minute), sec_i, sec_f, of_sec, start) + end - nth = result[:nth] - rjd = result[:rjd] - sg = valid_sg(start) + # call-seq: + # DateTime.commercial([cwyear=-4712[, cweek=1[, cwday=1[, hour=0[, minute=0[, second=0[, offset=0[, start=Date::ITALY]]]]]]]]) -> datetime + # + # Creates a DateTime object denoting the given week date. + # + # DateTime.commercial(2001) #=> # + # DateTime.commercial(2002) #=> # + # DateTime.commercial(2001,5,6,4,5,6,'+7') + # #=> # + def commercial(cwyear = -4712, cweek = 1, cwday = 1, hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) + jd_v = internal_valid_commercial?(Integer(cwyear), Integer(cweek), Integer(cwday), start) + raise Date::Error, "invalid date" unless jd_v + of_sec = _parse_of(offset) + sec_i, sec_f = _split_sec(second) + _new_dt_from_jd_time(jd_v, Integer(hour), Integer(minute), sec_i, sec_f, of_sec, start) + end - rof = _offset_to_sec(offset) + # call-seq: + # DateTime.now([start=Date::ITALY]) -> datetime + # + # Creates a DateTime object denoting the present time. + # + # DateTime.now #=> # + def now(start = Date::ITALY) + t = Time.now + jd = civil_to_jd(t.year, t.mon, t.mday, start) + sec_f = Rational(t.subsec) + _new_dt_from_jd_time(jd, t.hour, t.min, t.sec, sec_f, t.utc_offset, start) + end - h = hour.to_i - h_frac = hour - h - min_i = minute.to_i - min_frac = minute - min_i - s_i = second.to_i - s_frac = second - s_i + # call-seq: + # DateTime.weeknum(year=-4712, week=0, wday=1, wstart=0, hour=0, min=0, sec=0, offset=0, start=Date::ITALY) -> datetime + def weeknum(year = -4712, week = 0, wday = 1, wstart = 0, + hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) + jd = weeknum_to_jd(Integer(year), Integer(week), Integer(wday), Integer(wstart), start) + of_sec = _parse_of(offset) + sec_i, sec_f = _split_sec(second) + _new_dt_from_jd_time(jd, Integer(hour), Integer(minute), sec_i, sec_f, of_sec, start) + end - fr2 = yday_frac.nonzero? ? Rational(yday_frac) : 0 - fr2 = fr2 + Rational(h_frac) / 24 if h_frac.nonzero? - fr2 = fr2 + Rational(min_frac) / 1440 if min_frac.nonzero? - fr2 = fr2 + Rational(s_frac) / 86400 if s_frac.nonzero? + # call-seq: + # DateTime.nth_kday(year=-4712, month=1, n=1, k=1, hour=0, min=0, sec=0, offset=0, start=Date::ITALY) -> datetime + def nth_kday(year = -4712, month = 1, n = 1, k = 1, + hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) + jd = nth_kday_to_jd(Integer(year), Integer(month), Integer(n), Integer(k), start) + of_sec = _parse_of(offset) + sec_i, sec_f = _split_sec(second) + _new_dt_from_jd_time(jd, Integer(hour), Integer(minute), sec_i, sec_f, of_sec, start) + end + + # :nodoc: + def _new_dt_from_jd_time(jd, h, m, s, sf, of, sg) + jd, h, m, s = _normalize_hms(jd, h, m, s) + obj = allocate + obj.__send__(:_init_datetime, jd, h, m, s, sf, of, sg) + obj + end + # Normalize hour/min/sec. + # Negative values: add one period (non-cascading, matching C's c_valid_time_f?). + # After normalization, validate ranges and raise Date::Error if out of range. + # 24:00:00 is valid (normalizes to next day 00:00:00). + def _normalize_hms(jd, h, m, s) + s += 60 if s < 0 + m += 60 if m < 0 h += 24 if h < 0 - min_i += 60 if min_i < 0 - s_i += 60 if s_i < 0 - unless (0..24).cover?(h) && (0..59).cover?(min_i) && (0..59).cover?(s_i) && - !(h == 24 && (min_i > 0 || s_i > 0)) - raise Date::Error, "invalid date" - end + raise Date::Error, "invalid date" if s >= 60 + raise Date::Error, "invalid date" if m >= 60 + raise Date::Error, "invalid date" if h > 24 || h < 0 + raise Date::Error, "invalid date" if h == 24 && (m != 0 || s != 0) if h == 24 + jd += 1 h = 0 - fr2 = fr2 + 1 end - - df = h * 3600 + min_i * 60 + s_i - df_utc = df - rof - jd_utc = rjd - if df_utc < 0 - jd_utc -= 1 - df_utc += 86400 - elsif df_utc >= 86400 - jd_utc += 1 - df_utc -= 86400 - end - - obj = new_with_jd_and_time(nth, jd_utc, df_utc, 0, rof, sg) - - obj = obj + fr2 if fr2.nonzero? - - obj + [jd, h, m, s] end # call-seq: - # DateTime.commercial(cwyear=-4712, cweek=1, cwday=1, hour=0, minute=0, second=0, offset=0, start=Date::ITALY) -> datetime + # DateTime.parse(string='-4712-01-01T00:00:00+00:00'[, comp=true[, start=Date::ITALY]], limit: 128) -> datetime # - # Creates a new DateTime from a commercial date. - # C: dt_lite_s_commercial - def commercial(cwyear = -4712, cweek = 1, cwday = 1, hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) - raise TypeError, "invalid cwyear (not numeric)" unless cwyear.is_a?(Numeric) - raise TypeError, "invalid cweek (not numeric)" unless cweek.is_a?(Numeric) - raise TypeError, "invalid cwday (not numeric)" unless cwday.is_a?(Numeric) - raise TypeError, "invalid hour (not numeric)" unless hour.is_a?(Numeric) - raise TypeError, "invalid minute (not numeric)" unless minute.is_a?(Numeric) - raise TypeError, "invalid second (not numeric)" unless second.is_a?(Numeric) - - # Truncate fractional cwday - cwday_int = cwday.to_i - cwday_frac = cwday.is_a?(Integer) ? 0 : cwday - cwday_int - - result = valid_commercial_p(cwyear, cweek, cwday_int, start) - raise Date::Error, "invalid date" unless result - - nth = result[:nth] - rjd = result[:rjd] - sg = valid_sg(start) - - rof = _offset_to_sec(offset) - - h = hour.to_i - h_frac = hour - h - min_i = minute.to_i - min_frac = minute - min_i - s_i = second.to_i - s_frac = second - s_i - - fr2 = cwday_frac.nonzero? ? Rational(cwday_frac) : 0 - fr2 = fr2 + Rational(h_frac) / 24 if h_frac.nonzero? - fr2 = fr2 + Rational(min_frac) / 1440 if min_frac.nonzero? - fr2 = fr2 + Rational(s_frac) / 86400 if s_frac.nonzero? - - h += 24 if h < 0 - min_i += 60 if min_i < 0 - s_i += 60 if s_i < 0 - unless (0..24).cover?(h) && (0..59).cover?(min_i) && (0..59).cover?(s_i) && - !(h == 24 && (min_i > 0 || s_i > 0)) - raise Date::Error, "invalid date" - end - if h == 24 - h = 0 - fr2 = fr2 + 1 - end - - df = h * 3600 + min_i * 60 + s_i - df_utc = df - rof - jd_utc = rjd - if df_utc < 0 - jd_utc -= 1 - df_utc += 86400 - elsif df_utc >= 86400 - jd_utc += 1 - df_utc -= 86400 - end - - obj = new_with_jd_and_time(nth, jd_utc, df_utc, 0, rof, sg) - - obj = obj + fr2 if fr2.nonzero? - - obj + # Parses the given representation of date and time, and creates a + # DateTime object. + # + # This method *does* *not* function as a validator. If the input + # string does not match valid formats strictly, you may get a cryptic + # result. Should consider to use DateTime.strptime instead of this + # method as possible. + # + # If the optional second argument is true and the detected year is in + # the range "00" to "99", makes it full. + # + # DateTime.parse('2001-02-03T04:05:06+07:00') + # #=> # + # DateTime.parse('20010203T040506+0700') + # #=> # + # DateTime.parse('3rd Feb 2001 04:05:06 PM') + # #=> # + # + # Raise an ArgumentError when the string length is longer than _limit_. + # You can stop this check by passing limit: nil, but note + # that it may take a long time to parse. + def parse(string = '-4712-01-01T00:00:00+00:00', comp = true, start = Date::ITALY, limit: 128) + hash = Date._parse(string, comp, limit: limit) + _dt_new_by_frags(hash, start) end # call-seq: - # DateTime.strptime(string='-4712-01-01T00:00:00+00:00', format='%FT%T%z', start=Date::ITALY) -> datetime + # DateTime.iso8601(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) -> datetime # - # Parses +string+ according to +format+ and creates a DateTime. - # C: dt_lite_s_strptime - def strptime(string = '-4712-01-01T00:00:00+00:00', format = '%FT%T%z', start = Date::ITALY) - hash = _strptime(string, format) - dt_new_by_frags(hash, start) + # Creates a new DateTime object by parsing from a string according to + # some typical ISO 8601 formats. + # + # DateTime.iso8601('2001-02-03T04:05:06+07:00') + # #=> # + # DateTime.iso8601('20010203T040506+0700') + # #=> # + # DateTime.iso8601('2001-W05-6T04:05:06+07:00') + # #=> # + # + # Raise an ArgumentError when the string length is longer than _limit_. + # You can stop this check by passing limit: nil, but note + # that it may take a long time to parse. + def iso8601(string = '-4712-01-01T00:00:00+00:00', start = Date::ITALY, limit: 128) + hash = Date._iso8601(string, limit: limit) + _dt_new_by_frags(hash, start) end - # Override Date._strptime default format for DateTime - def _strptime(string, format = '%FT%T%z') - super(string, format) + # call-seq: + # DateTime.rfc3339(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) -> datetime + # + # Creates a new DateTime object by parsing from a string according to + # some typical RFC 3339 formats. + # + # DateTime.rfc3339('2001-02-03T04:05:06+07:00') + # #=> # + # + # Raise an ArgumentError when the string length is longer than _limit_. + # You can stop this check by passing limit: nil, but note + # that it may take a long time to parse. + def rfc3339(string = '-4712-01-01T00:00:00+00:00', start = Date::ITALY, limit: 128) + hash = Date._rfc3339(string, limit: limit) + _dt_new_by_frags(hash, start) end # call-seq: - # DateTime.now(start = Date::ITALY) -> datetime + # DateTime.xmlschema(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) -> datetime # - # Creates a DateTime for the current time. + # Creates a new DateTime object by parsing from a string according to + # some typical XML Schema formats. # - # C: datetime_s_now - def now(start = Date::ITALY) - t = Time.now - sg = valid_sg(start) - - of = t.utc_offset # integer seconds - - new( - t.year, t.mon, t.mday, - t.hour, t.min, t.sec + Rational(t.nsec, 1_000_000_000), - Rational(of, 86400), - sg - ) + # DateTime.xmlschema('2001-02-03T04:05:06+07:00') + # #=> # + # + # Raise an ArgumentError when the string length is longer than _limit_. + # You can stop this check by passing limit: nil, but note + # that it may take a long time to parse. + def xmlschema(string = '-4712-01-01T00:00:00+00:00', start = Date::ITALY, limit: 128) + hash = Date._xmlschema(string, limit: limit) + _dt_new_by_frags(hash, start) end # call-seq: - # DateTime.parse(string, comp = true, start = Date::ITALY, limit: 128) -> datetime + # DateTime.rfc2822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) -> datetime + # DateTime.rfc822(string='Mon, 1 Jan -4712 00:00:00 +0000'[, start=Date::ITALY], limit: 128) -> datetime + # + # Creates a new DateTime object by parsing from a string according to + # some typical RFC 2822 formats. # - # Parses +string+ and creates a DateTime. + # DateTime.rfc2822('Sat, 3 Feb 2001 04:05:06 +0700') + # #=> # # - # C: date_parse → dt_new_by_frags - def parse(string = JULIAN_EPOCH_DATETIME, comp = true, start = Date::ITALY, limit: 128) - hash = _parse(string, comp, limit: limit) - dt_new_by_frags(hash, start) + # Raise an ArgumentError when the string length is longer than _limit_. + # You can stop this check by passing limit: nil, but note + # that it may take a long time to parse. + def rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000', start = Date::ITALY, limit: 128) + hash = Date._rfc2822(string, limit: limit) + _dt_new_by_frags(hash, start) end + alias rfc822 rfc2822 - # Format-specific constructors delegate to _xxx + dt_new_by_frags - - def iso8601(string = JULIAN_EPOCH_DATETIME, start = Date::ITALY, limit: 128) - hash = _iso8601(string, limit: limit) - dt_new_by_frags(hash, start) + # call-seq: + # DateTime.httpdate(string='Mon, 01 Jan -4712 00:00:00 GMT'[, start=Date::ITALY]) -> datetime + # + # Creates a new DateTime object by parsing from a string according to + # some RFC 2616 format. + # + # DateTime.httpdate('Sat, 03 Feb 2001 04:05:06 GMT') + # #=> # + # + # Raise an ArgumentError when the string length is longer than _limit_. + # You can stop this check by passing limit: nil, but note + # that it may take a long time to parse. + def httpdate(string = 'Mon, 01 Jan -4712 00:00:00 GMT', start = Date::ITALY, limit: 128) + hash = Date._httpdate(string, limit: limit) + _dt_new_by_frags(hash, start) end - def rfc3339(string = JULIAN_EPOCH_DATETIME, start = Date::ITALY, limit: 128) - hash = _rfc3339(string, limit: limit) - dt_new_by_frags(hash, start) + # call-seq: + # DateTime.jisx0301(string='-4712-01-01T00:00:00+00:00'[, start=Date::ITALY], limit: 128) -> datetime + # + # Creates a new DateTime object by parsing from a string according to + # some typical JIS X 0301 formats. + # + # DateTime.jisx0301('H13.02.03T04:05:06+07:00') + # #=> # + # + # For no-era year, legacy format, Heisei is assumed. + # + # DateTime.jisx0301('13.02.03T04:05:06+07:00') + # #=> # + # + # Raise an ArgumentError when the string length is longer than _limit_. + # You can stop this check by passing limit: nil, but note + # that it may take a long time to parse. + def jisx0301(string = '-4712-01-01T00:00:00+00:00', start = Date::ITALY, limit: 128) + hash = Date._jisx0301(string, limit: limit) + _dt_new_by_frags(hash, start) end - def xmlschema(string = JULIAN_EPOCH_DATETIME, start = Date::ITALY, limit: 128) - hash = _xmlschema(string, limit: limit) - dt_new_by_frags(hash, start) - end + private - def rfc2822(string = JULIAN_EPOCH_DATETIME_RFC2822, start = Date::ITALY, limit: 128) - hash = _rfc2822(string, limit: limit) - dt_new_by_frags(hash, start) + # Create a DateTime object from parsed fragment hash. + # Uses the same fragment rewrite/complete/validate logic as Date._new_by_frags + # but additionally extracts time components (hour, min, sec, offset, sec_fraction). + def _dt_new_by_frags(hash, sg) # rubocop:disable Metrics/MethodLength + raise Date::Error, 'invalid date' if hash.nil? + hash = _sp_rewrite_frags(hash) + orig_sec = hash[:sec] + hash = _sp_complete_frags(DateTime, hash) + jd = _sp_valid_date_frags_p(hash, sg) + raise Date::Error, 'invalid date' if jd.nil? + + h = hash[:hour] || 0 + m = hash[:min] || 0 + s = hash[:sec] || 0 + raise Date::Error, 'invalid date' if orig_sec && orig_sec > 60 + s = 59 if s > 59 + of = hash[:offset] || 0 + if of.is_a?(Numeric) && (of < -86400 || of > 86400) + warn("invalid offset is ignored: #{of}", uplevel: 0) + of = 0 + end + sf = hash[:sec_fraction] || Rational(0) + _new_dt_from_jd_time(jd, h, m, s, sf, of, sg) end - alias_method :rfc822, :rfc2822 - def httpdate(string = JULIAN_EPOCH_DATETIME_HTTPDATE, start = Date::ITALY, limit: 128) - hash = _httpdate(string, limit: limit) - dt_new_by_frags(hash, start) + def _parse_of(offset) + case offset + when String + Date.__send__(:_offset_str_to_sec, offset) + when Rational + (offset * 86400).to_i + when Numeric + (offset * 86400).to_i + else + 0 + end end - def jisx0301(string = JULIAN_EPOCH_DATETIME, start = Date::ITALY, limit: 128) - hash = _jisx0301(string, limit: limit) - dt_new_by_frags(hash, start) + def _split_sec(second) + if second.is_a?(Rational) || second.is_a?(Float) + s_r = second.to_r + s_i = s_r.floor + [s_i, s_r - s_i] + else + [Integer(second), Rational(0)] + end end - private + end - JULIAN_EPOCH_DATETIME = '-4712-01-01T00:00:00+00:00' - JULIAN_EPOCH_DATETIME_RFC2822 = 'Mon, 1 Jan -4712 00:00:00 +0000' - JULIAN_EPOCH_DATETIME_HTTPDATE = 'Mon, 01 Jan -4712 00:00:00 GMT' + # --------------------------------------------------------------------------- + # Private helpers (strftime overrides) + # --------------------------------------------------------------------------- - # C: offset_to_sec / val2off (class method version for use in class << self) - def _offset_to_sec(of) - case of - when Integer - of - when Rational - (of * 86400).to_i - when Float - (of * 86400).to_i - when String - if of.strip.upcase == 'Z' - 0 - elsif of =~ /\A([+-])(\d{1,2}):(\d{2})\z/ - sign = $1 == '-' ? -1 : 1 - sign * ($2.to_i * 3600 + $3.to_i * 60) - elsif of =~ /\A([+-])(\d{2})(\d{2})?\z/ - sign = $1 == '-' ? -1 : 1 - sign * ($2.to_i * 3600 + ($3 ? $3.to_i * 60 : 0)) - else - 0 - end - else - 0 - end - end + private - # C: dt_new_by_frags (date_core.c:8434) - # - # Structure matches C exactly: - # 1. Fast path: year+mon+mday present, no jd/yday - # - Validate civil, default time to 0, clamp sec==60 → 59 - # 2. Slow path: rt_rewrite_frags → rt_complete_frags → rt__valid_date_frags_p - # 3. Validate time (c_valid_time_p), handle sec_fraction, offset - # 4. Construct DateTime - def dt_new_by_frags(hash, sg) - raise Date::Error, "invalid date" if hash.nil? || hash.empty? - - # --- Fast path (C: lines 8447-8466) --- - if !hash.key?(:jd) && !hash.key?(:yday) && - hash[:year] && hash[:mon] && hash[:mday] - - y = hash[:year]; m = hash[:mon]; d = hash[:mday] - raise Date::Error, "invalid date" unless valid_civil?(y, m, d, sg) - - # C: default time fields, clamp sec==60 - hash[:hour] = 0 unless hash.key?(:hour) - hash[:min] = 0 unless hash.key?(:min) - if !hash.key?(:sec) - hash[:sec] = 0 - elsif hash[:sec] == 60 - hash[:sec] = 59 - end + def internal_hour + @hour + end - # --- Slow path (C: lines 8467-8470) --- - # rt_complete_frags needs DateTime as klass for time-only fill-in. - # rt__valid_date_frags_p needs Date for validation (calls ordinal/new). - else - hash = Date.send(:rt_rewrite_frags, hash) - hash = Date.send(:rt_complete_frags, self, hash) - jd_val = Date.send(:rt__valid_date_frags_p, hash, sg) - raise Date::Error, "invalid date" unless jd_val + def internal_min + @min + end - # Convert JD to civil for constructor - y, m, d = Date.send(:c_jd_to_civil, jd_val, sg) - end + def internal_sec + @sec_i + end - # --- Time validation (C: c_valid_time_p, lines 8473-8480) --- - h = hash[:hour] || 0 - min = hash[:min] || 0 - s = hash[:sec] || 0 - - # C: c_valid_time_p normalizes negative values and validates range. - rh = h < 0 ? h + 24 : h - rmin = min < 0 ? min + 60 : min - rs = s < 0 ? s + 60 : s - unless (0..24).cover?(rh) && (0..59).cover?(rmin) && (0..59).cover?(rs) && - !(rh == 24 && (rmin > 0 || rs > 0)) - raise Date::Error, "invalid date" - end + def _sec_frac + @sec_frac + end - # --- sec_fraction (C: lines 8482-8486) --- - sf = hash[:sec_fraction] - s_with_frac = sf ? rs + sf : rs + def _of_seconds + @of + end - # --- offset (C: lines 8488-8495) --- - of_sec = hash[:offset] || 0 - if of_sec.abs > 86400 - warn "invalid offset is ignored" - of_sec = 0 - end - of = Rational(of_sec, 86400) + def _zone_str + _of2str(@of) + end - # --- Construct DateTime --- - new(y, m, d, rh, rmin, s_with_frac, of, sg) - end + def _init_datetime(jd, h, m, s, sf, of, sg) + @jd = jd + @sg = sg + @hour = h + @min = m + @sec_i = s + @sec_frac = sf.is_a?(Rational) ? sf : Rational(sf) + @of = of.to_i end - private + def _split_second(second) + if second.is_a?(Rational) || second.is_a?(Float) + s_r = second.to_r + s_i = s_r.floor + [s_i, s_r - s_i] + else + [Integer(second), Rational(0)] + end + end - # Convert offset argument to integer seconds. - # Accepts: Integer (seconds), Rational (fraction of day), String ("+HH:MM"), 0 - # C: offset_to_sec / val2off - def offset_to_sec(of) - case of - when Integer - of - when Float - # Fraction of day to seconds - (of * DAY_IN_SECONDS).to_i - when Rational - # Fraction of day to seconds - (of * DAY_IN_SECONDS).to_i + def _str_offset_to_sec(offset) + case offset when String - if of.strip.upcase == 'Z' - 0 - elsif of =~ /\A([+-])(\d{2}):(\d{2})\z/ - sign = $1 == '-' ? -1 : 1 - sign * ($2.to_i * HOUR_IN_SECONDS + $3.to_i * MINUTE_IN_SECONDS) - elsif of =~ /\A([+-])(\d{2})(\d{2})?\z/ - sign = $1 == '-' ? -1 : 1 - sign * ($2.to_i * HOUR_IN_SECONDS + ($3 ? $3.to_i * MINUTE_IN_SECONDS : 0)) - else - 0 - end + self.class.__send__(:_parse_of, offset) + when Rational + (offset * 86400).to_i + when Numeric + r = offset.to_r + raise TypeError, "#{offset.class} can't be used as offset" unless r.is_a?(Rational) + (r * 86400).to_i else 0 end end - # Validate time fields (C: c_valid_time_p) - def validate_time(h, min, s) - h += 24 if h < 0 - min += 60 if min < 0 - s += 60 if s < 0 - unless (0..24).cover?(h) && (0..59).cover?(min) && (0..59).cover?(s) && - !(h == 24 && (min > 0 || s > 0)) - raise Error, "invalid date" - end - [h, min, s] + def _of2str(of) + sign = of < 0 ? '-' : '+' + abs = of.abs + h = abs / 3600 + m = (abs % 3600) / 60 + format('%s%02d:%02d'.encode(Encoding::US_ASCII), sign, h, m) + end + + def _from_total_sec_r(total_r) + jd = (total_r / 86400).floor + rem = total_r - jd * 86400 + h = rem.to_i / 3600 + rem -= h * 3600 + m = rem.to_i / 60 + s_r = rem - m * 60 + s_i = s_r.floor + s_f = s_r - s_i + self.class.__send__(:_new_dt_from_jd_time,jd, h, m, s_i, s_f, @of, @sg) end + end diff --git a/lib/date/parse.rb b/lib/date/parse.rb index e560b3bb..682f6b40 100644 --- a/lib/date/parse.rb +++ b/lib/date/parse.rb @@ -1,99 +1,123 @@ # frozen_string_literal: true -require_relative "patterns" require_relative "zonetab" -# Implementation of ruby/date/ext/date/date_parse.c class Date class << self - # call-seq: - # Date.parse(string = '-4712-01-01', comp = true, start = Date::ITALY, limit: 128) -> date - # - # Returns a new \Date object with values parsed from +string+. - # - # If +comp+ is +true+ and the given year is in the range (0..99), - # the current century is supplied; otherwise, the year is taken as given. - # - # See argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. - # See argument {limit}[rdoc-ref:Date@Argument+limit]. - # - # Related: Date._parse (returns a hash). - def parse(string = JULIAN_EPOCH_DATE, comp = true, start = DEFAULT_SG, limit: 128) - hash = _parse(string, comp, limit: limit) - new_by_frags(hash, start) - end - - # call-seq: - # Date._parse(string, comp = true, limit: 128) -> hash - # - # Returns a hash of values parsed from +string+. - # - # If +comp+ is +true+ and the given year is in the range (0..99), - # the current century is supplied; otherwise, the year is taken as given. - # - # See argument {limit}[rdoc-ref:Date@Argument+limit]. - # - # Related: Date.parse (returns a \Date object). - def _parse(string, comp = true, limit: 128) - string = string_value(string) - str = string.strip - # Check limit - if limit && str.length > limit - raise ArgumentError, "string length (#{str.length}) exceeds the limit #{limit}" - end - - date__parse(str, comp) - end + # ------------------------------------------------------------------ + # _rfc3339 + # ------------------------------------------------------------------ # call-seq: - # Date._iso8601(string, limit: 128) -> hash + # Date._rfc3339(string, limit: 128) -> hash # - # Returns a hash of values parsed from +string+, which should contain - # an {ISO 8601 formatted date}[rdoc-ref:language/strftime_formatting.rdoc@ISO+8601+Format+Specifications]: + # Returns a hash of values parsed from +string+, which should be a valid + # {RFC 3339 format}[rdoc-ref:language/strftime_formatting.rdoc@RFC+3339+Format]: # # d = Date.new(2001, 2, 3) - # s = d.iso8601 # => "2001-02-03" - # Date._iso8601(s) # => {:mday=>3, :year=>2001, :mon=>2} + # s = d.rfc3339 # => "2001-02-03T00:00:00+00:00" + # Date._rfc3339(s) + # # => {:year=>2001, :mon=>2, :mday=>3, :hour=>0, :min=>0, :sec=>0, :zone=>"+00:00", :offset=>0} # # See argument {limit}[rdoc-ref:Date@Argument+limit]. # - # Related: Date.iso8601 (returns a \Date object). - def _iso8601(string, limit: 128) - return {} if string.nil? - string = string_value(string) - check_string_limit(string, limit) - - date__iso8601(string) - end - - # date__rfc3339 in date_parse.c + # Related: Date.rfc3339 (returns a \Date object). def _rfc3339(string, limit: 128) - return {} if string.nil? - string = string_value(string) - check_string_limit(string, limit) - - date__rfc3339(string) - end - - # date__xmlschema in date_parse.c - def _xmlschema(string, limit: 128) - return {} if string.nil? - string = string_value(string) - check_string_limit(string, limit) + unless String === string + raise TypeError if string.is_a?(Symbol) + return {} if string.nil? + string = string.to_str + end + return {} if string.empty? + raise ArgumentError, "string length (#{string.length}) exceeds the limit #{limit}" if limit && string.length > limit + + # Fast path: YYYY-MM-DDTHH:MM:SS+HH:MM (25 bytes) or YYYY-MM-DDTHH:MM:SSZ (20 bytes) + len = string.length + if len == 25 || len == 20 + b0 = string.getbyte(0) + if b0 >= 48 && b0 <= 57 && + string.getbyte(4) == 45 && string.getbyte(7) == 45 && + (string.getbyte(10) | 32) == 116 && # T or t + string.getbyte(13) == 58 && string.getbyte(16) == 58 + b1 = string.getbyte(1) + b2 = string.getbyte(2) + b3 = string.getbyte(3) + b5 = string.getbyte(5) + b6 = string.getbyte(6) + b8 = string.getbyte(8) + b9 = string.getbyte(9) + b11 = string.getbyte(11) + b12 = string.getbyte(12) + b14 = string.getbyte(14) + b15 = string.getbyte(15) + b17 = string.getbyte(17) + b18 = string.getbyte(18) + if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && + b5 >= 48 && b5 <= 57 && b6 >= 48 && b6 <= 57 && + b8 >= 48 && b8 <= 57 && b9 >= 48 && b9 <= 57 && + b11 >= 48 && b11 <= 57 && b12 >= 48 && b12 <= 57 && + b14 >= 48 && b14 <= 57 && b15 >= 48 && b15 <= 57 && + b17 >= 48 && b17 <= 57 && b18 >= 48 && b18 <= 57 + h = { + year: (b0 - 48) * 1000 + (b1 - 48) * 100 + (b2 - 48) * 10 + (b3 - 48), + mon: (b5 - 48) * 10 + (b6 - 48), + mday: (b8 - 48) * 10 + (b9 - 48), + hour: (b11 - 48) * 10 + (b12 - 48), + min: (b14 - 48) * 10 + (b15 - 48), + sec: (b17 - 48) * 10 + (b18 - 48) + } + b19 = string.getbyte(19) + if (b19 == 90 || b19 == 122) && len == 20 # Z or z + h[:zone] = string[19, 1] + h[:offset] = 0 + elsif (b19 == 43 || b19 == 45) && len == 25 && string.getbyte(22) == 58 + zone = string[19, 6] + h[:zone] = zone + b20 = string.getbyte(20) + b21 = string.getbyte(21) + b23 = string.getbyte(23) + b24 = string.getbyte(24) + if b20 >= 48 && b20 <= 57 && b21 >= 48 && b21 <= 57 && + b23 >= 48 && b23 <= 57 && b24 >= 48 && b24 <= 57 + h[:offset] = (b19 == 45 ? -1 : 1) * ((b20 - 48) * 36000 + (b21 - 48) * 3600 + (b23 - 48) * 600 + (b24 - 48) * 60) + return h + end + end + return h if h.key?(:zone) + end + end + end - date__xmlschema(string) + h = {} + if (m = RFC3339_RE.match(string)) + h[:year] = m[1].to_i + s = m[2] + h[:mon] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + s = m[3] + h[:mday] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + s = m[4] + h[:hour] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + s = m[5] + h[:min] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + s = m[6] + h[:sec] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:sec_fraction] = Rational(m[7].to_i, 10 ** m[7].length) if m[7] + zone = m[8] + h[:zone] = zone + b0 = zone.getbyte(0) + if b0 == 90 || b0 == 122 # Z or z + h[:offset] = 0 + else + h[:offset] = (b0 == 45 ? -1 : 1) * ((zone.getbyte(1) - 48) * 36000 + (zone.getbyte(2) - 48) * 3600 + (zone.getbyte(4) - 48) * 600 + (zone.getbyte(5) - 48) * 60) + end + end + h end - # date__rfc2822 in date_parse.c - def _rfc2822(string, limit: 128) - return {} if string.nil? - string = string_value(string) - check_string_limit(string, limit) - - date__rfc2822(string) - end - alias _rfc822 _rfc2822 + # ------------------------------------------------------------------ + # _httpdate + # ------------------------------------------------------------------ # call-seq: # Date._httpdate(string, limit: 128) -> hash @@ -108,2497 +132,1572 @@ def _rfc2822(string, limit: 128) # # Related: Date.httpdate (returns a \Date object). def _httpdate(string, limit: 128) - return {} if string.nil? - string = string_value(string) - check_string_limit(string, limit) + unless String === string + raise TypeError if string.is_a?(Symbol) + return {} if string.nil? + string = string.to_str + end + return {} if string.empty? + raise ArgumentError, "string length (#{string.length}) exceeds the limit #{limit}" if limit && string.length > limit + + # Byte-level fast path for Type 1: "Dow, DD Mon YYYY HH:MM:SS GMT" (29 bytes) + # Avoids all regex and string allocation overhead + len = string.length + if len == 29 + b0 = string.getbyte(0) + if b0 >= 65 && string.getbyte(3) == 44 && string.getbyte(4) == 32 && # alpha, ',', ' ' + string.getbyte(7) == 32 && string.getbyte(11) == 32 && + string.getbyte(16) == 32 && string.getbyte(19) == 58 && + string.getbyte(22) == 58 && string.getbyte(25) == 32 && + string.getbyte(26) == 71 && string.getbyte(27) == 77 && string.getbyte(28) == 84 # 'G','M','T' + wkey = ((b0 | 32) << 16) | ((string.getbyte(1) | 32) << 8) | (string.getbyte(2) | 32) + wday_info = ABBR_DAY_3KEY[wkey] + if wday_info + mkey = ((string.getbyte(8) | 32) << 16) | ((string.getbyte(9) | 32) << 8) | (string.getbyte(10) | 32) + mon_info = ABBR_MONTH_3KEY[mkey] + if mon_info + return { + wday: wday_info[0], + mday: (string.getbyte(5) - 48) * 10 + (string.getbyte(6) - 48), + mon: mon_info[0], + year: (string.getbyte(12) - 48) * 1000 + (string.getbyte(13) - 48) * 100 + (string.getbyte(14) - 48) * 10 + (string.getbyte(15) - 48), + hour: (string.getbyte(17) - 48) * 10 + (string.getbyte(18) - 48), + min: (string.getbyte(20) - 48) * 10 + (string.getbyte(21) - 48), + sec: (string.getbyte(23) - 48) * 10 + (string.getbyte(24) - 48), + zone: 'GMT', offset: 0 + } + end + end + end + end - date__httpdate(string) - end + h = {} + if (m = HTTPDATE_TYPE1_RE.match(string)) + h[:wday] = HTTPDATE_WDAY[m[1].downcase] + s = m[2] + h[:mday] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:mon] = ABBR_MONTH_NUM[m[3].downcase] + h[:year] = m[4].to_i + s = m[5] + h[:hour] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + s = m[6] + h[:min] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + s = m[7] + h[:sec] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:zone] = m[8] + h[:offset] = 0 + elsif (m = HTTPDATE_TYPE2_RE.match(string)) + h[:wday] = HTTPDATE_FULL_WDAY[m[1].downcase] + s = m[2] + h[:mday] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:mon] = ABBR_MONTH_NUM[m[3].downcase] + y = m[4].to_i + h[:year] = y >= 69 ? y + 1900 : y + 2000 + s = m[5] + h[:hour] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + s = m[6] + h[:min] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + s = m[7] + h[:sec] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:zone] = m[8] + h[:offset] = 0 + elsif (m = HTTPDATE_TYPE3_RE.match(string)) + h[:wday] = HTTPDATE_WDAY[m[1].downcase] + h[:mon] = ABBR_MONTH_NUM[m[2].downcase] + h[:mday] = m[3].to_i + s = m[4] + h[:hour] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + s = m[5] + h[:min] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + s = m[6] + h[:sec] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:year] = m[7].to_i + end + h + end + + # ------------------------------------------------------------------ + # _rfc2822 + # ------------------------------------------------------------------ # call-seq: - # Date._jisx0301(string, limit: 128) -> hash + # Date._rfc2822(string, limit: 128) -> hash # # Returns a hash of values parsed from +string+, which should be a valid - # {JIS X 0301 date format}[rdoc-ref:language/strftime_formatting.rdoc@JIS+X+0301+Format]: + # {RFC 2822 date format}[rdoc-ref:language/strftime_formatting.rdoc@RFC+2822+Format]: # # d = Date.new(2001, 2, 3) - # s = d.jisx0301 # => "H13.02.03" - # Date._jisx0301(s) # => {:year=>2001, :mon=>2, :mday=>3} + # s = d.rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000" + # Date._rfc2822(s) + # # => {:wday=>6, :mday=>3, :mon=>2, :year=>2001, :hour=>0, :min=>0, :sec=>0, :zone=>"+0000", :offset=>0} # # See argument {limit}[rdoc-ref:Date@Argument+limit]. # - # Related: Date.jisx0301 (returns a \Date object). - def _jisx0301(string, limit: 128) - return {} if string.nil? - string = string_value(string) - check_string_limit(string, limit) - - date__jisx0301(string) - end - - # --- Constructor methods --- - - def iso8601(string = JULIAN_EPOCH_DATE, start = DEFAULT_SG, limit: 128) - hash = _iso8601(string, limit: limit) - - new_by_frags(hash, start) - end - - def rfc3339(string = JULIAN_EPOCH_DATETIME, start = DEFAULT_SG, limit: 128) - hash = _rfc3339(string, limit: limit) - - new_by_frags(hash, start) - end - - def xmlschema(string = JULIAN_EPOCH_DATE, start = DEFAULT_SG, limit: 128) - hash = _xmlschema(string, limit: limit) - - new_by_frags(hash, start) - end - - def rfc2822(string = JULIAN_EPOCH_DATETIME_RFC2822, start = DEFAULT_SG, limit: 128) - hash = _rfc2822(string, limit: limit) - - new_by_frags(hash, start) - end - alias rfc822 rfc2822 - - def httpdate(string = JULIAN_EPOCH_DATETIME_HTTPDATE, start = DEFAULT_SG, limit: 128) - hash = _httpdate(string, limit: limit) - - new_by_frags(hash, start) - end - - def jisx0301(string = JULIAN_EPOCH_DATE, start = DEFAULT_SG, limit: 128) - hash = _jisx0301(string, limit: limit) - - new_by_frags(hash, start) - end - - private - - def date__parse(str, comp) - hash = {} - - # Preprocessing: duplicate and replace non-allowed characters. - # Non-TIGHT: Replace [^-+',./:@[:alnum:]\[\]]+ with a single space - str = str.dup.gsub(%r{[^-+',./:@[:alnum:]\[\]]+}, ' ') - - hash[:_comp] = comp - - # Parser invocation (non-TIGHT order) - # Note: C's HAVE_ELEM_P calls check_class(str) every time because - # str is modified by subx after each successful parse. - - # parse_day and parse_time always run (no goto ok). - if have_elem_p?(str, HAVE_ALPHA) - parse_day(str, hash) - end - - if have_elem_p?(str, HAVE_DIGIT) - parse_time(str, hash) - end - - # Date parsers: first success skips the rest (C's "goto ok"). - # In C, all paths converge at ok: for post-processing. - catch(:date_parsed) do - if have_elem_p?(str, HAVE_ALPHA | HAVE_DIGIT) - throw :date_parsed if parse_eu(str, hash) - throw :date_parsed if parse_us(str, hash) - end - - if have_elem_p?(str, HAVE_DIGIT | HAVE_DASH) - throw :date_parsed if parse_iso(str, hash) - end - - if have_elem_p?(str, HAVE_DIGIT | HAVE_DOT) - throw :date_parsed if parse_jis(str, hash) - end - - if have_elem_p?(str, HAVE_ALPHA | HAVE_DIGIT | HAVE_DASH) - throw :date_parsed if parse_vms(str, hash) - end - - if have_elem_p?(str, HAVE_DIGIT | HAVE_SLASH) - throw :date_parsed if parse_sla(str, hash) - end - - if have_elem_p?(str, HAVE_DIGIT | HAVE_DOT) - throw :date_parsed if parse_dot(str, hash) - end - - if have_elem_p?(str, HAVE_DIGIT) - throw :date_parsed if parse_iso2(str, hash) + # Related: Date.rfc2822 (returns a \Date object). + def _rfc2822(string, limit: 128) + unless String === string + raise TypeError if string.is_a?(Symbol) + return {} if string.nil? + string = string.to_str + end + return {} if string.empty? + raise ArgumentError, "string length (#{string.length}) exceeds the limit #{limit}" if limit && string.length > limit + + # Byte-level fast path: "Dow, DD Mon YYYY HH:MM:SS +ZZZZ" (31 bytes, 2-digit day) + # Avoids all regex and string allocation overhead + len = string.length + if len == 31 + b0 = string.getbyte(0) + if b0 >= 65 && string.getbyte(3) == 44 && string.getbyte(4) == 32 && # alpha, ',', ' ' + string.getbyte(7) == 32 && string.getbyte(11) == 32 && + string.getbyte(16) == 32 && string.getbyte(19) == 58 && + string.getbyte(22) == 58 && string.getbyte(25) == 32 + bz0 = string.getbyte(26) + if bz0 == 43 || bz0 == 45 # '+' or '-' + wkey = ((b0 | 32) << 16) | ((string.getbyte(1) | 32) << 8) | (string.getbyte(2) | 32) + wday_info = ABBR_DAY_3KEY[wkey] + if wday_info + mkey = ((string.getbyte(8) | 32) << 16) | ((string.getbyte(9) | 32) << 8) | (string.getbyte(10) | 32) + mon_info = ABBR_MONTH_3KEY[mkey] + if mon_info + bz1 = string.getbyte(27) + bz2 = string.getbyte(28) + bz3 = string.getbyte(29) + bz4 = string.getbyte(30) + sign = bz0 == 45 ? -1 : 1 + offset_val = sign * ((bz1 - 48) * 36000 + (bz2 - 48) * 3600 + (bz3 - 48) * 600 + (bz4 - 48) * 60) + zone = (bz0 == 43 && bz1 == 48 && bz2 == 48 && bz3 == 48 && bz4 == 48) ? '+0000' : string.byteslice(26, 5) + return { + wday: wday_info[0], + mday: (string.getbyte(5) - 48) * 10 + (string.getbyte(6) - 48), + mon: mon_info[0], + year: (string.getbyte(12) - 48) * 1000 + (string.getbyte(13) - 48) * 100 + (string.getbyte(14) - 48) * 10 + (string.getbyte(15) - 48), + hour: (string.getbyte(17) - 48) * 10 + (string.getbyte(18) - 48), + min: (string.getbyte(20) - 48) * 10 + (string.getbyte(21) - 48), + sec: (string.getbyte(23) - 48) * 10 + (string.getbyte(24) - 48), + zone: zone, offset: offset_val + } + end + end + end end + end - if have_elem_p?(str, HAVE_DIGIT) - throw :date_parsed if parse_year(str, hash) + # Preprocess: remove obs-FWS (\r\n and \0) - skip if not needed + s = (string.include?("\r") || string.include?("\n") || string.include?("\0")) ? + string.gsub(/[\r\n\0]+/, ' ') : string + h = {} + if (m = RFC2822_RE.match(s)) + h[:wday] = HTTPDATE_WDAY[m[1].downcase] if m[1] + h[:mday] = m[2].to_i + h[:mon] = ABBR_MONTH_NUM[m[3].downcase] + y_s = m[4] + y = y_s.to_i + ylen = y_s.getbyte(0) == 45 ? y_s.length - 1 : y_s.length + if ylen < 4 + if ylen == 3 + h[:year] = y + 1900 + else + h[:year] = y >= 50 ? y + 1900 : y + 2000 + end + else + h[:year] = y end - - if have_elem_p?(str, HAVE_ALPHA) - throw :date_parsed if parse_mon(str, hash) + s5 = m[5] + h[:hour] = (s5.getbyte(0) - 48) * 10 + (s5.getbyte(1) - 48) + s6 = m[6] + h[:min] = (s6.getbyte(0) - 48) * 10 + (s6.getbyte(1) - 48) + if m[7] + s7 = m[7] + h[:sec] = (s7.getbyte(0) - 48) * 10 + (s7.getbyte(1) - 48) end + h[:zone] = m[8] + h[:offset] = fast_zone_offset(m[8]) + end + h + end + alias _rfc822 _rfc2822 - if have_elem_p?(str, HAVE_DIGIT) - throw :date_parsed if parse_mday(str, hash) - end + # ------------------------------------------------------------------ + # _xmlschema + # ------------------------------------------------------------------ - if have_elem_p?(str, HAVE_DIGIT) - throw :date_parsed if parse_ddd(str, hash) + # call-seq: + # Date._xmlschema(string, limit: 128) -> hash + # + # Returns a hash of values parsed from +string+, which should be a valid + # XML date format: + # + # d = Date.new(2001, 2, 3) + # s = d.xmlschema # => "2001-02-03" + # Date._xmlschema(s) # => {:year=>2001, :mon=>2, :mday=>3} + # + # See argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date.xmlschema (returns a \Date object). + def _xmlschema(string, limit: 128) + unless String === string + raise TypeError if string.is_a?(Symbol) + return {} if string.nil? + string = string.to_str + end + return {} if string.empty? + raise ArgumentError, "string length (#{string.length}) exceeds the limit #{limit}" if limit && string.length > limit + + # Fast path: YYYY-MM-DD (exactly 10 bytes, all ASCII) + if string.length == 10 + b0 = string.getbyte(0) + if b0 >= 48 && b0 <= 57 + b1 = string.getbyte(1) + b2 = string.getbyte(2) + b3 = string.getbyte(3) + if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && + string.getbyte(4) == 45 && string.getbyte(7) == 45 + b5 = string.getbyte(5) + b6 = string.getbyte(6) + b8 = string.getbyte(8) + b9 = string.getbyte(9) + if b5 >= 48 && b5 <= 57 && b6 >= 48 && b6 <= 57 && + b8 >= 48 && b8 <= 57 && b9 >= 48 && b9 <= 57 + return { + year: (b0 - 48) * 1000 + (b1 - 48) * 100 + (b2 - 48) * 10 + (b3 - 48), + mon: (b5 - 48) * 10 + (b6 - 48), + mday: (b8 - 48) * 10 + (b9 - 48) + } + end + end end end - # ok: (post-processing — always runs, matching C's ok: label) - if have_elem_p?(str, HAVE_ALPHA) - parse_bc(str, hash) - end - if have_elem_p?(str, HAVE_DIGIT) - parse_frag(str, hash) + h = {} + if (m = XMLSCHEMA_DATETIME_RE.match(string)) + h[:year] = m[1].to_i + h[:mon] = m[2].to_i if m[2] + h[:mday] = m[3].to_i if m[3] + h[:hour] = m[4].to_i if m[4] + h[:min] = m[5].to_i if m[5] + h[:sec] = m[6].to_i if m[6] + h[:sec_fraction] = parse_sec_fraction(m[7]) if m[7] + parse_zone_and_offset(m[8], h) if m[8] + elsif (m = XMLSCHEMA_TIME_RE.match(string)) + h[:hour] = m[1].to_i + h[:min] = m[2].to_i + h[:sec] = m[3].to_i + h[:sec_fraction] = parse_sec_fraction(m[4]) if m[4] + parse_zone_and_offset(m[5], h) if m[5] + elsif (m = XMLSCHEMA_TRUNC_RE.match(string)) + if m[3] + h[:mday] = m[3].to_i + else + h[:mon] = m[1].to_i if m[1] + h[:mday] = m[2].to_i if m[2] + end + parse_zone_and_offset(m[4], h) if m[4] end - - apply_comp(hash) - hash - end - - # asctime format with timezone: Sat Aug 28 02:29:34 JST 1999 - def parse_asctime_with_zone(str, hash) - return false unless str =~ /\b(sun|mon|tue|wed|thu|fri|sat)[[:space:]]+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)[[:space:]]+(\d{1,2})[[:space:]]+(\d{2}):(\d{2}):(\d{2})[[:space:]]+(.*?)[[:space:]]+(-?\d+)[[:space:]]*$/i - - wday_str = $1 - mon_str = $2 - mday_str = $3 - hour_str = $4 - min_str = $5 - sec_str = $6 - zone_part = $7 - year_str = $8 - - hash[:wday] = day_num(wday_str) - hash[:mon] = mon_num(mon_str) - hash[:mday] = mday_str.to_i - hash[:hour] = hour_str.to_i - hash[:min] = min_str.to_i - hash[:sec] = sec_str.to_i - - zone_part = zone_part.strip - unless zone_part.empty? - zone = zone_part.gsub(/\s+/, ' ') - hash[:zone] = zone - hash[:offset] = parse_zone_offset(zone) - end - - hash[:_year_str] = year_str - hash[:year] = year_str.to_i - apply_comp(hash) - - true + h end - # asctime format without timezone: Sat Aug 28 02:55:50 1999 - def parse_asctime(str, hash) - return false unless str =~ /\b(sun|mon|tue|wed|thu|fri|sat)\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\s+(\d{1,2})\s+(\d{2}):(\d{2}):(\d{2})\s+(-?\d+)\s*$/i - - wday_str = $1 - mon_str = $2 - mday_str = $3 - hour_str = $4 - min_str = $5 - sec_str = $6 - year_str = $7 - - hash[:wday] = day_num(wday_str) - hash[:mon] = mon_num(mon_str) - hash[:mday] = mday_str.to_i - hash[:hour] = hour_str.to_i - hash[:min] = min_str.to_i - hash[:sec] = sec_str.to_i - hash[:_year_str] = year_str - hash[:year] = year_str.to_i - apply_comp(hash) - - true - end - - # HTTP date type 1: "Sat, 03 Feb 2001 00:00:00 GMT" - def httpdate_type1(str, hash) - pattern = /\A\s*(#{ABBR_DAYS_PATTERN})\s*,\s+ - (\d{2})\s+ - (#{ABBR_MONTHS_PATTERN})\s+ - (-?\d{4})\s+ - (\d{2}):(\d{2}):(\d{2})\s+ - (gmt)\s*\z/ix - - match = pattern.match(str) - return false unless match - - hash[:wday] = day_num(match[1]) - hash[:mday] = match[2].to_i - hash[:mon] = mon_num(match[3]) - hash[:year] = match[4].to_i - hash[:hour] = match[5].to_i - hash[:min] = match[6].to_i - hash[:sec] = match[7].to_i - hash[:zone] = match[8] - hash[:offset] = 0 - - true - end + # ------------------------------------------------------------------ + # _iso8601 + # ------------------------------------------------------------------ - # HTTP date type 2: "Saturday, 03-Feb-01 00:00:00 GMT" - def httpdate_type2(str, hash) - pattern = /\A\s*(#{DAYS_PATTERN})\s*,\s+ - (\d{2})\s*-\s* - (#{ABBR_MONTHS_PATTERN})\s*-\s* - (\d{2})\s+ - (\d{2}):(\d{2}):(\d{2})\s+ - (gmt)\s*\z/ix - - match = pattern.match(str) - return false unless match - - hash[:wday] = day_num(match[1]) - hash[:mday] = match[2].to_i - hash[:mon] = mon_num(match[3]) - - # Year completion for 2-digit year - year = match[4].to_i - year = comp_year69(year) if year >= 0 && year <= 99 - hash[:year] = year - - hash[:hour] = match[5].to_i - hash[:min] = match[6].to_i - hash[:sec] = match[7].to_i - hash[:zone] = match[8] - hash[:offset] = 0 - - true - end - - # HTTP date type 3: "Sat Feb 3 00:00:00 2001" - def httpdate_type3(str, hash) - pattern = /\A\s*(#{ABBR_DAYS_PATTERN})\s+ - (#{ABBR_MONTHS_PATTERN})\s+ - (\d{1,2})\s+ - (\d{2}):(\d{2}):(\d{2})\s+ - (\d{4})\s*\z/ix - - match = pattern.match(str) - return false unless match - - hash[:wday] = day_num(match[1]) - hash[:mon] = mon_num(match[2]) - hash[:mday] = match[3].to_i - hash[:hour] = match[4].to_i - hash[:min] = match[5].to_i - hash[:sec] = match[6].to_i - hash[:year] = match[7].to_i - - true - end - - # parse_day in date_parse.c. - # Non-TIGHT pattern: \b(sun|mon|tue|wed|thu|fri|sat)[^-/\d\s]* - # The [^-/\d\s]* part consumes trailing characters (e.g., "urday" - # in "Saturday") so they get replaced by subx, but only the - # abbreviation in $1 is used. - def parse_day(str, hash) - m = subx(str, PARSE_DAY_PAT) - return false unless m - - hash[:wday] = day_num(m[1]) - - true - end - - # parse_time in date_parse.c. - # Uses subx to replace the matched time portion with " " so - # subsequent parsers (parse_us, etc.) won't re-match it. - def parse_time(str, hash) - m = subx(str, TIME_PAT) - return false unless m - - time_str = m[1] - zone_str = m[2] + # call-seq: + # Date._iso8601(string, limit: 128) -> hash + # + # Returns a hash of values parsed from +string+, which should contain + # an {ISO 8601 formatted date}[rdoc-ref:language/strftime_formatting.rdoc@ISO+8601+Format+Specifications]: + # + # d = Date.new(2001, 2, 3) + # s = d.iso8601 # => "2001-02-03" + # Date._iso8601(s) # => {:mday=>3, :year=>2001, :mon=>2} + # + # See argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date.iso8601 (returns a \Date object). + def _iso8601(string, limit: 128) + unless String === string + raise TypeError if string.is_a?(Symbol) + return {} if string.nil? + string = string.to_str + end + return {} if string.empty? + raise ArgumentError, "string length (#{string.length}) exceeds the limit #{limit}" if limit && string.length > limit + + # Fast path: YYYY-MM-DD (exactly 10 bytes, all ASCII) + if string.length == 10 + b0 = string.getbyte(0) + if b0 >= 48 && b0 <= 57 + b1 = string.getbyte(1) + b2 = string.getbyte(2) + b3 = string.getbyte(3) + if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && + string.getbyte(4) == 45 && string.getbyte(7) == 45 + b5 = string.getbyte(5) + b6 = string.getbyte(6) + b8 = string.getbyte(8) + b9 = string.getbyte(9) + if b5 >= 48 && b5 <= 57 && b6 >= 48 && b6 <= 57 && + b8 >= 48 && b8 <= 57 && b9 >= 48 && b9 <= 57 + return { + mday: (b8 - 48) * 10 + (b9 - 48), + year: (b0 - 48) * 1000 + (b1 - 48) * 100 + (b2 - 48) * 10 + (b3 - 48), + mon: (b5 - 48) * 10 + (b6 - 48) + } + end + end + end + end - parse_time_detail(time_str, hash) + h = {} - if zone_str && !zone_str.empty? - hash[:zone] = zone_str - hash[:offset] = date_zone_to_diff(zone_str) + if (m = ISO8601_EXT_DATETIME_RE.match(string)) + iso8601_ext_datetime(m, h) + elsif (m = ISO8601_BAS_DATETIME_RE.match(string)) + iso8601_bas_datetime(m, h) + elsif (m = ISO8601_EXT_TIME_RE.match(string)) + h[:hour] = m[1].to_i + h[:min] = m[2].to_i + h[:sec] = m[3].to_i if m[3] + h[:sec_fraction] = parse_sec_fraction(m[4]) if m[4] + parse_zone_and_offset(m[5], h) if m[5] + elsif (m = ISO8601_BAS_TIME_RE.match(string)) + h[:hour] = m[1].to_i + h[:min] = m[2].to_i + h[:sec] = m[3].to_i if m[3] + h[:sec_fraction] = parse_sec_fraction(m[4]) if m[4] + parse_zone_and_offset(m[5], h) if m[5] end - - true + h end - # parse_ddd in date_parse.c. - def parse_ddd(str, hash) - m = subx(str, PARSE_DDD_PAT) - return false unless m - - sign = m[1] - digits = m[2] - time_digits = m[3] - fraction = m[4] - zone = m[5] + # ------------------------------------------------------------------ + # _jisx0301 + # ------------------------------------------------------------------ - l = digits.length - - # Branches based on the length of the main number string. - case l - when 2 - if time_digits.nil? && !fraction.nil? - hash[:sec] = digits[-2, 2].to_i - else - hash[:mday] = digits[0, 2].to_i - end - when 4 - if time_digits.nil? && !fraction.nil? - hash[:sec] = digits[-2, 2].to_i - hash[:min] = digits[-4, 2].to_i - else - hash[:mon] = digits[0, 2].to_i - hash[:mday] = digits[2, 2].to_i - end - when 6 - if time_digits.nil? && !fraction.nil? - hash[:sec] = digits[-2, 2].to_i - hash[:min] = digits[-4, 2].to_i - hash[:hour] = digits[-6, 2].to_i - else - y = digits[0, 2].to_i - y = -y if sign == '-' - hash[:year] = y - hash[:mon] = digits[2, 2].to_i - hash[:mday] = digits[4, 2].to_i - hash[:_year_str] = digits[0, 2] # year completion - end - when 8, 10, 12, 14 - if time_digits.nil? && !fraction.nil? - # Interpreted as time - hash[:sec] = digits[-2, 2].to_i - hash[:min] = digits[-4, 2].to_i - hash[:hour] = digits[-6, 2].to_i - hash[:mday] = digits[-8, 2].to_i - hash[:mon] = digits[-10, 2].to_i if l >= 10 - if l == 12 - y = digits[-12, 2].to_i - y = -y if sign == '-' - hash[:year] = y - hash[:_year_str] = digits[-12, 2] - elsif l == 14 - y = digits[-14, 4].to_i - y = -y if sign == '-' - hash[:year] = y - hash[:_comp] = false + # call-seq: + # Date._jisx0301(string, limit: 128) -> hash + # + # Returns a hash of values parsed from +string+, which should be a valid + # {JIS X 0301 date format}[rdoc-ref:language/strftime_formatting.rdoc@JIS+X+0301+Format]: + # + # d = Date.new(2001, 2, 3) + # s = d.jisx0301 # => "H13.02.03" + # Date._jisx0301(s) # => {:year=>2001, :mon=>2, :mday=>3} + # + # See argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date.jisx0301 (returns a \Date object). + def _jisx0301(string, limit: 128) + unless String === string + raise TypeError if string.is_a?(Symbol) + return {} if string.nil? + string = string.to_str + end + return {} if string.empty? + raise ArgumentError, "string length (#{string.length}) exceeds the limit #{limit}" if limit && string.length > limit + + # Fast path: X##.##.## (9 bytes: era + YY.MM.DD) + if string.length == 9 + b0 = string.getbyte(0) | 32 # downcase + era_offset = JISX0301_ERA[b0.chr] + if era_offset && + string.getbyte(3) == 46 && string.getbyte(6) == 46 # '.' + b1 = string.getbyte(1) + b2 = string.getbyte(2) + b4 = string.getbyte(4) + b5 = string.getbyte(5) + b7 = string.getbyte(7) + b8 = string.getbyte(8) + if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && + b4 >= 48 && b4 <= 57 && b5 >= 48 && b5 <= 57 && + b7 >= 48 && b7 <= 57 && b8 >= 48 && b8 <= 57 + return { + year: (b1 - 48) * 10 + (b2 - 48) + era_offset, + mon: (b4 - 48) * 10 + (b5 - 48), + mday: (b7 - 48) * 10 + (b8 - 48) + } end - else - # Interpret as date - y = digits[0, 4].to_i - y = -y if sign == '-' - hash[:year] = y - hash[:mon] = digits[4, 2].to_i - hash[:mday] = digits[6, 2].to_i - hash[:hour] = digits[8, 2].to_i if l >= 10 - hash[:min] = digits[10, 2].to_i if l >= 12 - hash[:sec] = digits[12, 2].to_i if l >= 14 - hash[:_comp] = false - end - when 3 - if time_digits.nil? && !fraction.nil? - hash[:sec] = digits[-2, 2].to_i - hash[:min] = digits[-3, 1].to_i - else - hash[:yday] = digits[0, 3].to_i - end - when 5 - if time_digits.nil? && !fraction.nil? - hash[:sec] = digits[-2, 2].to_i - hash[:min] = digits[-4, 2].to_i - hash[:hour] = digits[-5, 1].to_i - else - y = digits[0, 2].to_i - y = -y if sign == '-' - hash[:year] = y - hash[:yday] = digits[2, 3].to_i - hash[:_year_str] = digits[0, 2] - end - when 7 - if time_digits.nil? && !fraction.nil? - hash[:sec] = digits[-2, 2].to_i - hash[:min] = digits[-4, 2].to_i - hash[:hour] = digits[-6, 2].to_i - hash[:mday] = digits[-7, 1].to_i - else - y = digits[0, 4].to_i - y = -y if sign == '-' - hash[:year] = y - hash[:yday] = digits[4, 3].to_i - # No need to complete because it is a 4-digit year end end - # Processing time portion - if time_digits && !time_digits.empty? - tl = time_digits.length - if !fraction.nil? - # Interpreted as time - case tl - when 2, 4, 6 - hash[:sec] = time_digits[-2, 2].to_i - hash[:min] = time_digits[-4, 2].to_i if tl >= 4 - hash[:hour] = time_digits[-6, 2].to_i if tl >= 6 - end - else - # Interpreted as time - case tl - when 2, 4, 6 - hash[:hour] = time_digits[0, 2].to_i - hash[:min] = time_digits[2, 2].to_i if tl >= 4 - hash[:sec] = time_digits[4, 2].to_i if tl >= 6 - end - end + h = {} + if (m = JISX0301_RE.match(string)) + era_char = m[1] ? m[1].downcase : 'h' + era_offset = JISX0301_ERA[era_char] + h[:year] = m[2].to_i + era_offset + h[:mon] = m[3].to_i + h[:mday] = m[4].to_i + h[:hour] = m[5].to_i if m[5] + h[:min] = m[6].to_i if m[6] + h[:sec] = m[7].to_i if m[7] + h[:sec_fraction] = parse_sec_fraction(m[8]) if m[8] && !m[8].empty? + parse_zone_and_offset(m[9], h) if m[9] + else + h = _iso8601(string, limit: limit) end + h + end - # Handling fractional seconds - if fraction && !fraction.empty? - hash[:sec_fraction] = Rational(fraction.to_i, 10 ** fraction.length) - end + # ------------------------------------------------------------------ + # _parse + # ------------------------------------------------------------------ - # Handling time zone - if zone && !zone.empty? - if zone[0] == '[' - # Bracket-enclosed zone: C's parse_ddd_cb special handling. - # Strip '[' and ']', then check for ':' separator. - inner = zone[1..-2] # content between [ and ] - colon_pos = inner.index(':') - if colon_pos - # e.g., "[-5:EST]" → zone_name="EST", offset_str="-5:" - # C: zone = part after ':', s5 = part from start to after ':' - zone_name = inner[(colon_pos + 1)..] - offset_str = inner[0, colon_pos + 1] # includes ':' - else - # e.g., "[-9]" → zone_name="-9", offset_str="-9" - # e.g., "[9]" → zone_name="9", offset_str="+9" (digit→prepend '+') - zone_name = inner - if inner[0] && inner[0] =~ /\d/ - offset_str = "+" + zone_name - else - offset_str = zone_name + # call-seq: + # Date._parse(string, comp = true, limit: 128) -> hash + # + # Note: + # This method recognizes many forms in +string+, + # but it is not a validator. + # For formats, see + # {"Specialized Format Strings" in Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc@Specialized+Format+Strings] + # + # If +string+ does not specify a valid date, + # the result is unpredictable; + # consider using Date._strptime instead. + # + # Returns a hash of values parsed from +string+: + # + # Date._parse('2001-02-03') # => {:year=>2001, :mon=>2, :mday=>3} + # + # If +comp+ is +true+ and the given year is in the range (0..99), + # the current century is supplied; + # otherwise, the year is taken as given: + # + # Date._parse('01-02-03', true) # => {:year=>2001, :mon=>2, :mday=>3} + # Date._parse('01-02-03', false) # => {:year=>1, :mon=>2, :mday=>3} + # + # See argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date.parse(returns a \Date object). + def _parse(string, comp = true, limit: 128) + unless String === string + raise TypeError, "no implicit conversion of #{string.class} into String" if string.is_a?(Symbol) || string.nil? + string = string.to_str + end + return {} if string.empty? + raise ArgumentError, "string length (#{string.length}) exceeds limit (#{limit})" if limit && string.length > limit + + # === Fast paths for common date formats === + len = string.length + + # Fast ISO: YYYY-MM-DD (exactly 10 ASCII bytes) + if len == 10 + b0 = string.getbyte(0) + if b0 >= 48 && b0 <= 57 + b1 = string.getbyte(1) + b2 = string.getbyte(2) + b3 = string.getbyte(3) + if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && + string.getbyte(4) == 45 && string.getbyte(7) == 45 + b5 = string.getbyte(5) + b6 = string.getbyte(6) + b8 = string.getbyte(8) + b9 = string.getbyte(9) + if b5 >= 48 && b5 <= 57 && b6 >= 48 && b6 <= 57 && + b8 >= 48 && b8 <= 57 && b9 >= 48 && b9 <= 57 + return { + year: (b0 - 48) * 1000 + (b1 - 48) * 100 + (b2 - 48) * 10 + (b3 - 48), + mon: (b5 - 48) * 10 + (b6 - 48), + mday: (b8 - 48) * 10 + (b9 - 48) + } end end - hash[:zone] = zone_name - hash[:offset] = date_zone_to_diff(offset_str) - else - # Non-bracket zone: just set zone. - # Offset will be resolved in apply_comp if not already set. - hash[:zone] = zone - hash[:offset] = date_zone_to_diff(zone) end end - true - end - - # Parse $1 (time string) further and set hash to hour/min/sec/sec_fraction. - # - # Internal pattern: - # $1 hour - # $2 min (colon format) - # $3 sec (colon format) - # $4 frac ([,.]\d*) - # $5 min (h format) - # $6 sec (h format) - # $7 am/pm (a or p) - def parse_time_detail(time_str, hash) - return unless time_str =~ TIME_DETAIL_PAT - - hour = $1.to_i - min_colon = $2 - sec_colon = $3 - frac = $4 # "[,.] number string" or nil - min_h = $5 - sec_h = $6 - ampm = $7 - - if min_colon - # Branch A: HH:MM[:SS[.frac]] - hash[:hour] = hour - hash[:min] = min_colon.to_i - if sec_colon - hash[:sec] = sec_colon.to_i - if frac && frac.length > 1 - # Since frac is a "[,.] number string", the first character (delimiter) is omitted. - frac_digits = frac[1..] - hash[:sec_fraction] = Rational(frac_digits.to_i, 10 ** frac_digits.length) + # Fast compact: YYYYMMDD (exactly 8 ASCII digit bytes) + if len == 8 + b0 = string.getbyte(0) + if b0 >= 48 && b0 <= 57 + b1 = string.getbyte(1) + b2 = string.getbyte(2) + b3 = string.getbyte(3) + b4 = string.getbyte(4) + b5 = string.getbyte(5) + b6 = string.getbyte(6) + b7 = string.getbyte(7) + if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && + b4 >= 48 && b4 <= 57 && b5 >= 48 && b5 <= 57 && + b6 >= 48 && b6 <= 57 && b7 >= 48 && b7 <= 57 + return { + year: (b0 - 48) * 1000 + (b1 - 48) * 100 + (b2 - 48) * 10 + (b3 - 48), + mon: (b4 - 48) * 10 + (b5 - 48), + mday: (b6 - 48) * 10 + (b7 - 48) + } end end - elsif min_h - # Branch B: HHh[MMm[SSs]](with min) - hash[:hour] = hour - hash[:min] = min_h.to_i - hash[:sec] = sec_h.to_i if sec_h - elsif time_str.match?(/h/i) - # Branch B: Only HHh (no min/sec) - hash[:hour] = hour - elsif ampm - # Branch C: Only AM/PM => Set only hour (converted to AM/PM below) - hash[:hour] = hour - end - - # AM/PM conversion - if ampm - h = hash[:hour] || hour - if ampm.downcase == 'p' && h != 12 - hash[:hour] = h + 12 - elsif ampm.downcase == 'a' && h == 12 - hash[:hour] = 0 - end end - end - # parse_era in date_parse.c. - def parse_era(str, hash) - if str =~ ERA1_PAT - hash[:bc] = false - return true + # Fast US: "Month DD, YYYY" + if (m = FAST_PARSE_US_RE.match(string)) + mon = ABBR_MONTH_NUM[m[1].downcase] + return {year: m[3].to_i, mon: mon, mday: m[2].to_i} if mon end - if str =~ ERA2_PAT - hash[:bc] = $1.downcase.delete('.') != 'ce' - return true + # Fast EU: "DD Month YYYY" + if (m = FAST_PARSE_EU_RE.match(string)) + mon = ABBR_MONTH_NUM[m[2].downcase] + return {year: m[3].to_i, mon: mon, mday: m[1].to_i} if mon end - false - end - - # parse_eu in date_parse.c. - def parse_eu(str, hash) - m = subx(str, PARSE_EU_PAT) - return false unless m - - mday_str = m[1] - mon_str = m[2] - era_str = m[3] - year_str = m[4] - - # Determine bc flag from era. - # AD/A.D./CE/C.E. => false, BC/B.C./BCE/B.C.E. => true - bc = if era_str - era_str.downcase.delete('.') !~ /\A(ad|ce)\z/ - else - false - end - - # Normalize y/m/d and set to hash in s3e. - # 'mon' is converted to an Integer using 'mon_num' and then passed. - s3e(hash, year_str, mon_num(mon_str), mday_str, bc) - - true - end - - # parse_us in date_parse.c. - def parse_us(str, hash) - m = subx(str, PARSE_US_PAT) - return false unless m - - mon_str = m[1] - mday_str = m[2] - era_str = m[3] - year_str = m[4] - - # Determine bc flag from era (same logic as parse_eu). - bc = if era_str - era_str.downcase.delete('.') !~ /\A(ad|ce)\z/ - else - false - end - - # Normalize y/m/d and set to hash using s3e. - # Difference from parse_eu: mon=$1, mday=$2 (only the $ numbers are swapped). - s3e(hash, year_str, mon_num(mon_str), mday_str, bc) - - true - end - - # parse_iso in date_parse.c - def parse_iso(str, hash) - m = subx(str, PARSE_ISO_PAT) - return false unless m - - # Normalize y/m/d and set to hash in s3e. - # bc is always false (there is no era symbol in ISO format). - s3e(hash, m[1], m[2], m[3], false) - - true - end - - # parse_iso2 in date_parse.c - def parse_iso2(str, hash) - return true if parse_iso21(str, hash) - return true if parse_iso22(str, hash) - return true if parse_iso23(str, hash) - return true if parse_iso24(str, hash) - return true if parse_iso25(str, hash) - return true if parse_iso26(str, hash) - - false - end - - def parse_iso21(str, hash) - m = subx(str, PARSE_ISO21_PAT) - return false unless m - - hash[:cwyear] = m[1].to_i if m[1] - hash[:cweek] = m[2].to_i - hash[:cwday] = m[3].to_i if m[3] - - true - end - - def parse_iso22(str, hash) - m = subx(str, PARSE_ISO22_PAT) - return false unless m - - hash[:cwday] = m[1].to_i - - true - end - - def parse_iso23(str, hash) - m = subx(str, PARSE_ISO23_PAT) - return false unless m - - hash[:mon] = m[1].to_i if m[1] - hash[:mday] = m[2].to_i - - true - end - - def parse_iso24(str, hash) - m = subx(str, PARSE_ISO24_PAT) - return false unless m - - hash[:mon] = m[1].to_i - hash[:mday] = m[2].to_i if m[2] - - true - end - - def parse_iso25(str, hash) - # Skip if exclude pattern matches (uses match, not subx). - return false if str =~ PARSE_ISO25_PAT0 - - m = subx(str, PARSE_ISO25_PAT) - return false unless m - - hash[:year] = m[1].to_i - hash[:yday] = m[2].to_i - - true - end - - def parse_iso26(str, hash) - # Skip if exclude pattern matches (uses match, not subx). - return false if str =~ PARSE_ISO26_PAT0 - - m = subx(str, PARSE_ISO26_PAT) - return false unless m - - hash[:yday] = m[1].to_i - - true - end - - # parse_jis in date_parse.c - def parse_jis(str, hash) - m = subx(str, PARSE_JIS_PAT) - return false unless m - - era = m[1].upcase - year = m[2].to_i - mon = m[3].to_i - mday = m[4].to_i - - # Convert the era symbol and year number to Gregorian calendar - # and set it to hash. - hash[:year] = gengo(era) + year - hash[:mon] = mon - hash[:mday] = mday - - true - end - - # parse_vms in date_parse.c - def parse_vms(str, hash) - return true if parse_vms11(str, hash) - return true if parse_vms12(str, hash) - - false - end - - def parse_vms11(str, hash) - m = subx(str, PARSE_VMS11_PAT) - return false unless m - - mday_str = m[1] - mon_str = m[2] - year_str = m[3] - - # Normalize y/m/d and set to hash in s3e. - s3e(hash, year_str, mon_num(mon_str), mday_str, false) - - true - end - - def parse_vms12(str, hash) - m = subx(str, PARSE_VMS12_PAT) - return false unless m - - mon_str = m[1] - mday_str = m[2] - year_str = m[3] - - # Normalize y/m/d and set to hash in s3e. - s3e(hash, year_str, mon_num(mon_str), mday_str, false) - - true - end - - # parse_sla in date_parse.c - def parse_sla(str, hash) - m = subx(str, PARSE_SLA_PAT) - return false unless m - - # Normalize y/m/d and set to hash in s3e. - # bc is always false. - s3e(hash, m[1], m[2], m[3], false) - - true - end - - # parse_dot in date_parse.c - def parse_dot(str, hash) - m = subx(str, PARSE_DOT_PAT) - return false unless m - - # Normalize y/m/d and set to hash in s3e. - # bc is always false. - s3e(hash, m[1], m[2], m[3], false) - - true - end - - # parse_year in date_parse.c - def parse_year(str, hash) - m = subx(str, PARSE_YEAR_PAT) - return false unless m - - hash[:year] = m[1].to_i - - true - end - - # parse_mon in date_parse.c - def parse_mon(str, hash) - m = subx(str, PARSE_MON_PAT) - return false unless m - - hash[:mon] = mon_num(m[1]) - - true - end - - # parse_mday in date_parse.c - def parse_mday(str, hash) - m = subx(str, PARSE_MDAY_PAT) - return false unless m - - hash[:mday] = m[1].to_i - - true - end - - # parse_bc in date_parse.c (non-TIGHT post-processing). - # Matches standalone BC/BCE/B.C./B.C.E. and sets _bc flag. - def parse_bc(str, hash) - m = subx(str, PARSE_BC_PAT) - return false unless m - - hash[:_bc] = true + # Fast RFC2822-like: "Dow, DD Mon YYYY HH:MM:SS +ZZZZ" + if (m = FAST_PARSE_RFC2822_RE.match(string)) + wday = ABBR_DAY_NUM[m[1].downcase] + mon = ABBR_MONTH_NUM[m[3].downcase] + if wday && mon + zone = m[8] + return { + wday: wday, mday: m[2].to_i, mon: mon, year: m[4].to_i, + hour: m[5].to_i, min: m[6].to_i, sec: m[7].to_i, + zone: zone, offset: fast_zone_offset(zone) + } + end + end - true - end + # Preprocessing: replace non-date chars with space + str = string.dup + str.gsub!(/[^-+',.\/:\@\[\][:alnum:]]+/, ' ') - # parse_frag in date_parse.c (non-TIGHT post-processing). - # If the remaining string (after all other parsers have consumed - # their portions) is a standalone 1-2 digit number: - # - If we have hour but no mday, and the number is 1-31, set mday - # - If we have mday but no hour, and the number is 0-24, set hour - def parse_frag(str, hash) - m = subx(str, PARSE_FRAG_PAT) - return false unless m + # check_class (byte-level for speed) + cc = 0 + str.each_byte do |b| + if b >= 65 && b <= 90 || b >= 97 && b <= 122 || b > 127 + cc |= HAVE_ALPHA + elsif b >= 48 && b <= 57 + cc |= HAVE_DIGIT + elsif b == 45 + cc |= HAVE_DASH + elsif b == 46 + cc |= HAVE_DOT + elsif b == 47 + cc |= HAVE_SLASH + elsif b == 58 + cc |= HAVE_COLON + end + end - n = m[1].to_i + h = {} - if hash.key?(:hour) && !hash.key?(:mday) - hash[:mday] = n if n >= 1 && n <= 31 + # parse_day (always runs) + if (cc & HAVE_ALPHA) != 0 + parse_day(str, h) end - if hash.key?(:mday) && !hash.key?(:hour) - hash[:hour] = n if n >= 0 && n <= 24 - end - - true - end - # Helper: Convert day name to number (0=Sunday, 6=Saturday) - def day_num(day_name) - abbr_days = %w[sun mon tue wed thu fri sat] - abbr_days.index(day_name[0, 3].downcase) || 0 - end + # parse_time (needs colon or alpha for h/am/pm patterns) + if (cc & HAVE_DIGIT) != 0 && (cc & (HAVE_COLON | HAVE_ALPHA)) != 0 + parse_time(str, h) + end - # Helper: Convert month name to number (1=January, 12=December) - def mon_num(month_name) - abbr_months = %w[jan feb mar apr may jun jul aug sep oct nov dec] - (abbr_months.index(month_name[0, 3].downcase) || 0) + 1 - end + # Date parsers: first match wins (goto ok) + matched = false - # ISO 8601 extended datetime: 2001-02-03T04:05:06+09:00 - def iso8601_ext_datetime(str, hash) - pattern = /\A\s* - (?: - ([-+]?\d{2,}|-)-(\d{2})?(?:-(\d{2}))?| # YYYY-MM-DD or --MM-DD - ([-+]?\d{2,})?-(\d{3})| # YYYY-DDD - (\d{4}|\d{2})?-w(\d{2})-(\d)| # YYYY-Www-D - -w-(\d) # -W-D - ) - (?:t - (\d{2}):(\d{2})(?::(\d{2})(?:[,.](\d+))?)? # HH:MM:SS.fraction - (z|[-+]\d{2}(?::?\d{2})?)? # timezone - )? - \s*\z/ix - - match = pattern.match(str) - return false unless match - - # Calendar date (YYYY-MM-DD) - if match[1] - unless match[1] == '-' - year = match[1].to_i - # Complete 2-digit year - year = comp_year69(year) if match[1].length < 4 - hash[:year] = year - end - hash[:mon] = match[2].to_i if match[2] - hash[:mday] = match[3].to_i if match[3] - # Ordinal date (YYYY-DDD) - elsif match[5] - if match[4] - year = match[4].to_i - year = comp_year69(year) if match[4].length < 4 - hash[:year] = year - end - hash[:yday] = match[5].to_i - # Week date (YYYY-Www-D) - elsif match[8] - if match[6] - year = match[6].to_i - year = comp_year69(year) if match[6].length < 4 - hash[:cwyear] = year - end - hash[:cweek] = match[7].to_i - hash[:cwday] = match[8].to_i - # Week day only (-W-D) - elsif match[9] - hash[:cwday] = match[9].to_i + if !matched && (cc & (HAVE_ALPHA | HAVE_DIGIT)) == (HAVE_ALPHA | HAVE_DIGIT) + matched = parse_eu(str, h) end - # Time - if match[10] - hash[:hour] = match[10].to_i - hash[:min] = match[11].to_i - hash[:sec] = match[12].to_i if match[12] - hash[:sec_fraction] = parse_fraction(match[13]) if match[13] + if !matched && (cc & (HAVE_ALPHA | HAVE_DIGIT)) == (HAVE_ALPHA | HAVE_DIGIT) + matched = parse_us(str, h) end - # Timezone - if match[14] - hash[:zone] = match[14] - hash[:offset] = parse_zone_offset(match[14]) + if !matched && (cc & (HAVE_DIGIT | HAVE_DASH)) == (HAVE_DIGIT | HAVE_DASH) + matched = parse_iso(str, h) end - true - end - - # ISO 8601 basic datetime: 20010203T040506 - def iso8601_bas_datetime(str, hash) - # Try full basic datetime: YYYYMMDD or YYMMDD - pattern = /\A\s* - ([-+]?(?:\d{4}|\d{2})|--) # Year (YYYY, YY, --, or signed) - (\d{2}|-) # Month (MM or -) - (\d{2}) # Day (DD) - (?:t? - (\d{2})(\d{2}) # Hour and minute (HHMM) - (?:(\d{2}) # Second (SS) - (?:[,.](\d+))? # Fraction - )? - (z|[-+]\d{2}(?:\d{2})?)? # Timezone - )? - \s*\z/ix - - match = pattern.match(str) - if match - # Calendar date - unless match[1] == '--' - year = match[1].to_i - year = comp_year69(year) if match[1].length == 2 && match[1] !~ /^[-+]/ - hash[:year] = year - end - hash[:mon] = match[2].to_i unless match[2] == '-' - hash[:mday] = match[3].to_i - - # Time - if match[4] - hash[:hour] = match[4].to_i - hash[:min] = match[5].to_i - hash[:sec] = match[6].to_i if match[6] - hash[:sec_fraction] = parse_fraction(match[7]) if match[7] - end - - # Timezone - if match[8] - hash[:zone] = match[8] - hash[:offset] = parse_zone_offset(match[8]) - end + if !matched && (cc & (HAVE_DIGIT | HAVE_DOT)) == (HAVE_DIGIT | HAVE_DOT) + matched = parse_jis(str, h) + end - return true + if !matched && (cc & (HAVE_ALPHA | HAVE_DIGIT | HAVE_DASH)) == (HAVE_ALPHA | HAVE_DIGIT | HAVE_DASH) + matched = parse_vms(str, h) end - # Try ordinal date: YYYYDDD or YYDDD - pattern = /\A\s* - ([-+]?(?:\d{4}|\d{2})) # Year - (\d{3}) # Day of year - (?:t? - (\d{2})(\d{2}) # Hour and minute - (?:(\d{2}) # Second - (?:[,.](\d+))? # Fraction - )? - (z|[-+]\d{2}(?:\d{2})?)? # Timezone - )? - \s*\z/ix - - match = pattern.match(str) - if match - year = match[1].to_i - year = comp_year69(year) if match[1].length == 2 && match[1] !~ /^[-+]/ - hash[:year] = year - hash[:yday] = match[2].to_i - - # Time - if match[3] - hash[:hour] = match[3].to_i - hash[:min] = match[4].to_i - hash[:sec] = match[5].to_i if match[5] - hash[:sec_fraction] = parse_fraction(match[6]) if match[6] - end + if !matched && (cc & (HAVE_DIGIT | HAVE_SLASH)) == (HAVE_DIGIT | HAVE_SLASH) + matched = parse_sla(str, h) + end - # Timezone - if match[7] - hash[:zone] = match[7] - hash[:offset] = parse_zone_offset(match[7]) - end + if !matched && (cc & (HAVE_DIGIT | HAVE_DOT)) == (HAVE_DIGIT | HAVE_DOT) + matched = parse_dot(str, h) + end - return true + if !matched && (cc & HAVE_DIGIT) != 0 + matched = parse_iso2(str, h) end - # Try -DDD (ordinal without year) - pattern = /\A\s* - -(\d{3}) # Day of year - (?:t? - (\d{2})(\d{2}) # Hour and minute - (?:(\d{2}) # Second - (?:[,.](\d+))? # Fraction - )? - (z|[-+]\d{2}(?:\d{2})?)? # Timezone - )? - \s*\z/ix - - match = pattern.match(str) - if match - hash[:yday] = match[1].to_i - - # Time - if match[2] - hash[:hour] = match[2].to_i - hash[:min] = match[3].to_i - hash[:sec] = match[4].to_i if match[4] - hash[:sec_fraction] = parse_fraction(match[5]) if match[5] - end + if !matched && (cc & HAVE_DIGIT) != 0 + matched = parse_year(str, h) + end - # Timezone - if match[6] - hash[:zone] = match[6] - hash[:offset] = parse_zone_offset(match[6]) - end + if !matched && (cc & HAVE_ALPHA) != 0 + matched = parse_mon(str, h) + end - return true + if !matched && (cc & HAVE_DIGIT) != 0 + matched = parse_mday(str, h) end - # Try week date: YYYYWwwD or YYWwwD - pattern = /\A\s* - (\d{4}|\d{2}) # Year - w(\d{2}) # Week - (\d) # Day of week - (?:t? - (\d{2})(\d{2}) # Hour and minute - (?:(\d{2}) # Second - (?:[,.](\d+))? # Fraction - )? - (z|[-+]\d{2}(?:\d{2})?)? # Timezone - )? - \s*\z/ix - - match = pattern.match(str) - if match - year = match[1].to_i - year = comp_year69(year) if match[1].length == 2 - hash[:cwyear] = year - hash[:cweek] = match[2].to_i - hash[:cwday] = match[3].to_i - - # Time - if match[4] - hash[:hour] = match[4].to_i - hash[:min] = match[5].to_i - hash[:sec] = match[6].to_i if match[6] - hash[:sec_fraction] = parse_fraction(match[7]) if match[7] - end + if !matched && (cc & HAVE_DIGIT) != 0 + parse_ddd(str, h) + end - # Timezone - if match[8] - hash[:zone] = match[8] - hash[:offset] = parse_zone_offset(match[8]) - end + # Post-processing (always runs after ok label) + # parse_bc + if (cc & HAVE_ALPHA) != 0 + parse_bc_post(str, h) + end - return true + # parse_frag + if (cc & HAVE_DIGIT) != 0 + parse_frag(str, h) end - # Try -WwwD (week date without year) - pattern = /\A\s* - -w(\d{2}) # Week - (\d) # Day of week - (?:t? - (\d{2})(\d{2}) # Hour and minute - (?:(\d{2}) # Second - (?:[,.](\d+))? # Fraction - )? - (z|[-+]\d{2}(?:\d{2})?)? # Timezone - )? - \s*\z/ix - - match = pattern.match(str) - if match - hash[:cweek] = match[1].to_i - hash[:cwday] = match[2].to_i - - # Time - if match[3] - hash[:hour] = match[3].to_i - hash[:min] = match[4].to_i - hash[:sec] = match[5].to_i if match[5] - hash[:sec_fraction] = parse_fraction(match[6]) if match[6] - end + # BC handling + if h.delete(:_bc) + h[:cwyear] = -h[:cwyear] + 1 if h[:cwyear] + h[:year] = -h[:year] + 1 if h[:year] + end - # Timezone - if match[7] - hash[:zone] = match[7] - hash[:offset] = parse_zone_offset(match[7]) + # comp (century completion) + if comp && h.delete(:_comp) != false + [:cwyear, :year].each do |key| + y = h[key] + if y && y >= 0 && y <= 99 + h[key] = y >= 69 ? y + 1900 : y + 2000 + end end + end - return true + # zone -> offset + if h[:zone] && !h.key?(:offset) + h[:offset] = fast_zone_offset(h[:zone]) end - # Try -W-D (day of week only) - pattern = /\A\s* - -w-(\d) # Day of week - (?:t? - (\d{2})(\d{2}) # Hour and minute - (?:(\d{2}) # Second - (?:[,.](\d+))? # Fraction - )? - (z|[-+]\d{2}(?:\d{2})?)? # Timezone - )? - \s*\z/ix - - match = pattern.match(str) - if match - hash[:cwday] = match[1].to_i - - # Time - if match[2] - hash[:hour] = match[2].to_i - hash[:min] = match[3].to_i - hash[:sec] = match[4].to_i if match[4] - hash[:sec_fraction] = parse_fraction(match[5]) if match[5] - end + h + end - # Timezone - if match[6] - hash[:zone] = match[6] - hash[:offset] = parse_zone_offset(match[6]) - end + # ------------------------------------------------------------------ + # parse constructor + # ------------------------------------------------------------------ - return true - end + # call-seq: + # Date.parse(string = '-4712-01-01', comp = true, start = Date::ITALY, limit: 128) -> date + # + # Note: + # This method recognizes many forms in +string+, + # but it is not a validator. + # For formats, see + # {"Specialized Format Strings" in Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc@Specialized+Format+Strings] + # If +string+ does not specify a valid date, + # the result is unpredictable; + # consider using Date._strptime instead. + # + # Returns a new \Date object with values parsed from +string+: + # + # Date.parse('2001-02-03') # => # + # Date.parse('20010203') # => # + # Date.parse('3rd Feb 2001') # => # + # + # If +comp+ is +true+ and the given year is in the range (0..99), + # the current century is supplied; + # otherwise, the year is taken as given: + # + # Date.parse('01-02-03', true) # => # + # Date.parse('01-02-03', false) # => # + # + # See: + # + # - Argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # - Argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date._parse (returns a hash). + def parse(string = '-4712-01-01', comp = true, start = DEFAULT_SG, limit: 128) + hash = _parse(string, comp, limit: limit) + fast_new_date(hash, start) + end - false + # ------------------------------------------------------------------ + # Specialized constructors + # ------------------------------------------------------------------ + + # call-seq: + # Date.iso8601(string = '-4712-01-01', start = Date::ITALY, limit: 128) -> date + # + # Returns a new \Date object with values parsed from +string+, + # which should contain + # an {ISO 8601 formatted date}[rdoc-ref:language/strftime_formatting.rdoc@ISO+8601+Format+Specifications]: + # + # d = Date.new(2001, 2, 3) + # s = d.iso8601 # => "2001-02-03" + # Date.iso8601(s) # => # + # + # See: + # + # - Argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # - Argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date._iso8601 (returns a hash). + def iso8601(string = JULIAN_EPOCH_DATE, start = DEFAULT_SG, limit: 128) + hash = _iso8601(string, limit: limit) + fast_new_date(hash, start) end - # ISO 8601 extended time: 04:05:06+09:00 - def iso8601_ext_time(str, hash) - # Pattern: HH:MM:SS.fraction or HH:MM:SS,fraction - pattern = /\A\s*(\d{2}):(\d{2})(?::(\d{2})(?:[,.](\d+))?)?(z|[-+]\d{2}(?::?\d{2})?)?\s*\z/ix + # call-seq: + # Date.rfc3339(string = '-4712-01-01T00:00:00+00:00', start = Date::ITALY, limit: 128) -> date + # + # Returns a new \Date object with values parsed from +string+, + # which should be a valid + # {RFC 3339 format}[rdoc-ref:language/strftime_formatting.rdoc@RFC+3339+Format]: + # + # d = Date.new(2001, 2, 3) + # s = d.rfc3339 # => "2001-02-03T00:00:00+00:00" + # Date.rfc3339(s) # => # + # + # See: + # + # - Argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # - Argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date._rfc3339 (returns a hash). + def rfc3339(string = JULIAN_EPOCH_DATETIME, start = DEFAULT_SG, limit: 128) + hash = _rfc3339(string, limit: limit) + fast_new_date(hash, start) + end - match = pattern.match(str) - return false unless match + # call-seq: + # Date.xmlschema(string = '-4712-01-01', start = Date::ITALY, limit: 128) -> date + # + # Returns a new \Date object with values parsed from +string+, + # which should be a valid XML date format: + # + # d = Date.new(2001, 2, 3) + # s = d.xmlschema # => "2001-02-03" + # Date.xmlschema(s) # => # + # + # See: + # + # - Argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # - Argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date._xmlschema (returns a hash). + def xmlschema(string = JULIAN_EPOCH_DATE, start = DEFAULT_SG, limit: 128) + hash = _xmlschema(string, limit: limit) + fast_new_date(hash, start) + end - hash[:hour] = match[1].to_i - hash[:min] = match[2].to_i - hash[:sec] = match[3].to_i if match[3] - hash[:sec_fraction] = parse_fraction(match[4]) if match[4] + # call-seq: + # Date.rfc2822(string = 'Mon, 1 Jan -4712 00:00:00 +0000', start = Date::ITALY, limit: 128) -> date + # + # Returns a new \Date object with values parsed from +string+, + # which should be a valid + # {RFC 2822 date format}[rdoc-ref:language/strftime_formatting.rdoc@RFC+2822+Format]: + # + # d = Date.new(2001, 2, 3) + # s = d.rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000" + # Date.rfc2822(s) # => # + # + # See: + # + # - Argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # - Argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date._rfc2822 (returns a hash). + def rfc2822(string = JULIAN_EPOCH_DATETIME_RFC2822, start = DEFAULT_SG, limit: 128) + hash = _rfc2822(string, limit: limit) + fast_new_date(hash, start) + end + alias rfc822 rfc2822 - if match[5] - hash[:zone] = match[5] - hash[:offset] = parse_zone_offset(match[5]) - end + # call-seq: + # Date.httpdate(string = 'Mon, 01 Jan -4712 00:00:00 GMT', start = Date::ITALY, limit: 128) -> date + # + # Returns a new \Date object with values parsed from +string+, + # which should be a valid + # {HTTP date format}[rdoc-ref:language/strftime_formatting.rdoc@HTTP+Format]: + # + # d = Date.new(2001, 2, 3) + # s = d.httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT" + # Date.httpdate(s) # => # + # + # See: + # + # - Argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # - Argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date._httpdate (returns a hash). + def httpdate(string = JULIAN_EPOCH_DATETIME_HTTPDATE, start = DEFAULT_SG, limit: 128) + hash = _httpdate(string, limit: limit) + fast_new_date(hash, start) + end - true + # call-seq: + # Date.jisx0301(string = '-4712-01-01', start = Date::ITALY, limit: 128) -> date + # + # Returns a new \Date object with values parsed from +string+, + # which should be a valid {JIS X 0301 format}[rdoc-ref:language/strftime_formatting.rdoc@JIS+X+0301+Format]: + # + # d = Date.new(2001, 2, 3) + # s = d.jisx0301 # => "H13.02.03" + # Date.jisx0301(s) # => # + # + # For no-era year, legacy format, Heisei is assumed. + # + # Date.jisx0301('13.02.03') # => # + # + # See: + # + # - Argument {start}[rdoc-ref:language/calendars.rdoc@Argument+start]. + # - Argument {limit}[rdoc-ref:Date@Argument+limit]. + # + # Related: Date._jisx0301 (returns a hash). + def jisx0301(string = JULIAN_EPOCH_DATE, start = DEFAULT_SG, limit: 128) + hash = _jisx0301(string, limit: limit) + fast_new_date(hash, start) end - # ISO 8601 basic time: 040506 - def iso8601_bas_time(str, hash) - # Pattern: HHMMSS.fraction or HHMMSS,fraction - pattern = /\A\s*(\d{2})(\d{2})(?:(\d{2})(?:[,.](\d+))?)?(z|[-+]\d{2}(?:\d{2})?)?\s*\z/ix + private - match = pattern.match(str) - return false unless match + # ------------------------------------------------------------------ + # Shared infrastructure + # ------------------------------------------------------------------ - hash[:hour] = match[1].to_i - hash[:min] = match[2].to_i - hash[:sec] = match[3].to_i if match[3] - hash[:sec_fraction] = parse_fraction(match[4]) if match[4] + def parse_check_limit(str, limit) + raise ArgumentError, "string length (#{str.length}) exceeds limit (#{limit})" if limit && str.length > limit + end - if match[5] - hash[:zone] = match[5] - hash[:offset] = parse_zone_offset(match[5]) - end + def parse_to_str(obj) + return nil if obj.nil? + raise TypeError, "no implicit conversion of #{obj.class} into String" if obj.is_a?(Symbol) + String === obj ? obj : obj.to_str + end - true + def parse_zone_and_offset(zone_str, hash) + return unless zone_str + hash[:zone] = zone_str + hash[:offset] = fast_zone_offset(zone_str) end - # Parse fractional seconds - def parse_fraction(frac_str) - return nil unless frac_str + def parse_sec_fraction(frac_str) Rational(frac_str.to_i, 10 ** frac_str.length) end - # Parse timezone offset (Z, +09:00, -0500, etc.) - def parse_zone_offset(zone_str) - return nil if zone_str.nil? || zone_str.empty? - - zone = zone_str.strip - - # Handle [+9] or [-9] or [9 ] format (brackets around offset) - if zone =~ /^\[(.*)\]$/ - zone = $1.strip - end - - # Handle Z (UTC) - return 0 if zone.upcase == 'Z' - - # Handle unsigned numeric offset: 9, 09 (assume positive) - if zone =~ /^(\d{1,2})$/ - hours = $1.to_i - return hours * HOUR_IN_SECONDS - end - - # Handle simple numeric offsets with sign: +9, -9, +09, -05, etc. - if zone =~ /^([-+])(\d{1,2})$/ - sign = $1 == '-' ? -1 : 1 - hours = $2.to_i - return sign * (hours * HOUR_IN_SECONDS) - end - - # Handle +09:00, -05:30 format (with colon) - if zone =~ /^([-+])(\d{2}):(\d{2})$/ - sign = $1 == '-' ? -1 : 1 - hours = $2.to_i - minutes = $3.to_i - return sign * (hours * HOUR_IN_SECONDS + minutes * MINUTE_IN_SECONDS) - end - - # Handle +0900, -0500 format (4 digits, no colon) - if zone =~ /^([-+])(\d{4})$/ - sign = $1 == '-' ? -1 : 1 - hours = $2[0, 2].to_i - minutes = $2[2, 2].to_i - return sign * (hours * HOUR_IN_SECONDS + minutes * MINUTE_IN_SECONDS) - end - - # Handle +0900 format (4 digits without colon) - if zone =~ /^([-+])(\d{4})$/ - sign = $1 == '-' ? -1 : 1 - hours = $2[0, 2].to_i - minutes = $2[2, 2].to_i - return sign * (hours * HOUR_IN_SECONDS + minutes * MINUTE_IN_SECONDS) - end - - # Handle fractional hours: +9.5, -5.5 - if zone =~ /^([-+])(\d+)[.,](\d+)$/ - sign = $1 == '-' ? -1 : 1 - hours = $2.to_i - fraction = "0.#{$3}".to_f - return sign * ((hours + fraction) * HOUR_IN_SECONDS).to_i - end - - # Handle GMT+9, GMT-5, etc. - if zone =~ /^(?:gmt|utc)?([-+])(\d{1,2})(?::?(\d{2}))?(?::?(\d{2}))?$/i - sign = $1 == '-' ? -1 : 1 - hours = $2.to_i - minutes = $3 ? $3.to_i : 0 - seconds = $4 ? $4.to_i : 0 - return sign * (hours * HOUR_IN_SECONDS + minutes * MINUTE_IN_SECONDS + seconds) - end - - # Known timezone abbreviations - zone_offsets = { - 'JST' => 9 * HOUR_IN_SECONDS, - 'GMT' => 0, - 'UTC' => 0, - 'UT' => 0, - 'EST' => -5 * HOUR_IN_SECONDS, - 'EDT' => -4 * HOUR_IN_SECONDS, - 'CST' => -6 * HOUR_IN_SECONDS, - 'CDT' => -5 * HOUR_IN_SECONDS, - 'MST' => -7 * HOUR_IN_SECONDS, - 'MDT' => -6 * HOUR_IN_SECONDS, - 'PST' => -8 * HOUR_IN_SECONDS, - 'PDT' => -7 * HOUR_IN_SECONDS, - 'AEST' => 10 * HOUR_IN_SECONDS, - 'MET DST' => 2 * HOUR_IN_SECONDS, - 'GMT STANDARD TIME' => 0, - 'MOUNTAIN STANDARD TIME' => -7 * HOUR_IN_SECONDS, - 'MOUNTAIN DAYLIGHT TIME' => -6 * HOUR_IN_SECONDS, - 'MEXICO STANDARD TIME' => -6 * HOUR_IN_SECONDS, - 'E. AUSTRALIA STANDARD TIME' => 10 * HOUR_IN_SECONDS, - 'W. CENTRAL AFRICA STANDARD TIME' => 1 * HOUR_IN_SECONDS, - } - - # Handle military timezones (single letters A-Z except J) - if zone =~ /^([A-Z])$/i - letter = zone.upcase - return 0 if letter == 'Z' - return nil if letter == 'J' # J is not used - - if letter <= 'I' - # A-I: +1 to +9 - offset = letter.ord - 'A'.ord + 1 - elsif letter >= 'K' && letter <= 'M' - # K-M: +10 to +12 (skip J) - offset = letter.ord - 'A'.ord # K is 10th letter (ord-'A'=10) - elsif letter >= 'N' && letter <= 'Y' - # N-Y: -1 to -12 - offset = -(letter.ord - 'N'.ord + 1) - else - return nil + # Fast zone offset calculation for common patterns. + # Handles: Z/z, +HH:MM/-HH:MM, +HHMM/-HHMM, short named zones. + # Falls back to _sp_zone_to_diff for complex cases. + def fast_zone_offset(zone_str) # rubocop:disable Metrics/CyclomaticComplexity + len = zone_str.length + b0 = zone_str.getbyte(0) + + # Z/z + return 0 if len == 1 && (b0 == 90 || b0 == 122) + + if b0 == 43 || b0 == 45 # '+' or '-' + sign = b0 == 45 ? -1 : 1 + if len == 6 && zone_str.getbyte(3) == 58 # +HH:MM + b1 = zone_str.getbyte(1) + b2 = zone_str.getbyte(2) + b4 = zone_str.getbyte(4) + b5 = zone_str.getbyte(5) + if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b4 >= 48 && b4 <= 57 && b5 >= 48 && b5 <= 57 + return sign * ((b1 - 48) * 36000 + (b2 - 48) * 3600 + (b4 - 48) * 600 + (b5 - 48) * 60) + end + end + if len == 5 # +HHMM + b1 = zone_str.getbyte(1) + b2 = zone_str.getbyte(2) + b3 = zone_str.getbyte(3) + b4 = zone_str.getbyte(4) + if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && b4 >= 48 && b4 <= 57 + return sign * ((b1 - 48) * 36000 + (b2 - 48) * 3600 + (b3 - 48) * 600 + (b4 - 48) * 60) + end end + end - return offset * HOUR_IN_SECONDS + # Short named zones: gmt, utc, est, etc. + if len <= 3 + off = ZONE_TABLE[zone_str.downcase] + return off if off end - # Normalize zone string for lookup - zone_upper = zone.gsub(/\s+/, ' ').upcase - zone_offsets[zone_upper] + # Fall back to full parser + _sp_zone_to_diff(zone_str) end - # JIS X 0301 format: H13.02.03 or H13.02.03T04:05:06 - def parse_jisx0301_fmt(str, hash) - # Pattern: [Era]YY.MM.DD[T]HH:MM:SS[.fraction][timezone] - # Era initials: M, T, S, H, R (or none for ISO 8601 fallback) - pattern = /\A\s* - ([#{JISX0301_ERA_INITIALS}])? # Era (optional) - (\d{2})\.(\d{2})\.(\d{2}) # YY.MM.DD - (?:t # Time separator (optional) - (?: - (\d{2}):(\d{2}) # HH:MM - (?::(\d{2}) # :SS (optional) - (?:[,.](\d*))? # .fraction (optional) - )? - (z|[-+]\d{2}(?::?\d{2})?)? # timezone (optional) - )? - )? - \s*\z/ix - - match = pattern.match(str) - return false unless match - - # Parse era and year - era_char = match[1] ? match[1].upcase : JISX0301_DEFAULT_ERA - era_year = match[2].to_i - - # Convert era year to gregorian year - era_start = gengo(era_char) - hash[:year] = era_start + era_year - - # Parse month and day - hash[:mon] = match[3].to_i - hash[:mday] = match[4].to_i - - # Parse time (if present) - if match[5] - hash[:hour] = match[5].to_i - hash[:min] = match[6].to_i if match[6] - hash[:sec] = match[7].to_i if match[7] - hash[:sec_fraction] = parse_fraction(match[8]) if match[8] - end - - # Parse timezone (if present) - if match[9] - hash[:zone] = match[9] - hash[:offset] = parse_zone_offset(match[9]) - end - - true - end + # ------------------------------------------------------------------ + # _iso8601 helpers + # ------------------------------------------------------------------ - # Convert era character to year offset - def gengo(era_char) - case era_char.upcase - when 'M' then 1867 # Meiji - when 'T' then 1911 # Taisho - when 'S' then 1925 # Showa - when 'H' then 1988 # Heisei - when 'R' then 2018 # Reiwa - else 0 - end + def comp_year69(y) + y >= 69 ? y + 1900 : y + 2000 end - # Post-processing: matches C's date__parse post-processing after ok: label. - # - # 1. _bc handling: negate year and cwyear (year = 1 - year) - # 2. _comp handling: complete 2-digit year/cwyear to 4-digit (69-99 → 1900s, 0-68 → 2000s) - # 3. zone → offset conversion - # 4. Clean up internal keys - def apply_comp(hash) - # _bc: del_hash("_bc") — read and delete - bc = hash.delete(:_bc) - if bc - if hash.key?(:cwyear) - hash[:cwyear] = 1 - hash[:cwyear] - end - if hash.key?(:year) - hash[:year] = 1 - hash[:year] + def iso8601_ext_datetime(m, h) + if m[1] + # year-mon-mday or truncated + unless m[1] == '-' + y = m[1].to_i + h[:year] = (m[1].length <= 2 && !m[1].start_with?('+') && !m[1].start_with?('-')) ? comp_year69(y) : y end - end - - # _comp: del_hash("_comp") — read and delete - comp = hash.delete(:_comp) - if comp - if hash.key?(:cwyear) - y = hash[:cwyear] - if y >= 0 && y <= 99 - hash[:cwyear] = y >= 69 ? y + 1900 : y + 2000 - end + h[:mon] = m[2].to_i if m[2] + h[:mday] = m[3].to_i if m[3] + elsif m[4] || m[5] + # year-yday + if m[4] + y = m[4].to_i + h[:year] = (m[4].length <= 2 && !m[4].start_with?('+') && !m[4].start_with?('-')) ? comp_year69(y) : y end - if hash.key?(:year) - y = hash[:year] - if y >= 0 && y <= 99 - hash[:year] = y >= 69 ? y + 1900 : y + 2000 - end + h[:yday] = m[5].to_i + elsif m[6] || m[7] + # cwyear-wNN-D + if m[6] + y = m[6].to_i + h[:cwyear] = m[6].length <= 2 ? comp_year69(y) : y end + h[:cweek] = m[7].to_i + h[:cwday] = m[8].to_i if m[8] + elsif m[9] + # -w-D + h[:cwday] = m[9].to_i end - - # zone → offset conversion - if hash.key?(:zone) && !hash.key?(:offset) - hash[:offset] = date_zone_to_diff(hash[:zone]) + # time part + if m[10] + h[:hour] = m[10].to_i + h[:min] = m[11].to_i if m[11] + h[:sec] = m[12].to_i if m[12] + h[:sec_fraction] = parse_sec_fraction(m[13]) if m[13] + parse_zone_and_offset(m[14], h) if m[14] end - - # Clean up internal keys - hash.delete(:_year_str) end - # s3e in date_parse.c. - # y, m, and d are Strings or nil. m can also be an Integer (convert with to_s). - # bc is a Boolean. - # - # This method normalizes the year, mon, and mday from the combination of y, m, and - # d and writes them to a hash. - # The sorting logic operates in the following order of priority: - # - # Phase 1: Argument rotation and promotion - # - y and m are available, but d is nil => Rotate because it is a pair (mon, mday) - # - y is nil and d is long (>2 digits) or starts with an apostrophe => Promote d to y - # - If y has a leading character other than a digit, extract only the numeric portion, and if there is a remainder, add it to d - # - # Phase 2: Sort m and d - # - m starts with an apostrophe or its length is >2 => US->BE sort (y,m,d)=(m,d,y) - # - d starts with an apostrophe or its length is >2 => Swap (y,d) - # - # Phase 3: Write to hash - # - Extract the sign and digits from y and set them to year - # If signed or the number of digits is >2, write _comp = false - # - Extract the number from m and set it to mon - # - Extract the number from d and set it to mday - # - If bc is true, write _bc = true - def s3e(hash, y, m, d, bc) - # Candidates for _comp. If nil, do not write. - c = nil - - # If m is not a string, use to_s (parse_eu/parse_us passes the Integer returned by mon_num) - m = m.to_s unless m.nil? || m.is_a?(String) - - # ---------------------------------------------------------- - # Phase 1: Argument reordering - # ---------------------------------------------------------- - - # If we have y and m, but d is nil, it's actually a (mon, mday) pair, so we rotate it. - # (y, m, d) = (nil, y, m) - if !y.nil? && !m.nil? && d.nil? - y, m, d = nil, y, m - end - - # If y is nil and d exists, if d is long or begins with an apostrophe, it is promoted to y - if y.nil? - if !d.nil? && d.length > 2 - y = d - d = nil - end - if !d.nil? && d.length > 0 && d[0] == "'" - y = d - d = nil - end + def iso8601_bas_datetime(m, h) + if m[1] + # yyyymmdd / --mmdd / ----dd + unless m[1] == '--' + y_s = m[1] + y = y_s.to_i + ylen = y_s.sub(/\A[-+]/, '').length + h[:year] = (ylen <= 2 && !y_s.start_with?('+') && !y_s.start_with?('-')) ? comp_year69(y) : y + end + h[:mon] = m[2].to_i unless m[2] == '-' + h[:mday] = m[3].to_i + elsif m[4] + # yyyyddd + y_s = m[4] + y = y_s.to_i + ylen = y_s.sub(/\A[-+]/, '').length + h[:year] = (ylen <= 2 && !y_s.start_with?('+') && !y_s.start_with?('-')) ? comp_year69(y) : y + h[:yday] = m[5].to_i + elsif m[6] + # -ddd + h[:yday] = m[6].to_i + elsif m[7] + # yyyywwwd + y = m[7].to_i + h[:cwyear] = m[7].length <= 2 ? comp_year69(y) : y + h[:cweek] = m[8].to_i + h[:cwday] = m[9].to_i + elsif m[10] + # -wNN-D + h[:cweek] = m[10].to_i + h[:cwday] = m[11].to_i + elsif m[12] + # -w-D + h[:cwday] = m[12].to_i end - - # If y has a leading character other than a sign or a number, skip it and - # extract only the numeric part. If there are any characters remaining after - # the extracted numeric string, swap y and d, and set the numeric part to d. - unless y.nil? - pos = 0 - pos += 1 while pos < y.length && !issign?(y[pos]) && !y[pos].match?(/\d/) - - unless pos >= y.length # no_date - bp = pos - pos += 1 if pos < y.length && issign?(y[pos]) - span = digit_span(y[pos..]) - ep = pos + span - - if ep < y.length - # There is a letter after the number string => exchange (y, d) - y, d = d, y[bp...ep] - end - end + # time part + if m[13] + h[:hour] = m[13].to_i + h[:min] = m[14].to_i if m[14] + h[:sec] = m[15].to_i if m[15] + h[:sec_fraction] = parse_sec_fraction(m[16]) if m[16] + parse_zone_and_offset(m[17], h) if m[17] end + end - # ---------------------------------------------------------- - # Phase 2: Rearrange m and d - # ---------------------------------------------------------- - - # m starts with an apostrophe or length > 2 => US => BE sort - # (y, m, d) = (m, d, y) - if !m.nil? && (m[0] == "'" || m.length > 2) - y, m, d = m, d, y - end + # ------------------------------------------------------------------ + # _parse sub-parsers (private) + # ------------------------------------------------------------------ - # d begins with an apostrophe or length > 2 => exchange (y, d) - if !d.nil? && (d[0] == "'" || d.length > 2) - y, d = d, y + def parse_day(str, h) + if (m = PARSE_DAYS_RE.match(str)) + h[:wday] = ABBR_DAY_NUM[m[1].downcase] + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) end + end - # ---------------------------------------------------------- - # Phase 3: Write to hash - # ---------------------------------------------------------- - - # year: Extract the sign and digit from y and set - unless y.nil? - pos = 0 - pos += 1 while pos < y.length && !issign?(y[pos]) && !y[pos].match?(/\d/) + def parse_time(str, h) + if (m = PARSE_TIME_RE.match(str)) + time_part = m[1] + zone_part = m[2] + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) - unless pos >= y.length # no_year - bp = pos - sign = false - if pos < y.length && issign?(y[pos]) - sign = true - pos += 1 + if (tm = PARSE_TIME_CB_RE.match(time_part)) + hour = tm[1].to_i + if tm[5] + ampm = tm[5].downcase + if ampm == 'p' + hour = (hour % 12) + 12 + else + hour = hour % 12 + end end - - c = false if sign # Signed => _comp = false - span = digit_span(y[pos..]) - c = false if span > 2 # Number of digits > 2 => _comp = false - - num_str = y[bp, (pos - bp) + span] # sign + number part - hash[:year] = num_str.to_i - end - end - - hash[:_bc] = true if bc - - # mon: Extract and set a number from m - unless m.nil? - pos = 0 - pos += 1 while pos < m.length && !m[pos].match?(/\d/) - - unless pos >= m.length # no_month - span = digit_span(m[pos..]) - hash[:mon] = m[pos, span].to_i + h[:hour] = hour + h[:min] = tm[2].to_i if tm[2] + h[:sec] = tm[3].to_i if tm[3] + h[:sec_fraction] = parse_sec_fraction(tm[4]) if tm[4] end - end - # mday: Extract and set numbers from d - unless d.nil? - pos = 0 - pos += 1 while pos < d.length && !d[pos].match?(/\d/) - - unless pos >= d.length # no_mday - span = digit_span(d[pos..]) - hash[:mday] = d[pos, span].to_i + if zone_part + h[:zone] = zone_part end end - - # _comp is written only if it is explicitly false - hash[:_comp] = false unless c.nil? - end - - # issign macro in date_parse.c. - def issign?(c) - c == '-' || c == '+' end - # digit_span in date_parse.c. - # Returns the length of the first consecutive digit in the string 's'. - def digit_span(s) - i = 0 - i += 1 while i < s.length && s[i].match?(/\d/) - - i - end - - # date_zone_to_diff in date_parse.c. - # Returns the number of seconds since UTC from a time zone name or offset string. - # Returns nil if no match occurs. - # - # Supported input types: - # 1. Zone names: "EST", "JST", "Eastern", "Central Pacific", ... - # 2. Suffixes: "Eastern standard time", "EST dst", ... - # "standard time" => As is - # "daylight time" / "dst" => Set offset to +3600 - # 3. Numeric offset: "+09:00", "-0530", "+9", "GMT+09:00", ... - # 4. Fractional time offset: "+9.5" (=+09:30), "+5.50" (=+05:30), ... - def date_zone_to_diff(str) - return nil if str.nil? || str.empty? - - s = str.dup - dst = false - - # Suffix removal: "time", "standard", "daylight", "dst" - w = str_end_with_word(s, "time") - if w > 0 - s = s[0, s.length - w] - - w2 = str_end_with_word(s, "standard") - if w2 > 0 - s = s[0, s.length - w2] - else - w2 = str_end_with_word(s, "daylight") - if w2 > 0 - s = s[0, s.length - w2] - dst = true - else - # "time" alone is not enough, so return - s = str.dup - end - end + def parse_eu(str, h) + if (m = PARSE_EU_RE.match(str)) + mon = ABBR_MONTH_NUM[m[2].downcase] + return false unless mon + bc = m[3] && m[3] =~ /\Ab/i ? true : false + s3e(h, m[4], mon, m[1], bc) + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true else - w = str_end_with_word(s, "dst") - if w > 0 - s = s[0, s.length - w] - dst = true - end - end - - # --- zonetab search --- - # Normalize consecutive spaces into a single space before searching - zn = shrink_space(s) - z_offset = ZONE_TABLE[zn.downcase] - - if z_offset - z_offset += 3600 if dst - return z_offset - end - - # --- Parse numeric offsets --- - # Remove "GMT" and "UTC" prefixes - if zn.length > 3 && zn[0, 3].downcase =~ /\A(gmt|utc)\z/ - zn = zn[3..] - end - - # If there is no sign, it is not treated as a numeric offset - return nil if zn.empty? || (zn[0] != '+' && zn[0] != '-') - - sign = zn[0] == '-' ? -1 : 1 - zn = zn[1..] - return nil if zn.empty? - - # ':' separator: HH:MM or HH:MM:SS - if zn.include?(':') - return parse_colon_offset(zn, sign) - end - - # '.' or ',' separator: HH.fraction - if zn.include?('.') || zn.include?(',') - return parse_fractional_offset(zn, sign) + false end - - # Others: HH or HHMM or HHMMSS - parse_compact_offset(zn, sign) end - # str_end_with_word in date_parse.c. - # If the string 's' ends with "" (a word plus a space), - # Returns the length of that "" (including leading spaces). - # Otherwise, returns 0. - def str_end_with_word(s, word) - n = word.length - return 0 if s.length <= n - - # The last n characters match word (ignoring case) - return 0 unless s[-n..].casecmp?(word) - - # Is there a space just before it? - return 0 unless s[-(n + 1)].match?(/\s/) - - # Include consecutive spaces - count = n + 1 - count += 1 while count < s.length && s[-(count + 1)].match?(/\s/) - - count + def parse_us(str, h) + if (m = PARSE_US_RE.match(str)) + mon = ABBR_MONTH_NUM[m[1].downcase] + return false unless mon + bc = m[3] && m[3] =~ /\Ab/i ? true : false + s3e(h, m[4], mon, m[2], bc) + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true + else + false + end end - # shrink_space in date_parse.c. - # Combines consecutive spaces into a single space. - # If the length is the same as the original (normalization unnecessary), - # return it as is. - def shrink_space(s) - result = [] - prev_space = false - s.each_char do |ch| - if ch.match?(/\s/) - result << ' ' unless prev_space - prev_space = true + def parse_iso(str, h) + if (m = PARSE_ISO_RE.match(str)) + y_s = m[1] + m_s = m[2] + d_s = m[3] + # Fast path: y is unambiguous year (3+ digits or signed), d is short + if y_s =~ /\A[-+]?\d{3,}\z/ && d_s =~ /\A\d{1,2}\z/ + h[:year] = y_s.to_i + h[:_comp] = false + h[:mon] = m_s.to_i + h[:mday] = d_s.to_i else - result << ch - prev_space = false + s3e(h, y_s, m_s, d_s, false) end + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true + else + false end - result.join - end - - # parse_colon_offset - # Parse "+HH:MM" or "+HH:MM:SS" and return the number of seconds. - # Range checking: hour 0-23, min 0-59, sec 0-59 - def parse_colon_offset(zn, sign) - parts = zn.split(':') - hour = parts[0].to_i - return nil if hour < 0 || hour > 23 - - min = parts.length > 1 ? parts[1].to_i : 0 - return nil if min < 0 || min > 59 - - sec = parts.length > 2 ? parts[2].to_i : 0 - return nil if sec < 0 || sec > 59 - - sign * (sec + min * 60 + hour * 3600) end - # Parse "+HH.fraction" or "+HH,fraction" and return the number of seconds. - # - # C logic: - # Read the fraction string up to 7 digits. - # sec = (read value) * 36 - # If n <= 2: - # If n == 1, sec *= 10 (treat HH.n as HH.n0) - # Return value = sec + hour * 3600 (Integer) - # If n > 2: - # Return value = Rational(sec, 10**(n-2)) + hour * 3600 - # Convert to an Integer if the denominator is 1. - # - # Reason for the 36 factor: - # 1 hour = 3600 seconds. Each decimal point is 1/10. Time = 360 seconds. - # However, since the implementation handles it in two-digit units, multiply - # by 36 before dividing by 10^2. - # (3600 / 100 = 36) - def parse_fractional_offset(zn, sign) - sep = zn.include?('.') ? '.' : ',' - hh_str, frac_str = zn.split(sep, 2) - hour = hh_str.to_i - return nil if hour < 0 || hour > 23 - - # Up to 7 digits (C: "no over precision for offset") - max_digits = 7 - frac_str = frac_str[0, max_digits] - n = frac_str.length - return sign * (hour * 3600) if n == 0 - - sec = frac_str.to_i * 36 # Convert to seconds by factor 36 - - if sign == -1 - hour = -hour - sec = -sec - end - - if n <= 2 - sec *= 10 if n == 1 # HH.n => HH.n0 - sec + hour * 3600 + def parse_jis(str, h) + if (m = PARSE_JIS_RE.match(str)) + era_char = m[1].downcase + era_offset = JISX0301_ERA[era_char] + return false unless era_offset + h[:year] = m[2].to_i + era_offset + h[:mon] = m[3].to_i + h[:mday] = m[4].to_i + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true else - # Rational for precise calculations - denom = 10 ** (n - 2) - offset = Rational(sec, denom) + (hour * 3600) - offset.denominator == 1 ? offset.to_i : offset + false + end + end + + def parse_vms(str, h) + if (m = PARSE_VMS11_RE.match(str)) + mon = ABBR_MONTH_NUM[m[2].downcase] + return false unless mon + s3e(h, m[3], mon, m[1], false) + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true + elsif (m = PARSE_VMS12_RE.match(str)) + mon = ABBR_MONTH_NUM[m[1].downcase] + return false unless mon + s3e(h, m[3], mon, m[2], false) + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true + else + false end end - # parse_compact_offset - # Parse consecutive numeric offsets without colons. - # HH (2 digits or less) - # HHM (3 digits: 1 digit for hour, 2 digits for min) - # HHMM (4 digits) - # HHMMM (5 digits: 2 digits for hour, 2 digits for min, 1 digit for sec) ... Rare in practical use - # HHMMSS (6 digits) - # - # C adjusts the leading padding width with "2 - l % 2". - # Ruby does the same calculation with length. - def parse_compact_offset(zn, sign) - l = zn.length - - # Only HH - return sign * zn.to_i * 3600 if l <= 2 - - # C: hour = scan_digits(&s[0], 2 - l % 2) - # min = scan_digits(&s[2 - l % 2], 2) - # sec = scan_digits(&s[4 - l % 2], 2) - # - # l=3 => hw=1 => hour=zn[0,1], min=zn[1,2] - # l=4 => hw=2 => hour=zn[0,2], min=zn[2,2] - # l=5 => hw=1 => hour=zn[0,1], min=zn[1,2], sec=zn[3,2] - # l=6 => hw=2 => hour=zn[0,2], min=zn[2,2], sec=zn[4,2] - hw = 2 - l % 2 # hour width: 2 for even, 1 for odd - hour = zn[0, hw].to_i - min = l >= 3 ? zn[hw, 2].to_i : 0 - sec = l >= 5 ? zn[hw + 2, 2].to_i : 0 - - sign * (sec + min * 60 + hour * 3600) - end - - # subx in date_parse.c. - # Matches pat against str. If it matches, replaces the matched - # portion of str (in-place) with rep (default: " ") and returns - # the MatchData. Returns nil on no match. - # - # This is the core mechanism C uses (via the SUBS macro) to - # prevent later parsers from re-matching already-consumed text. - def subx(str, pat, rep = " ") - m = pat.match(str) - return nil unless m - - str[m.begin(0), m.end(0) - m.begin(0)] = rep - m - end - - def check_class(str) - flags = 0 - flags |= HAVE_ALPHA if str.match?(/[a-zA-Z]/) - flags |= HAVE_DIGIT if str.match?(/\d/) - flags |= HAVE_DASH if str.include?('-') - flags |= HAVE_DOT if str.include?('.') - flags |= HAVE_SLASH if str.include?('/') - flags - end - - # C macro HAVE_ELEM_P(x) in date_parse.c. - # Note: C calls check_class(str) every time because str is - # modified by subx. We do the same here. - def have_elem_p?(str, required) - (check_class(str) & required) == required + def parse_sla(str, h) + if (m = PARSE_SLA_RE.match(str)) + s3e(h, m[1], m[2], m[3], false) + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true + else + false + end end - # --- String type conversion (C's StringValue macro) --- - def string_value(str) - return str if str.is_a?(String) - if str.respond_to?(:to_str) - s = str.to_str - raise TypeError, "can't convert #{str.class} to String (#{str.class}#to_str gives #{s.class})" unless s.is_a?(String) - return s + def parse_dot(str, h) + if (m = PARSE_DOT_RE.match(str)) + s3e(h, m[1], m[2], m[3], false) + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true + else + false end - raise TypeError, "no implicit conversion of #{str.class} into String" end - def check_string_limit(str, limit) - if limit && str.length > limit - raise ArgumentError, "string length (#{str.length}) exceeds the limit #{limit}" + def parse_iso2(str, h) + # iso21: week date + if (m = PARSE_ISO21_RE.match(str)) + if m[1] + y = m[1].to_i + h[:cwyear] = y + end + h[:cweek] = m[2].to_i + h[:cwday] = m[3].to_i if m[3] + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + return true end - end - # C: d_new_by_frags - # Date-only fragment-based constructor. - # Time fields in hash are ignored — use dt_new_by_frags (in datetime.rb) for DateTime. - def new_by_frags(hash, sg) - raise Error, "invalid date" if hash.nil? || hash.empty? + # iso22: -w-D + if (m = PARSE_ISO22_RE.match(str)) + h[:cwday] = m[1].to_i + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + return true + end - y = hash[:year] - m = hash[:mon] - d = hash[:mday] + # iso23: --MM-DD + if (m = PARSE_ISO23_RE.match(str)) + h[:mon] = m[1].to_i if m[1] + h[:mday] = m[2].to_i + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + return true + end - # Fast path: year+mon+mday present, no jd/yday - if !hash.key?(:jd) && !hash.key?(:yday) && y && m && d - raise Error, "invalid date" unless valid_civil?(y, m, d, sg) - obj = new(y, m, d, sg) - # Store parsed offset for deconstruct_keys([:zone]) without - # affecting JD calculations (don't use @of which triggers UTC conversion) - of = hash[:offset] - obj.instance_variable_set(:@parsed_offset, of) if of && of != 0 - return obj + # iso24: --MMDD + if (m = PARSE_ISO24_RE.match(str)) + h[:mon] = m[1].to_i + h[:mday] = m[2].to_i if m[2] + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + return true end - # Slow path — uses self (Date), so time-only patterns - # (e.g. '23:55') correctly fail: rt_complete_frags with Date class - # does not set :jd for :time pattern → rt__valid_date_frags_p returns nil. - hash = rt_rewrite_frags(hash) - hash = rt_complete_frags(self, hash) - jd = rt__valid_date_frags_p(hash, sg) + # iso25: YYYY-DDD (guard against fraction match) + unless str =~ /[,.]\d{2,4}-\d{3}\b/ + if (m = PARSE_ISO25_RE.match(str)) + h[:year] = m[1].to_i + h[:yday] = m[2].to_i + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + return true + end + end - raise Error, "invalid date" unless jd + # iso26: -DDD (guard against digit-DDD) + unless str =~ /\d-\d{3}\b/ + if (m = PARSE_ISO26_RE.match(str)) + h[:yday] = m[1].to_i + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + return true + end + end - self.jd(jd, sg) + false end - # C: rt_rewrite_frags - # Converts :seconds (from %s/%Q) into jd/hour/min/sec/sec_fraction fields. - # - # C implementation (date_core.c:4033): - # seconds = del_hash("seconds"); - # if (!NIL_P(seconds)) { - # if (!NIL_P(offset)) seconds = f_add(seconds, offset); - # d = f_idiv(seconds, DAY_IN_SECONDS); - # fr = f_mod(seconds, DAY_IN_SECONDS); - # h = f_idiv(fr, HOUR_IN_SECONDS); fr = f_mod(fr, HOUR_IN_SECONDS); - # min= f_idiv(fr, MINUTE_IN_SECONDS); fr = f_mod(fr, MINUTE_IN_SECONDS); - # s = f_idiv(fr, 1); fr = f_mod(fr, 1); - # set jd = UNIX_EPOCH_IN_CJD + d, hour, min, sec, sec_fraction - # } - # - # Ruby's .div() and % match C's f_idiv (rb_intern("div")) and f_mod ('%'). - # Both use floor semantics, correctly handling negative and Rational values. - def rt_rewrite_frags(hash) - seconds = hash.delete(:seconds) - return hash unless seconds - - offset = hash[:offset] - seconds = seconds + offset if offset - - # Day count from Unix epoch - # C: d = f_idiv(seconds, DAY_IN_SECONDS) - d = seconds.div(DAY_IN_SECONDS) - fr = seconds % DAY_IN_SECONDS - - # Decompose remainder into h:min:s.frac - h = fr.div(HOUR_IN_SECONDS) - fr = fr % HOUR_IN_SECONDS - - min = fr.div(MINUTE_IN_SECONDS) - fr = fr % MINUTE_IN_SECONDS - - s = fr.div(1) - fr = fr % 1 - - # C: UNIX_EPOCH_IN_CJD = 2440588 (1970-01-01 in Chronological JD) - hash[:jd] = 2440588 + d - hash[:hour] = h - hash[:min] = min - hash[:sec] = s - hash[:sec_fraction] = fr - hash + def parse_year(str, h) + if (m = PARSE_YEAR_RE.match(str)) + h[:year] = m[1].to_i + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true + else + false + end end - # C: rt_complete_frags (date_core.c:4071) - # - # Algorithm: - # 1. Score each of 11 field-set patterns against hash, pick highest match count. - # 2. For the winning named pattern, fill leading missing date fields from Date.today - # and set defaults for trailing date fields. - # 3. Special case: "time" pattern + DateTime class → set :jd from today. - # 4. Default :hour/:min/:sec to 0; clamp :sec to 59. - # - # Pattern table (C's static tab): - # [name, [fields...]] - # ────────────────────────── - # [:time, [:hour, :min, :sec]] - # [nil, [:jd]] - # [:ordinal, [:year, :yday, :hour, :min, :sec]] - # [:civil, [:year, :mon, :mday, :hour, :min, :sec]] - # [:commercial, [:cwyear, :cweek, :cwday, :hour, :min, :sec]] - # [:wday, [:wday, :hour, :min, :sec]] - # [:wnum0, [:year, :wnum0, :wday, :hour, :min, :sec]] - # [:wnum1, [:year, :wnum1, :wday, :hour, :min, :sec]] - # [nil, [:cwyear, :cweek, :wday, :hour, :min, :sec]] - # [nil, [:year, :wnum0, :cwday, :hour, :min, :sec]] - # [nil, [:year, :wnum1, :cwday, :hour, :min, :sec]] - # - def rt_complete_frags(klass, hash) - # Step 1: Find best matching pattern - # C: for each tab entry, count how many fields exist in hash; pick max. - # First match wins on tie (strict >). - best_key = nil - best_fields = nil - best_count = 0 - - COMPLETE_FRAGS_TABLE.each do |key, fields| - count = fields.count { |f| hash.key?(f) } - if count > best_count - best_count = count - best_key = key - best_fields = fields + def parse_mon(str, h) + if (m = PARSE_MON_RE.match(str)) + mon = ABBR_MONTH_NUM[m[1].downcase] + if mon + h[:mon] = mon + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + return true end end + false + end - # Step 2: Complete missing fields for named patterns - # C: if (!NIL_P(k) && (RARRAY_LEN(a) > e)) - d = nil # lazy Date.today + def parse_mday(str, h) + if (m = PARSE_MDAY_RE.match(str)) + h[:mday] = m[1].to_i + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true + else + false + end + end - if best_key && best_fields && best_fields.length > best_count - case best_key + def parse_ddd(str, h) + if (m = PARSE_DDD_RE.match(str)) + sign = m[1] + s2 = m[2] + s3 = m[3] + s4 = m[4] + s5 = m[5] - when :ordinal - # C: fill year from today if missing, default yday=1 - unless hash.key?(:year) - d ||= today - hash[:year] = d.year + l2 = s2.length + case l2 + when 2 + if s3.nil? && s4 + h[:sec] = s2.to_i + else + h[:mday] = s2.to_i + end + when 4 + if s3.nil? && s4 + h[:sec] = s2[2, 2].to_i + h[:min] = s2[0, 2].to_i + else + h[:mon] = s2[0, 2].to_i + h[:mday] = s2[2, 2].to_i + end + when 6 + if s3.nil? && s4 + h[:sec] = s2[4, 2].to_i + h[:min] = s2[2, 2].to_i + h[:hour] = s2[0, 2].to_i + else + h[:year] = (sign.to_s + s2[0, 2]).to_i + h[:mon] = s2[2, 2].to_i + h[:mday] = s2[4, 2].to_i end - hash[:yday] ||= 1 - - when :civil - # C: fill leading missing fields from today, stop at first present field. - # Then default mon=1, mday=1. - # - # The loop iterates [:year, :mon, :mday, :hour, :min, :sec]. - # For each field, if it's already in hash → break. - # Otherwise fill from today via d.send(field). - # In practice, the loop only reaches date fields (:year/:mon/:mday) - # because at least one date field must be present for civil to win. - best_fields.each do |f| - break if hash.key?(f) - d ||= today - hash[f] = d.send(f) + when 8, 10, 12, 14 + if s3.nil? && s4 + # read from end: sec,min,hour,mday,mon,year + pos = l2 + h[:sec] = s2[pos - 2, 2].to_i + pos -= 2 + h[:min] = s2[pos - 2, 2].to_i + pos -= 2 + h[:hour] = s2[pos - 2, 2].to_i + pos -= 2 + if pos >= 2 + h[:mday] = s2[pos - 2, 2].to_i + pos -= 2 + if pos >= 2 + h[:mon] = s2[pos - 2, 2].to_i + pos -= 2 + h[:year] = (sign.to_s + s2[0, pos]).to_i if pos > 0 + end + end + else + h[:year] = (sign.to_s + s2[0, 4]).to_i + h[:mon] = s2[4, 2].to_i if l2 >= 6 + h[:mday] = s2[6, 2].to_i if l2 >= 8 + h[:hour] = s2[8, 2].to_i if l2 >= 10 + h[:min] = s2[10, 2].to_i if l2 >= 12 + h[:sec] = s2[12, 2].to_i if l2 >= 14 + h[:_comp] = false end - hash[:mon] ||= 1 - hash[:mday] ||= 1 - - when :commercial - # C: same leading-fill pattern, then default cweek=1, cwday=1 - best_fields.each do |f| - break if hash.key?(f) - d ||= today - hash[f] = d.send(f) + when 3 + if s3.nil? && s4 + h[:sec] = s2[1, 2].to_i + h[:min] = s2[0, 1].to_i + else + h[:yday] = s2.to_i end - hash[:cweek] ||= 1 - hash[:cwday] ||= 1 - - when :wday - # C: set_hash("jd", d_lite_jd(f_add(f_sub(d, d_lite_wday(d)), ref_hash("wday")))) - # → jd of (today - today.wday + parsed_wday) - d ||= today - hash[:jd] = (d - d.wday + hash[:wday]).jd - - when :wnum0 - # C: leading-fill from today, then default wnum0=0, wday=0 - best_fields.each do |f| - break if hash.key?(f) - d ||= today - # :year is the only field that can be missing before :wnum0 in practice - hash[f] = d.send(f) if d.respond_to?(f) + when 5 + if s3.nil? && s4 + h[:sec] = s2[3, 2].to_i + h[:min] = s2[1, 2].to_i + h[:hour] = s2[0, 1].to_i + else + h[:year] = (sign.to_s + s2[0, 2]).to_i + h[:yday] = s2[2, 3].to_i end - hash[:wnum0] ||= 0 - hash[:wday] ||= 0 - - when :wnum1 - # C: leading-fill from today, then default wnum1=0, wday=1 - best_fields.each do |f| - break if hash.key?(f) - d ||= today - hash[f] = d.send(f) if d.respond_to?(f) + when 7 + if s3.nil? && s4 + h[:sec] = s2[5, 2].to_i + h[:min] = s2[3, 2].to_i + h[:hour] = s2[1, 2].to_i + h[:mday] = s2[0, 1].to_i + else + h[:year] = (sign.to_s + s2[0, 4]).to_i + h[:yday] = s2[4, 3].to_i + h[:_comp] = false end - hash[:wnum1] ||= 0 - hash[:wday] ||= 1 end - end - # Step 3: "time" pattern special case - # C: if (k == sym("time")) { if (f_le_p(klass, cDateTime)) { ... } } - # For DateTime (or subclass), time-only input gets :jd from today. - # For Date, time-only input will fail validation (no date fields). - if best_key == :time - if defined?(DateTime) && klass <= DateTime - d ||= today - hash[:jd] ||= d.jd + # s3 (time portion from continuous digits after separator) + if s3 && !s3.empty? + l3 = s3.length + if s4 + # read from end + case l3 + when 2 + h[:sec] = s3[0, 2].to_i + when 4 + h[:sec] = s3[2, 2].to_i + h[:min] = s3[0, 2].to_i + when 6 + h[:sec] = s3[4, 2].to_i + h[:min] = s3[2, 2].to_i + h[:hour] = s3[0, 2].to_i + end + else + # read from start + h[:hour] = s3[0, 2].to_i if l3 >= 2 + h[:min] = s3[2, 2].to_i if l3 >= 4 + h[:sec] = s3[4, 2].to_i if l3 >= 6 + end + end + + # s4: sec_fraction + if s4 && !s4.empty? + h[:sec_fraction] = parse_sec_fraction(s4) + end + + # s5: zone + if s5 && !s5.empty? + zone = s5 + if zone.start_with?('[') + zone = zone[1...-1] # strip brackets + # Format: [offset:zonename] or [offset zonename] or [offset] or [zonename] + if (zm = zone.match(/\A([-+]?\d+(?:[,.]\d+)?):(.+)/)) + # +9:JST, -5:EST, +12:XXX YYY ZZZ + h[:zone] = zm[2].strip + off_s = zm[1] + off_s = "+#{off_s}" unless off_s.start_with?('+') || off_s.start_with?('-') + h[:offset] = fast_zone_offset(off_s) + elsif (zm = zone.match(/\A([-+]?\d+(?:[,.]\d+)?)\s+(\S.+)/)) + # Number followed by space and non-empty name + h[:zone] = zm[2] + off_s = zm[1] + off_s = "+#{off_s}" unless off_s.start_with?('+') || off_s.start_with?('-') + h[:offset] = fast_zone_offset(off_s) + else + # Could be just a number with optional trailing space: [9], [-9], [9 ] + h[:zone] = zone + stripped = zone.strip + if stripped =~ /\A([-+]?\d+(?:[,.]\d+)?)\z/ + off_s = $1 + off_s = "+#{off_s}" unless off_s.start_with?('+') || off_s.start_with?('-') + h[:offset] = fast_zone_offset(off_s) + end + end + else + h[:zone] = zone + end end - end - # Step 4: Default time fields, clamp sec - # C: if (NIL_P(ref_hash("hour"))) set_hash("hour", 0); - # if (NIL_P(ref_hash("min"))) set_hash("min", 0); - # if (NIL_P(ref_hash("sec"))) set_hash("sec", 0); - # else if (ref_hash("sec") > 59) set_hash("sec", 59); - hash[:hour] ||= 0 - hash[:min] ||= 0 - if !hash.key?(:sec) - hash[:sec] = 0 - elsif hash[:sec] > 59 - hash[:sec] = 59 + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + true + else + false end + end - hash + def parse_bc_post(str, h) + if (m = PARSE_BC_RE.match(str)) + h[:_bc] = true + str[m.begin(0)...m.end(0)] = ' ' * (m.end(0) - m.begin(0)) + end end - # C: rt__valid_date_frags_p (date_core.c:4379) - # Tries 6 strategies to produce a valid JD from hash fragments: - # jd → ordinal → civil → commercial → wnum0 → wnum1 - def rt__valid_date_frags_p(hash, sg) - # 1. Try jd (C: rt__valid_jd_p just returns jd) - if hash[:jd] - return hash[:jd] - end - - # 2. Try ordinal: year + yday - if hash[:yday] && hash[:year] - y = hash[:year] - yd = hash[:yday] - if valid_ordinal?(y, yd, sg) - return ordinal(y, yd, sg).jd + def parse_frag(str, h) + if (m = PARSE_FRAG_RE.match(str)) + v = m[1].to_i + if h.key?(:hour) && !h.key?(:mday) + h[:mday] = v if v >= 1 && v <= 31 + elsif h.key?(:mday) && !h.key?(:hour) + h[:hour] = v if v >= 0 && v <= 24 end end + end - # 3. Try civil: year + mon + mday - if hash[:mday] && hash[:mon] && hash[:year] - y = hash[:year] - m = hash[:mon] - d = hash[:mday] - if valid_civil?(y, m, d, sg) - return new(y, m, d, sg).jd - end + # s3e: 3-element (year, month, day) disambiguation + # Faithfully mirrors the C implementation's s3e() logic. + # Arguments: y, m, d are strings (or Integer for m when month name was parsed) + def s3e(h, y, m, d, bc) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + # Fast path: y is unambiguously a year (3+ digits or signed), m and d are simple digits. + # This covers ISO "2001-02-03" but not ambiguous cases like "23/5/1999". + if y && m && d && !bc && y.is_a?(String) && m.is_a?(String) && d.is_a?(String) && + !y.start_with?("'") && !d.start_with?("'") && + y =~ /\A([-+])?\d{3,}\z/ && m =~ /\A\d+\z/ && d =~ /\A\d{1,2}\z/ + h[:year] = y.to_i + h[:_comp] = false + h[:mon] = m.to_i + h[:mday] = d.to_i + return end - # 4. Try commercial: cwyear + cweek + cwday/wday - # C: wday = ref_hash("cwday"); - # if (NIL_P(wday)) { wday = ref_hash("wday"); if wday==0 → wday=7; } - begin - wday = hash[:cwday] - if wday.nil? - wday = hash[:wday] - wday = 7 if wday && wday == 0 # Sunday: wday 0 → cwday 7 - end + m = m.to_s if m.is_a?(Integer) - if wday && hash[:cweek] && hash[:cwyear] - jd = rt__valid_commercial_p(hash[:cwyear], hash[:cweek], wday, sg) - return jd if jd - end + # Step 1: If y && m are present but d is nil, rotate: d=m, m=y, y=nil + if y && m && d.nil? + d = m + m = y + y = nil end - # 5. Try wnum0: year + wnum0 + wday (Sunday-first week, %U) - # C: wday = ref_hash("wday"); - # if (NIL_P(wday)) { wday = ref_hash("cwday"); if cwday==7 → wday=0; } - begin - wday = hash[:wday] - if wday.nil? - wday = hash[:cwday] - wday = 0 if wday && wday == 7 # Sunday: cwday 7 → wday 0 - end - - if wday && hash[:wnum0] && hash[:year] - jd = rt__valid_weeknum_p(hash[:year], hash[:wnum0], wday, 0, sg) - return jd if jd + # Step 2: If y is nil but d is present, check if d looks like a year + if y.nil? && d + ds = d.to_s + digits = ds.sub(/\A'?-?/, '').sub(/(?:st|nd|rd|th)\z/i, '') + if digits.length > 2 || ds.start_with?("'") + y = d + d = nil end end - # 6. Try wnum1: year + wnum1 + wday (Monday-first week, %W) - # C: wday = ref_hash("wday"); if NIL → wday = ref_hash("cwday"); - # if wday → wday = (wday - 1) % 7 - begin - wday = hash[:wday] - wday = hash[:cwday] if wday.nil? - if wday - wday = (wday - 1) % 7 # Convert: 0(Sun)→6, 1(Mon)→0, ..., 7(Sun)→6 + # Step 3: Parse y - extract numeric value and determine _comp flag + year_val = nil + comp_flag = nil + if y + ys_raw = y.to_s + if ys_raw.start_with?("'") + year_val = ys_raw[1..].to_i + comp_flag = true + else + # Match digits (with optional leading sign), check for trailing non-digit + if ys_raw =~ /\A[^-+\d]*([-+]?\d+)/ + num_s = $1 + rest = ys_raw[$~.end(0)..] + if rest && !rest.empty? && rest =~ /[^\d]/ + # trailing non-digit (like "st" in "1st"): this y becomes d, old d becomes y + old_d = d + d = num_s + year_val = nil + comp_flag = nil + if old_d + s3eparse_year(old_d.to_s)&.then do |v, c| + year_val = v + comp_flag = c + end + end + else + year_val = num_s.to_i + if num_s.start_with?('-') || num_s.start_with?('+') || num_s.sub(/\A[-+]/, '').length > 2 + comp_flag = false + end + end + end end + end - if wday && hash[:wnum1] && hash[:year] - jd = rt__valid_weeknum_p(hash[:year], hash[:wnum1], wday, 1, sg) - return jd if jd + # Step 4: Check m - if it looks like a year (apostrophe or > 2 digits), swap US→BE + if m.is_a?(String) + ms_digits = m.sub(/\A'?-?/, '').sub(/(?:st|nd|rd|th)\z/i, '') + if m.start_with?("'") || ms_digits.length > 2 + # Rotate: old_y=y, y=m, m=d, d=old_y_string + old_y = y + y = m + m = d + d = old_y + + # Re-parse y + ys = y.to_s.sub(/(?:st|nd|rd|th)\z/i, '') + if ys.start_with?("'") + year_val = ys[1..].to_i + comp_flag = true + elsif ys =~ /([-+]?\d+)/ + num_s = $1 + year_val = num_s.to_i + comp_flag = (num_s.start_with?('-') || num_s.start_with?('+') || num_s.sub(/\A[-+]/, '').length > 2) ? false : nil + end end end - nil - end - - # C: rt__valid_commercial_p (date_core.c:4347) - # Validates commercial date and returns JD, or nil. - def rt__valid_commercial_p(y, w, d, sg) - if valid_commercial?(y, w, d, sg) - return commercial(y, w, d, sg).jd + # Step 5: Check d - if it looks like a year, swap with y + if d.is_a?(String) + ds_digits = d.sub(/\A'?-?/, '').sub(/(?:st|nd|rd|th)\z/i, '') + if d.start_with?("'") || ds_digits.length > 2 + old_y = y + # d becomes year + ys = d.sub(/(?:st|nd|rd|th)\z/i, '') + if ys.start_with?("'") + year_val = ys[1..].to_i + comp_flag = true + elsif ys =~ /([-+]?\d+)/ + num_s = $1 + year_val = num_s.to_i + comp_flag = (num_s.start_with?('-') || num_s.start_with?('+') || num_s.sub(/\A[-+]/, '').length > 2) ? false : nil + end + d = old_y + end end - nil - end - - # C: rt__valid_weeknum_p → valid_weeknum_p → c_valid_weeknum_p (date_core.c:1009) - # Validates weeknum-based date and returns JD, or nil. - # f=0 for Sunday-first (%U), f=1 for Monday-first (%W). - def rt__valid_weeknum_p(y, w, d, f, sg) - # C: if (d < 0) d += 7; - d += 7 if d < 0 - # C: if (w < 0) { ... normalize via next year ... } - if w < 0 - rjd2 = c_weeknum_to_jd(y + 1, 1, f, f, sg) - ry2, rw2, _ = c_jd_to_weeknum(rjd2 + w * 7, f, sg) - return nil if ry2 != y - w = rw2 - end - jd = c_weeknum_to_jd(y, w, d, f, sg) - ry, rw, rd = c_jd_to_weeknum(jd, f, sg) - return nil if y != ry || w != rw || d != rd - jd - end - - # C: c_weeknum_to_jd (date_core.c:663) - # Converts (year, week_number, day_in_week, first_day_flag, sg) → JD. - # - # C formula: - # c_find_fdoy(y, sg, &rjd2, &ns2); - # rjd2 += 6; - # *rjd = (rjd2 - MOD(((rjd2 - f) + 1), 7) - 7) + 7 * w + d; - def c_weeknum_to_jd(y, w, d, f, sg) - fdoy_jd, _ = c_find_fdoy(y, sg) - fdoy_jd += 6 - (fdoy_jd - ((fdoy_jd - f + 1) % 7) - 7) + 7 * w + d - end - - # C: c_jd_to_weeknum (date_core.c:674) - # Converts JD → [year, week_number, day_in_week]. - # Class-method version (the instance method in core.rb calls self.class.send). - # - # C formula: - # c_jd_to_civil(jd, sg, &ry, ...); - # c_find_fdoy(ry, sg, &rjd, ...); - # rjd += 6; - # j = jd - (rjd - MOD((rjd - f) + 1, 7)) + 7; - # rw = DIV(j, 7); - # rd = MOD(j, 7); - def c_jd_to_weeknum(jd, f, sg) - ry, _, _ = c_jd_to_civil(jd, sg) - fdoy_jd, _ = c_find_fdoy(ry, sg) - fdoy_jd += 6 - - j = jd - (fdoy_jd - ((fdoy_jd - f + 1) % 7)) + 7 - rw = j.div(7) - rd = j % 7 - - [ry, rw, rd] - end - - # --- comp_year helpers (C's comp_year69, comp_year50) --- - def comp_year69(y) - y >= 69 ? y + 1900 : y + 2000 - end - - def comp_year50(y) - y >= 50 ? y + 1900 : y + 2000 - end - - # --- sec_fraction helper --- - def sec_fraction(frac_str) - Rational(frac_str.to_i, 10 ** frac_str.length) - end - - # ================================================================ - # Format-specific parsers (date_parse.c) - # ================================================================ - - # --- ISO 8601 --- - def date__iso8601(str) - hash = {} - return hash if str.nil? || str.empty? + # Set year + h[:year] = year_val if year_val + h[:_comp] = comp_flag unless comp_flag.nil? + h[:_bc] = true if bc - if (m = ISO8601_EXT_DATETIME_PAT.match(str)) - iso8601_ext_datetime_cb(m, hash) - elsif (m = ISO8601_BAS_DATETIME_PAT.match(str)) - iso8601_bas_datetime_cb(m, hash) - elsif (m = ISO8601_EXT_TIME_PAT.match(str)) - iso8601_time_cb(m, hash) - elsif (m = ISO8601_BAS_TIME_PAT.match(str)) - iso8601_time_cb(m, hash) - end - hash - end - - def iso8601_ext_datetime_cb(m, hash) - if m[1] - hash[:mday] = m[3].to_i if m[3] - if m[1] != '-' - y = m[1].to_i - y = comp_year69(y) if m[1].length < 4 - hash[:year] = y - end - if m[2].nil? - return false if m[1] != '-' + # Set mon + if m + if m.is_a?(String) + ms = m.sub(/(?:st|nd|rd|th)\z/i, '') + h[:mon] = $1.to_i if ms =~ /(\d+)/ else - hash[:mon] = m[2].to_i - end - elsif m[5] - hash[:yday] = m[5].to_i - if m[4] - y = m[4].to_i - y = comp_year69(y) if m[4].length < 4 - hash[:year] = y - end - elsif m[8] - hash[:cweek] = m[7].to_i - hash[:cwday] = m[8].to_i - if m[6] - y = m[6].to_i - y = comp_year69(y) if m[6].length < 4 - hash[:cwyear] = y + h[:mon] = m.to_i end - elsif m[9] - hash[:cwday] = m[9].to_i - end - - if m[10] - hash[:hour] = m[10].to_i - hash[:min] = m[11].to_i - hash[:sec] = m[12].to_i if m[12] - end - hash[:sec_fraction] = sec_fraction(m[13]) if m[13] - if m[14] - hash[:zone] = m[14] - hash[:offset] = date_zone_to_diff(m[14]) end - true - end - def iso8601_bas_datetime_cb(m, hash) - if m[3] - hash[:mday] = m[3].to_i - if m[1] != '--' - y = m[1].to_i - y = comp_year69(y) if m[1].length < 4 - hash[:year] = y - end - if m[2][0] == '-' - return false if m[1] != '--' + # Set mday + if d + if d.is_a?(String) + ds = d.sub(/(?:st|nd|rd|th)\z/i, '') + h[:mday] = $1.to_i if ds =~ /(\d+)/ else - hash[:mon] = m[2].to_i + h[:mday] = d.to_i end - elsif m[5] - hash[:yday] = m[5].to_i - y = m[4].to_i - y = comp_year69(y) if m[4].length < 4 - hash[:year] = y - elsif m[6] - hash[:yday] = m[6].to_i - elsif m[9] - hash[:cweek] = m[8].to_i - hash[:cwday] = m[9].to_i - y = m[7].to_i - y = comp_year69(y) if m[7].length < 4 - hash[:cwyear] = y - elsif m[11] - hash[:cweek] = m[10].to_i - hash[:cwday] = m[11].to_i - elsif m[12] - hash[:cwday] = m[12].to_i - end - - if m[13] - hash[:hour] = m[13].to_i - hash[:min] = m[14].to_i - hash[:sec] = m[15].to_i if m[15] - end - hash[:sec_fraction] = sec_fraction(m[16]) if m[16] - if m[17] - hash[:zone] = m[17] - hash[:offset] = date_zone_to_diff(m[17]) - end - true - end - - def iso8601_time_cb(m, hash) - hash[:hour] = m[1].to_i - hash[:min] = m[2].to_i - hash[:sec] = m[3].to_i if m[3] - hash[:sec_fraction] = sec_fraction(m[4]) if m[4] - if m[5] - hash[:zone] = m[5] - hash[:offset] = date_zone_to_diff(m[5]) end - true - end - - # --- RFC 3339 --- - - def date__rfc3339(str) - hash = {} - return hash if str.nil? || str.empty? - - m = RFC3339_PAT.match(str) - return hash unless m - - hash[:year] = m[1].to_i - hash[:mon] = m[2].to_i - hash[:mday] = m[3].to_i - hash[:hour] = m[4].to_i - hash[:min] = m[5].to_i - hash[:sec] = m[6].to_i - hash[:zone] = m[8] - hash[:offset] = date_zone_to_diff(m[8]) - hash[:sec_fraction] = sec_fraction(m[7]) if m[7] - hash end - # --- XML Schema --- - - def date__xmlschema(str) - hash = {} - return hash if str.nil? || str.empty? - - if (m = XMLSCHEMA_DATETIME_PAT.match(str)) - hash[:year] = m[1].to_i - hash[:mon] = m[2].to_i if m[2] - hash[:mday] = m[3].to_i if m[3] - hash[:hour] = m[4].to_i if m[4] - hash[:min] = m[5].to_i if m[5] - hash[:sec] = m[6].to_i if m[6] - hash[:sec_fraction] = sec_fraction(m[7]) if m[7] - if m[8] - hash[:zone] = m[8] - hash[:offset] = date_zone_to_diff(m[8]) - end - elsif (m = XMLSCHEMA_TIME_PAT.match(str)) - hash[:hour] = m[1].to_i - hash[:min] = m[2].to_i - hash[:sec] = m[3].to_i if m[3] - hash[:sec_fraction] = sec_fraction(m[4]) if m[4] - if m[5] - hash[:zone] = m[5] - hash[:offset] = date_zone_to_diff(m[5]) - end - elsif (m = XMLSCHEMA_TRUNC_PAT.match(str)) - hash[:mon] = m[1].to_i if m[1] - hash[:mday] = m[2].to_i if m[2] - hash[:mday] = m[3].to_i if m[3] - if m[4] - hash[:zone] = m[4] - hash[:offset] = date_zone_to_diff(m[4]) - end + # Helper: parse a string as a year value, returning [year_val, comp_flag] or nil + def s3eparse_year(s) + if s.start_with?("'") + [s[1..].to_i, true] + elsif s =~ /\A[^-+\d]*([-+]?\d+)/ + num_s = $1 + cf = (num_s.start_with?('-') || num_s.start_with?('+') || num_s.sub(/\A[-+]/, '').length > 2) ? false : nil + [num_s.to_i, cf] end - hash - end - - # --- RFC 2822 --- - - def date__rfc2822(str) - hash = {} - return hash if str.nil? || str.empty? - - m = PARSE_RFC2822_PAT.match(str) - return hash unless m - - hash[:wday] = day_num(m[1]) if m[1] - hash[:mday] = m[2].to_i - hash[:mon] = mon_num(m[3]) - y = m[4].to_i - y = comp_year50(y) if m[4].length < 4 - hash[:year] = y - hash[:hour] = m[5].to_i - hash[:min] = m[6].to_i - hash[:sec] = m[7].to_i if m[7] - hash[:zone] = m[8] - hash[:offset] = date_zone_to_diff(m[8]) - hash - end - - # --- HTTP date --- - - def date__httpdate(str) - hash = {} - return hash if str.nil? || str.empty? - - if (m = PARSE_HTTPDATE_TYPE1_PAT.match(str)) - hash[:wday] = day_num(m[1]) - hash[:mday] = m[2].to_i - hash[:mon] = mon_num(m[3]) - hash[:year] = m[4].to_i - hash[:hour] = m[5].to_i - hash[:min] = m[6].to_i - hash[:sec] = m[7].to_i - hash[:zone] = m[8] - hash[:offset] = 0 - elsif (m = PARSE_HTTPDATE_TYPE2_PAT.match(str)) - hash[:wday] = day_num(m[1]) - hash[:mday] = m[2].to_i - hash[:mon] = mon_num(m[3]) - y = m[4].to_i - y = comp_year69(y) if y >= 0 && y <= 99 - hash[:year] = y - hash[:hour] = m[5].to_i - hash[:min] = m[6].to_i - hash[:sec] = m[7].to_i - hash[:zone] = m[8] - hash[:offset] = 0 - elsif (m = PARSE_HTTPDATE_TYPE3_PAT.match(str)) - hash[:wday] = day_num(m[1]) - hash[:mon] = mon_num(m[2]) - hash[:mday] = m[3].to_i - hash[:hour] = m[4].to_i - hash[:min] = m[5].to_i - hash[:sec] = m[6].to_i - hash[:year] = m[7].to_i - end - hash end - # --- JIS X 0301 --- + # ------------------------------------------------------------------ + # Fast Date construction + # ------------------------------------------------------------------ - def date__jisx0301(str) - hash = {} - return hash if str.nil? || str.empty? - - m = PARSE_JISX0301_PAT.match(str) - if m - era = m[1] || JISX0301_DEFAULT_ERA - ep = gengo(era) - hash[:year] = ep + m[2].to_i - hash[:mon] = m[3].to_i - hash[:mday] = m[4].to_i - if m[5] - hash[:hour] = m[5].to_i - hash[:min] = m[6].to_i if m[6] - hash[:sec] = m[7].to_i if m[7] - end - hash[:sec_fraction] = sec_fraction(m[8]) if m[8] && !m[8].empty? - if m[9] - hash[:zone] = m[9] - hash[:offset] = date_zone_to_diff(m[9]) + # Fast Date construction: when year/mon/mday are all present and no + # complex keys (jd, yday, cwyear, wday, wnum, seconds) exist, skip + # the full _sp_complete_frags pipeline and directly validate civil date. + def fast_new_date(hash, sg) + raise Error, 'invalid date' if hash.nil? || hash.empty? + y = hash[:year] + m = hash[:mon] + d = hash[:mday] + if y && m && d && + !hash.key?(:jd) && !hash.key?(:yday) && !hash.key?(:cwyear) && + !hash.key?(:wnum0) && !hash.key?(:wnum1) && !hash.key?(:seconds) + # Ultra-fast path: inline Gregorian JD for obviously valid dates + # (year > 1582 ensures JD > ITALY for any month/day; d <= 28 is always valid) + if y >= 1583 && m >= 1 && m <= 12 && d >= 1 && d <= 28 && sg <= 2299161 + gy = m <= 2 ? y - 1 : y + a = gy / 100 + _new_from_jd((1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[m] + d - 1524 + 2 - a + a / 4, sg) + else + jd = internal_valid_civil?(y, m, d, sg) + raise Error, 'invalid date' if jd.nil? + _new_from_jd(jd, sg) end else - # Fallback to iso8601 - hash = date__iso8601(str) + _new_by_frags(hash, sg) end - hash end + end end diff --git a/lib/date/strftime.rb b/lib/date/strftime.rb index b4e3f020..d86ad7a9 100644 --- a/lib/date/strftime.rb +++ b/lib/date/strftime.rb @@ -1,5 +1,7 @@ -# Implementation of ruby/date/ext/date/date_strftime.c +# frozen_string_literal: true + class Date + # call-seq: # strftime(format = '%F') -> string # @@ -10,746 +12,563 @@ class Date # # For other formats, see # {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]. - def strftime(format = STRFTIME_DEFAULT_FMT) - # If format is not a string, convert it to a string. - format = format.to_str unless format.is_a?(String) - - # Check for ASCII compatible encoding. - raise ArgumentError, "format should have ASCII compatible encoding" unless format.encoding.ascii_compatible? - - # Empty format returns empty string - return '' if format.empty? - - # Fast path: simple Date (no time/offset, @nth == 0) with civil fields cached. - # Covers the most common case for Date objects created via Date.new or Date.civil. - if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil && !format.include?("\0") - y = @year - case format - when '%Y-%m-%d', '%F' - str = if y >= 0 && y <= 9999 - "#{FOUR_DIGIT[y]}-#{TWO_DIGIT[@month]}-#{TWO_DIGIT[@day]}" - elsif y >= 0 - sprintf("%04d-%02d-%02d", y, @month, @day) - else - sprintf("%05d-%02d-%02d", y, @month, @day) - end - return str.force_encoding(format.encoding) - when '%Y-%m-%dT%H:%M:%S%z' - str = if y >= 0 && y <= 9999 - "#{FOUR_DIGIT[y]}-#{TWO_DIGIT[@month]}-#{TWO_DIGIT[@day]}T00:00:00+0000" - elsif y >= 0 - sprintf("%04d-%02d-%02dT00:00:00+0000", y, @month, @day) - else - sprintf("%05d-%02d-%02dT00:00:00+0000", y, @month, @day) - end - return str.force_encoding(format.encoding) - when '%x' - # %x = %m/%d/%y - str = "#{TWO_DIGIT[@month]}/#{TWO_DIGIT[@day]}/#{TWO_DIGIT[y % 100]}" - return str.force_encoding(format.encoding) - end - - # Formats that also require wday (needs @jd). - if @has_jd - wday = (@jd + 1) % 7 - case format - when '%c' - # %c = %a %b %e %H:%M:%S %Y (always 24 chars for 4-digit year) - ed = @day < 10 ? " #{@day}" : @day.to_s - y_str = (y >= 0 && y <= 9999) ? FOUR_DIGIT[y] : (y >= 0 ? sprintf("%04d", y) : sprintf("%05d", y)) - str = "#{ABBR_DAYNAMES[wday]} #{ABBR_MONTHNAMES[@month]} #{ed} 00:00:00 #{y_str}" - return str.force_encoding(format.encoding) - when '%A, %B %d, %Y' - y_str = (y >= 0 && y <= 9999) ? FOUR_DIGIT[y] : (y >= 0 ? sprintf("%04d", y) : sprintf("%05d", y)) - str = "#{DAYNAMES[wday]}, #{MONTHNAMES[@month]} #{TWO_DIGIT[@day]}, #{y_str}" - return str.force_encoding(format.encoding) - end - end + def strftime(format = DEFAULT_STRFTIME_FMT) + if format.equal?(DEFAULT_STRFTIME_FMT) + _civil unless @year + return _fast_ymd.force_encoding(Encoding::US_ASCII) end - - # What to do if format string contains a "\0". - if format.include?("\0") - result = String.new - parts = format.split("\0", -1) - - parts.each_with_index do |part, i| - result << strftime_format(part) unless part.empty? - result << "\0" if i < parts.length - 1 - end - - result.force_encoding(format.encoding) - - return result + fmt = format.to_str + if fmt == YMD_FMT + _civil unless @year + return _fast_ymd.force_encoding(Encoding::US_ASCII) end - - # Normal processing without "\0" in format string. - result = strftime_format(format) - result.force_encoding(format.encoding) - - result + internal_strftime(fmt).force_encoding(fmt.encoding) end private - def tmx_year - m_real_year - end - - def tmx_mon - mon - end - - def tmx_mday - mday - end - - def tmx_yday - yday - end - - def tmx_cwyear - m_real_cwyear - end - - def tmx_cweek - cweek - end - - def tmx_cwday - cwday - end - - def tmx_wday - wday - end - - def tmx_wnum0 - # Week number (Sunday start, 00-53) - m_wnumx(0) - end - - def tmx_wnum1 - # Week number (Monday start, 00-53) - m_wnumx(1) - end - - def tmx_hour - if simple_dat_p? - 0 - else - df = df_utc_to_local(m_df, m_of) - (df / 3600).floor - end - end - - def tmx_min - if simple_dat_p? - 0 - else - df = df_utc_to_local(m_df, m_of) - ((df % 3600) / 60).floor - end - end - - def tmx_sec - if simple_dat_p? - 0 - else - df = df_utc_to_local(m_df, m_of) - df % 60 - end - end - - def tmx_sec_fraction - if simple_dat_p? - Rational(0, 1) - else - # (Decimal part of df) + sf - df_frac = m_df - m_df.floor - sf_frac = m_sf == 0 ? 0 : Rational(m_sf, SECOND_IN_NANOSECONDS) - df_frac + sf_frac + def internal_strftime(fmt) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + # Fast path for common format strings (whole-string match) + case fmt + when '%Y-%m-%d', '%F' + _civil unless @year + return _fast_ymd + when '%H:%M:%S', '%T', '%X' + return instance_of?(Date) ? +'00:00:00' : "#{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]}" + when '%m/%d/%y', '%D', '%x' + _civil unless @year + return "#{PAD2[@month]}/#{PAD2[@day]}/#{PAD2[@year.abs % 100]}" + when '%Y-%m-%dT%H:%M:%S%z' + _civil unless @year + if instance_of?(Date) + return _fast_ymd << 'T00:00:00+0000' + else + of = _of_seconds + sign = of < 0 ? '-' : '+' + abs = of.abs + return "#{_fast_ymd}T#{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]}#{sign}#{PAD2[abs / 3600]}#{PAD2[(abs % 3600) / 60]}" + end + when '%a %b %e %H:%M:%S %Y', '%c' + _civil unless @year + return _fmt_asctime_str + when '%A, %B %d, %Y' + _civil unless @year + w = (@jd + 1) % 7 + y = @year + y_s = y >= 1000 ? y.to_s : (y >= 0 ? format('%04d', y) : format('-%04d', -y)) + return "#{DAY_FULL_COMMA[w]}#{MONTH_FULL_SPACE[@month]}#{PAD2[@day]}, #{y_s}" end - end - def tmx_secs - # C: tmx_m_secs (date_core.c:7306) - # s = day_to_sec(m_real_jd - UNIX_EPOCH_IN_CJD) - # if complex: s += m_df - s = jd_to_unix_time(m_real_jd) - return s if simple_dat_p? - df = m_df - s += df if df != 0 - s - end - - def tmx_msecs - # C: tmx_m_msecs (date_core.c:7322) - # s = tmx_m_secs * 1000 - # if complex: s += m_sf / MILLISECOND_IN_NANOSECONDS - s = tmx_secs * SECOND_IN_MILLISECONDS - return s if simple_dat_p? - sf = m_sf - s += (sf / (SECOND_IN_NANOSECONDS / SECOND_IN_MILLISECONDS)).to_i if sf != 0 - s - end + result = +''.encode(fmt.encoding) + i = 0 + len = fmt.bytesize - def tmx_offset - simple_dat_p? ? 0 : m_of - end + while i < len + b = fmt.getbyte(i) - def tmx_zone - if simple_dat_p? || tmx_offset.zero? - "+00:00" - else - of2str(m_of) - end - end - - def of2str(of) - s, h, m = decode_offset(of) - sprintf('%c%02d:%02d', s, h, m) - end - - def decode_offset(of) - s = (of < 0) ? '-' : '+' - a = of.abs - h = a / HOUR_IN_SECONDS - m = (a % HOUR_IN_SECONDS) / MINUTE_IN_SECONDS - [s, h, m] - end - - # Processing format strings. - # Uses format.index('%') to scan literal sections in bulk, avoiding - # per-character String allocation from format[i] indexing. - def strftime_format(format) - result = String.new - pos = 0 - fmt_len = format.length - - # Detect simple Date (no time/offset) with both civil and JD fields cached. - # Precompute frequently accessed values to bypass the tmx_* method chain. - if @df.nil? && @sf.nil? && @of.nil? && @nth == 0 && @has_civil && @has_jd - f_year = @year - f_month = @month - f_day = @day - f_wday = (@jd + 1) % 7 - is_simple = true - else - is_simple = false - end - - while pos < fmt_len - # Find next '%' starting from current position. - pct = format.index('%', pos) - - if pct.nil? - # No more format specs — append remaining literal text as a block. - result << format[pos..] if pos < fmt_len - break + # Batch collect literal (non-%) characters + if b != 37 # '%' + lit_start = i + i += 1 + i += 1 while i < len && fmt.getbyte(i) != 37 + result << fmt.byteslice(lit_start, i - lit_start) + next end - # Append literal text before this '%' as a single block copy. - result << format[pos, pct - pos] if pct > pos - - i = pct + 1 - if i >= fmt_len - # Trailing '%' with nothing after — append as literal (matches C behavior). + i += 1 # skip '%' + if i >= len result << '%' break end - # Parse all modifiers in a flat loop (flags, width, colons, E/O). - # flags: integer bitmask (FLAG_MINUS | FLAG_SPACE | FLAG_UPPER | FLAG_CHCASE | FLAG_ZERO) - # width: integer (-1 = not specified) + # Quick dispatch: if next byte is a simple letter spec (A-Z or a-z, + # excluding E/O locale modifiers), skip flag/width/prec parsing entirely. + # Flag chars '-'(45) '_'(95) '0'(48) '^'(94) '#'(35) ':'(58) are all + # outside A-Z(65-90) and a-z(97-122) ranges. + b = fmt.getbyte(i) + if (b >= 65 && b <= 90 && b != 69 && b != 79) || (b >= 97 && b <= 122) + fast = _fast_spec(b) + if fast + result << fast + i += 1 + next + end + end + + # Parse flags (bitmask — no Hash allocation) flags = 0 - width = -1 - modifier = nil colons = 0 - - while i < fmt_len - c = format[i] - case c - when 'E', 'O' - modifier = c - i += 1 - when ':' + loop do + b = fmt.getbyte(i) + case b + when 45 then flags |= FL_LEFT # '-' + when 95 then flags |= FL_SPACE # '_' + when 48 then flags |= FL_ZERO # '0' + when 94 then flags |= FL_UPPER # '^' + when 35 then flags |= FL_CHCASE # '#' + when 58 # ':' colons += 1 i += 1 - when '-' - flags |= FLAG_MINUS - i += 1 - when '_' - flags |= FLAG_SPACE - i += 1 - when '^' - flags |= FLAG_UPPER - i += 1 - when '#' - flags |= FLAG_CHCASE - i += 1 - when '0' - # '0' is a flag only when width is not yet started - if width == -1 - flags |= FLAG_ZERO - else - width = width * 10 - end - i += 1 - when '1'..'9' - width = format[i].ord - 48 - i += 1 - # Continue reading remaining digits - while i < fmt_len - d = format[i] - break if d < '0' || d > '9' - width = width * 10 + (d.ord - 48) - i += 1 - end - else + redo if fmt.getbyte(i) == 58 break + else break end + i += 1 end - # Invalid if both E/O and colon modifiers are present. - if modifier && colons > 0 - if i < fmt_len - spec = format[i] - result << "%#{modifier}#{':' * colons}#{spec}" + # Parse width (byte range check — no Regexp) + width = nil + b = fmt.getbyte(i) + if b && b >= 48 && b <= 57 # '0'..'9' + width = b - 48 + i += 1 + b = fmt.getbyte(i) + while b && b >= 48 && b <= 57 + width = width * 10 + (b - 48) i += 1 + b = fmt.getbyte(i) end - pos = i - next - end - - # Width specifier overflow check - if width != -1 && width >= 1024 - raise Errno::ERANGE, "Result too large" + raise Errno::ERANGE, "strftime" if width > STRFTIME_MAX_WIDTH end - if i < fmt_len - spec = format[i] - - if modifier - # E/O modifier check must come first - valid = case modifier - when 'E' - %w[c C x X y Y].include?(spec) - when 'O' - %w[d e H k I l m M S u U V w W y].include?(spec) - else - false - end - - if valid - result << format_spec(spec, flags, width) - else - result << "%#{modifier}#{flags_to_s(flags)}#{width == -1 ? '' : width}#{spec}" - end - elsif spec == 'z' - if is_simple && flags == 0 && width == -1 && colons == 0 - # Simple Date: offset is always 0, result is always '+0000'. - result << '+0000' - else - result << format_z(tmx_offset, width, flags, colons) - end - elsif colons > 0 - # Colon modifier is only valid for 'z'. - result << "%#{':' * colons}#{flags_to_s(flags)}#{width == -1 ? '' : width}#{spec}" - elsif is_simple && flags == 0 && width == -1 - # Fast path: simple Date with no flags or width — bypass tmx_* method chain. - case spec - when 'Y' - raise Errno::ERANGE, "Result too large" if f_year.bit_length > 128 - if f_year >= 0 && f_year <= 9999 - result << FOUR_DIGIT[f_year] - else - result << sprintf("%0#{f_year < 0 ? 5 : 4}d", f_year) - end - when 'C' - c = f_year / 100 - result << (c >= 0 && c < 100 ? TWO_DIGIT[c] : sprintf('%02d', c)) - when 'y' - result << TWO_DIGIT[f_year % 100] - when 'm' - result << TWO_DIGIT[f_month] - when 'd' - result << TWO_DIGIT[f_day] - when 'e' - result << sprintf('%2d', f_day) - when 'A' - result << (DAYNAMES[f_wday] || '?') - when 'a' - result << (ABBR_DAYNAMES[f_wday] || '?')[0, 3] - when 'B' - result << (MONTHNAMES[f_month] || '?') - when 'b', 'h' - result << (ABBR_MONTHNAMES[f_month] || '?')[0, 3] - when 'H', 'M', 'S' - result << '00' - when 'I', 'l' - # hour=0 → h = 0%12 = 0 → h = 12 - result << '12' - when 'k' - # sprintf('%2d', 0) = ' 0' - result << ' 0' - when 'P' - result << 'am' # hour=0 < 12 - when 'p' - result << 'AM' - when 'w' - result << f_wday.to_s - when 'Z' - result << '+00:00' - when '%' - result << '%' - when 'n' - result << "\n" - when 't' - result << "\t" - else - result << format_spec(spec, flags, width) - end - else - result << format_spec(spec, flags, width) + # Parse precision (after '.') + prec = nil + if fmt.getbyte(i) == 46 # '.' + i += 1 + prec = 0 + b = fmt.getbyte(i) + while b && b >= 48 && b <= 57 + prec = prec * 10 + (b - 48) + i += 1 + b = fmt.getbyte(i) end + end + # Post-width colons (for %8:z, %11::z etc.) + while fmt.getbyte(i) == 58 # ':' + colons += 1 i += 1 end - pos = i - end - - result.force_encoding('US-ASCII') if result.ascii_only? + # Locale modifier (%E or %O) + locale_mod = nil + b = fmt.getbyte(i) + if b == 69 || b == 79 # 'E' or 'O' + locale_mod = b + i += 1 + end - result - end + spec = fmt.getbyte(i) + i += 1 - def flags_to_s(flags) - return '' if flags == 0 - s = ''.dup - s << '-' if flags & FLAG_MINUS != 0 - s << '_' if flags & FLAG_SPACE != 0 - s << '^' if flags & FLAG_UPPER != 0 - s << '#' if flags & FLAG_CHCASE != 0 - s << '0' if flags & FLAG_ZERO != 0 - s - end + # Inline fast path: no flags, no width, no prec, no locale mod, no colons + if flags == 0 && width.nil? && prec.nil? && locale_mod.nil? && colons == 0 + fast = _fast_spec(spec) + if fast + result << fast + next + end + end - def format_spec(spec, flags = 0, width = -1) - # N/L: width controls precision (number of fractional digits) - if spec == 'N' || spec == 'L' - precision = if width != -1 - width - elsif spec == 'L' - 3 - else - 9 - end - frac = tmx_sec_fraction - digits = (frac * (10 ** precision)).floor - return sprintf("%0#{precision}d", digits) + result << _format_spec_b(spec, flags, colons, width, prec, locale_mod) end - # Get basic formatting results. - base_result = get_base_format(spec, flags) - - # Apply case change flags (before width/precision) - base_result = apply_case_flags(base_result, spec, flags) - - # Apply width specifier. - if width != -1 - default_pad = if NUMERIC_SPECS.include?(spec) - '0' - elsif SPACE_PAD_SPECS.include?(spec) - ' ' - else - ' ' - end - apply_width(base_result, width, flags, default_pad) - else - base_result - end + result end - # C: Apply ^ (UPPER) and # (CHCASE) flags - def apply_case_flags(str, spec, flags) - if flags & FLAG_UPPER != 0 - str.upcase - elsif flags & FLAG_CHCASE != 0 - if CHCASE_UPPER_SPECS.include?(spec) - str.upcase - elsif CHCASE_LOWER_SPECS.include?(spec) - str.downcase - else - str.swapcase - end + # Format "%a %b %e %H:%M:%S %Y" directly (used by %c expansion and asctime) + def _fmt_asctime_str + w = (@jd + 1) % 7 + d = @day + d_s = d < 10 ? " #{d}" : d.to_s + y = @year + y_s = y >= 1000 ? y.to_s : (y >= 0 ? format('%04d', y) : format('-%04d', -y)) + if instance_of?(Date) + "#{ASCTIME_PREFIX[w][@month]}#{d_s} 00:00:00 #{y_s}" else - str + "#{ASCTIME_PREFIX[w][@month]}#{d_s} #{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]} #{y_s}" end end - # format specifiers - def get_base_format(spec, flags = 0) + # Inline fast path for common specs with default formatting (no flags/width/prec) + def _fast_spec(spec) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity case spec - when 'Y' # 4-digit year - y = tmx_year - raise Errno::ERANGE, "Result too large" if y.is_a?(Integer) && y.bit_length > 128 - # C: FMT('0', y >= 0 ? 4 : 5, "ld", y) - if flags & FLAG_MINUS != 0 - y.to_s - elsif flags & FLAG_SPACE != 0 - sprintf("%#{y < 0 ? 5 : 4}d", y) - elsif y >= 0 && y <= 9999 - FOUR_DIGIT[y] - else - sprintf("%0#{y < 0 ? 5 : 4}d", y) - end - when 'C' # Century - c = tmx_year / 100 - c >= 0 && c < 100 ? TWO_DIGIT[c] : sprintf('%02d', c) - when 'y' # Two-digit year - TWO_DIGIT[tmx_year % 100] - when 'm' # Month (01-12) - if flags & FLAG_MINUS != 0 - tmx_mon.to_s - elsif flags & FLAG_SPACE != 0 - sprintf('%2d', tmx_mon) + when 89 # 'Y' + _civil unless @year + y = @year + if y >= 1000 + s = y.to_s + raise Errno::ERANGE, "strftime" if s.length >= STRFTIME_MAX_COPY_LEN + s + elsif y >= 0 + format('%04d', y) else - TWO_DIGIT[tmx_mon] + format('-%04d', -y) end - when 'B' # Full month name - MONTHNAMES[tmx_mon] || '?' - when 'b', 'h' # Abbreviated month name - (ABBR_MONTHNAMES[tmx_mon] || '?')[0, 3] - when 'd' # Day (01-31) - if flags & FLAG_MINUS != 0 - tmx_mday.to_s - elsif flags & FLAG_SPACE != 0 - sprintf('%2d', tmx_mday) + when 109 # 'm' + _civil unless @year + PAD2[@month] + when 100 # 'd' + _civil unless @year + PAD2[@day] + when 101 # 'e' + _civil unless @year + d = @day + d < 10 ? " #{d}" : d.to_s + when 72 # 'H' + PAD2[internal_hour] + when 77 # 'M' + PAD2[internal_min] + when 83 # 'S' + PAD2[internal_sec] + when 97 # 'a' + STRFTIME_DAYS_ABBR[(@jd + 1) % 7] + when 65 # 'A' + STRFTIME_DAYS_FULL[(@jd + 1) % 7] + when 98, 104 # 'b', 'h' + _civil unless @year + STRFTIME_MONTHS_ABBR[@month] + when 66 # 'B' + _civil unless @year + STRFTIME_MONTHS_FULL[@month] + when 112 # 'p' + internal_hour < 12 ? 'AM' : 'PM' + when 80 # 'P' + internal_hour < 12 ? 'am' : 'pm' + when 37 # '%' + '%' + when 110 # 'n' + "\n" + when 116 # 't' + "\t" + when 106 # 'j' + yd = yday + if yd < 10 + "00#{yd}" + elsif yd < 100 + "0#{yd}" else - TWO_DIGIT[tmx_mday] + yd.to_s end - when 'e' # Day (1-31) blank filled - if flags & FLAG_MINUS != 0 - tmx_mday.to_s - elsif flags & FLAG_ZERO != 0 - TWO_DIGIT[tmx_mday] + when 119 # 'w' + ((@jd + 1) % 7).to_s + when 117 # 'u' + cwday.to_s + when 121 # 'y' + _civil unless @year + PAD2[@year.abs % 100] + when 90 # 'Z' + _zone_str + when 122 # 'z' + of = _of_seconds + sign = of < 0 ? '-' : '+' + abs = of.abs + "#{sign}#{PAD2[abs / 3600]}#{PAD2[(abs % 3600) / 60]}" + when 115 # 's' + ((@jd - 2440588) * 86400 - _of_seconds + internal_hour * 3600 + internal_min * 60 + internal_sec).to_s + # Composite specs — inline expansion + when 99 # 'c' + _civil unless @year + _fmt_asctime_str + when 70 # 'F' + _civil unless @year + _fast_ymd + when 84, 88 # 'T', 'X' + instance_of?(Date) ? '00:00:00' : "#{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]}" + when 68, 120 # 'D', 'x' + _civil unless @year + "#{PAD2[@month]}/#{PAD2[@day]}/#{PAD2[@year.abs % 100]}" + when 82 # 'R' + instance_of?(Date) ? '00:00' : "#{PAD2[internal_hour]}:#{PAD2[internal_min]}" + when 114 # 'r' + if instance_of?(Date) + '12:00:00 AM' else - sprintf('%2d', tmx_mday) + h = internal_hour % 12 + h = 12 if h == 0 + "#{PAD2[h]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]} #{internal_hour < 12 ? 'AM' : 'PM'}" end - when 'j' # Day of the year (001-366) - if flags & FLAG_MINUS != 0 - tmx_yday.to_s - else - sprintf('%03d', tmx_yday) + else + nil # fall through to _format_spec_b + end + end + + # Full spec handling with bitmask flags (called when _fast_spec returns nil or flags/width/prec present) + def _format_spec_b(spec, flags, colons, width, prec, locale_mod) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + # Handle %E/%O locale modifiers + if locale_mod + valid = locale_mod == 69 ? STRFTIME_E_VALID_BYTES : STRFTIME_O_VALID_BYTES # 69='E' + unless valid.include?(spec) + mod_chr = locale_mod == 69 ? 'E' : 'O' + return "%#{mod_chr}#{spec&.chr}" end - when 'H' # Hour (00-23) - if flags & FLAG_MINUS != 0 - tmx_hour.to_s - elsif flags & FLAG_SPACE != 0 - sprintf('%2d', tmx_hour) + end + + case spec + when 89, 71 # 'Y', 'G' + y = spec == 89 ? year : cwyear + _fmt_year(y, width, prec, flags) + when 67 # 'C' + cent = year.div(100) + _pad_num(cent, width || 2, flags) + when 121 # 'y' + _pad_num(year.abs % 100, width || 2, flags, zero: true) + when 103 # 'g' + _pad_num(cwyear.abs % 100, width || 2, flags, zero: true) + when 109 # 'm' + _pad_num(month, width || 2, flags, zero: true) + when 100 # 'd' + _pad_num(day, width || 2, flags, zero: true) + when 101 # 'e' + _pad_num(day, width || 2, flags, zero: false) + when 106 # 'j' + _pad_num(yday, width || 3, flags, zero: true) + when 72 # 'H' + _pad_num(internal_hour, width || 2, flags, zero: true) + when 107 # 'k' + _pad_num(internal_hour, width || 2, flags, zero: false) + when 73 # 'I' + h = internal_hour % 12 + h = 12 if h == 0 + _pad_num(h, width || 2, flags, zero: true) + when 108 # 'l' + h = internal_hour % 12 + h = 12 if h == 0 + _pad_num(h, width || 2, flags, zero: false) + when 77 # 'M' + _pad_num(internal_min, width || 2, flags, zero: true) + when 83 # 'S' + _pad_num(internal_sec, width || 2, flags, zero: true) + when 76 # 'L' + w = width || 3 + ms = (_sec_frac * (10**w)).floor + ms.to_s.rjust(w, '0') + when 78 # 'N' + w = width || prec || 9 + ns = (_sec_frac * (10**w)).floor + ns.to_s.rjust(w, '0') + when 115 # 's' + unix = (@jd - 2440588) * 86400 - _of_seconds + + internal_hour * 3600 + internal_min * 60 + internal_sec + _pad_num(unix, width || 1, flags) + when 81 # 'Q' + ms = ((@jd - 2440588) * 86400 - _of_seconds + + internal_hour * 3600 + internal_min * 60 + internal_sec) * 1000 + + (_sec_frac * 1000).floor + _pad_num(ms, width || 1, flags) + when 65 # 'A' + _fmt_str(STRFTIME_DAYS_FULL[wday], width, flags) + when 97 # 'a' + _fmt_str(STRFTIME_DAYS_ABBR[wday], width, flags) + when 66 # 'B' + _fmt_str(STRFTIME_MONTHS_FULL[month], width, flags) + when 98, 104 # 'b', 'h' + _fmt_str(STRFTIME_MONTHS_ABBR[month], width, flags) + when 112 # 'p' + _fmt_str(internal_hour < 12 ? 'AM' : 'PM', width, flags) + when 80 # 'P' + _fmt_str(internal_hour < 12 ? 'am' : 'pm', width, flags) + when 90 # 'Z' + _fmt_str(_zone_str, width, flags) + when 122 # 'z' + _fmt_z(colons, width, prec, flags) + when 117 # 'u' + _pad_num(cwday, width || 1, flags) + when 119 # 'w' + _pad_num(wday, width || 1, flags) + when 85 # 'U' + _pad_num(_week_number(0), width || 2, flags, zero: true) + when 87 # 'W' + _pad_num(_week_number(1), width || 2, flags, zero: true) + when 86 # 'V' + _pad_num(cweek, width || 2, flags, zero: true) + when 37 # '%' + '%' + when 43 # '+' + s = internal_strftime('%a %b %e %H:%M:%S %Z %Y') + _fmt_str(s, width, flags) + else + # Try composite + expansion = STRFTIME_COMPOSITE_BYTE[spec] + if expansion + s = internal_strftime(expansion) + _fmt_str(s, width, flags) else - TWO_DIGIT[tmx_hour] + "%#{spec&.chr}" end - when 'k' # Hour (0-23) blank-padded - sprintf('%2d', tmx_hour) - when 'I' # Hour (01-12) - h = tmx_hour % 12 - h = 12 if h.zero? - if flags & FLAG_MINUS != 0 - h.to_s - elsif flags & FLAG_SPACE != 0 - sprintf('%2d', h) + end + end + + # Format year (handles negative years, precision, and all flag variants) + def _fmt_year(y, width, prec, flags) + if prec + s = y.abs.to_s.rjust(prec, '0') + s = (y < 0 ? '-' : '') + s + elsif flags & FL_LEFT != 0 + s = (y < 0 ? '-' : '') + y.abs.to_s + else + default_w = y < 0 ? 5 : 4 + w = width || default_w + if flags & FL_SPACE != 0 + raw = (y < 0 ? '-' : '') + y.abs.to_s + s = raw.rjust(w, ' ') else - TWO_DIGIT[h] + s = y.abs.to_s.rjust(w - (y < 0 ? 1 : 0), '0') + s = (y < 0 ? '-' : '') + s end - when 'l' # Hour (1-12) blank filled - h = tmx_hour % 12 - h = 12 if h.zero? - sprintf('%2d', h) - when 'M' # Minutes (00-59) - if flags & FLAG_MINUS != 0 - tmx_min.to_s - elsif flags & FLAG_SPACE != 0 - sprintf('%2d', tmx_min) + end + raise Errno::ERANGE, "strftime" if s.length >= STRFTIME_MAX_COPY_LEN + if flags & (FL_UPPER | FL_CHCASE) != 0 + s.upcase + else + s + end + end + + def _pad_num(n, default_w, flags, zero: nil) + sign = n < 0 ? '-' : '' + abs = n.abs.to_s + w = default_w + + if flags & FL_LEFT != 0 + sign + abs + elsif flags & FL_SPACE != 0 || (flags & FL_ZERO == 0 && zero == false) + sign + abs.rjust(w - sign.length, ' ') + else + pad = (flags & FL_ZERO != 0 || zero) ? '0' : ' ' + sign + abs.rjust([w - sign.length, abs.length].max, pad) + end + end + + def _fmt_str(s, width, flags) + s = s.dup + if flags & FL_CHCASE != 0 + s = (s == s.upcase) ? s.downcase : s.upcase + elsif flags & FL_UPPER != 0 + s = s.upcase + end + if flags & FL_LEFT != 0 + s + elsif width + pad = flags & FL_ZERO != 0 ? '0' : ' ' + s.rjust(width, pad) + else + s + end + end + + # Week number (0=first partial week) + def _week_number(ws) + yd = yday + wd = wday # 0=Sun + if ws == 1 + # Monday-based + wd = wd == 0 ? 6 : wd - 1 + end + (yd - wd + 6).div(7) + end + + # Format %z with colons variant and GNU extension flag support + def _fmt_z(colons, width, _prec, flags) + of = _of_seconds + sign = of < 0 ? '-' : '+' + abs = of.abs + hh = abs / 3600 + mm = (abs % 3600) / 60 + ss = abs % 60 + + no_lead = flags & (FL_LEFT | FL_SPACE) != 0 + + if no_lead + case colons + when 0 + s = format('%s%d%02d', sign, hh, mm) + when 1 + s = format('%s%d:%02d', sign, hh, mm) + when 2 + s = format('%s%d:%02d:%02d', sign, hh, mm, ss) + when 3 + if ss != 0 + s = format('%s%d:%02d:%02d', sign, hh, mm, ss) + elsif mm != 0 + s = format('%s%d:%02d', sign, hh, mm) + else + s = format('%s%d', sign, hh) + end else - TWO_DIGIT[tmx_min] + s = format('%s%d:%02d', sign, hh, mm) end - when 'S' # Seconds (00-59) - if flags & FLAG_MINUS != 0 - tmx_sec.to_s - elsif flags & FLAG_SPACE != 0 - sprintf('%2d', tmx_sec) + else + case colons + when 0 + s = format('%s%02d%02d', sign, hh, mm) + when 1 + s = format('%s%02d:%02d', sign, hh, mm) + when 2 + s = format('%s%02d:%02d:%02d', sign, hh, mm, ss) + when 3 + if ss != 0 + s = format('%s%02d:%02d:%02d', sign, hh, mm, ss) + elsif mm != 0 + s = format('%s%02d:%02d', sign, hh, mm) + else + s = format('%s%02d', sign, hh) + end else - TWO_DIGIT[tmx_sec] + s = format('%s%02d:%02d', sign, hh, mm) end - when 'L' # Milliseconds (000-999) - sprintf('%09d', (tmx_sec_fraction * 1_000_000_000).floor) - when 'N' # Fractional seconds digits - # C: width controls precision (number of digits), default 9. - # %3N → 3 digits (milliseconds), %6N → 6 digits (microseconds), - # %9N → 9 digits (nanoseconds), %12N → 12 digits (picoseconds, zero-padded). - # The 'width' variable is handled specially in format_spec for 'N'. - sprintf('%09d', (tmx_sec_fraction * 1_000_000_000).floor) - when 'P' # am/pm - tmx_hour < 12 ? 'am' : 'pm' - when 'p' # AM/PM - tmx_hour < 12 ? 'AM' : 'PM' - when 'A' # Full name of the day of the week - DAYNAMES[tmx_wday] || '?' - when 'a' # Abbreviated day of the week - (ABBR_DAYNAMES[tmx_wday] || '?')[0, 3] - when 'w' # Day of the week (0-6, Sunday is 0) - tmx_wday.to_s - when 'u' # Day of the week (1-7, Monday is 1) - tmx_cwday.to_s - when 'U' # Week number (00-53, Sunday start) - TWO_DIGIT[tmx_wnum0] - when 'W' # Week number (00-53, Monday start) - TWO_DIGIT[tmx_wnum1] - when 'V' # ISO week number (01-53) - TWO_DIGIT[tmx_cweek] - when 'G' # ISO week year - y = tmx_cwyear - if flags & FLAG_MINUS != 0 - y.to_s - elsif flags & FLAG_SPACE != 0 - sprintf("%#{y < 0 ? 5 : 4}d", y) - elsif y >= 0 && y <= 9999 - FOUR_DIGIT[y] + end + + if width + if flags & FL_LEFT != 0 + s + elsif flags & FL_SPACE != 0 + s.rjust(width, ' ') else - sprintf("%0#{y < 0 ? 5 : 4}d", y) + digits = s[1..] + sign + digits.rjust(width - 1, '0') end - when 'g' # ISO week year (2 digits) - TWO_DIGIT[tmx_cwyear % 100] - when 'z' # Time Zone Offset (+0900) — handled by format_z in format_spec - format_z(tmx_offset, -1, 0, 0) - when 'Z' # Time Zone Name - tmx_zone || '' - when 's' # Number of seconds since the Unix epoch - tmx_secs.to_s - when 'Q' # Milliseconds since the Unix epoch - tmx_msecs.to_s - when 'n' # Line breaks - "\n" - when 't' # Tab - "\t" - when '%' # % symbol - '%' - when 'F' # %Y-%m-%d - strftime_format('%Y-%m-%d') - when 'D' # %m/%d/%y - strftime_format('%m/%d/%y') - when 'x' # %m/%d/%y - strftime_format('%m/%d/%y') - when 'T', 'X' # %H:%M:%S - strftime_format('%H:%M:%S') - when 'R' # %H:%M - strftime_format('%H:%M') - when 'r' # %I:%M:%S %p - strftime_format('%I:%M:%S %p') - when 'c' # %a %b %e %H:%M:%S %Y - strftime_format('%a %b %e %H:%M:%S %Y') - when 'v' # %e-%^b-%Y (3-FEB-2001 format) - day_str = sprintf('%2d', tmx_mday) - month_str = (ABBR_MONTHNAMES[tmx_mon] || '?')[0, 3].upcase - year_str = sprintf('%04d', tmx_year) - "#{day_str}-#{month_str}-#{year_str}" - when '+' # %a %b %e %H:%M:%S %Z %Y - strftime_format('%a %b %e %H:%M:%S %Z %Y') else - # Unknown specifiers are output as is. - "%#{spec}" + s end end - def apply_width(str, width, flags, default_pad = ' ') - # '-' flag means no padding at all - return str if flags & FLAG_MINUS != 0 - return str if str.length >= width - - # Determine a padding character. - padding = - if flags & FLAG_ZERO != 0 - '0' - elsif flags & FLAG_SPACE != 0 - ' ' - else - default_pad - end + # Fast path helper: format '%Y-%m-%d' without allocation overhead + def _fast_ymd + y = @year + suffix = MONTH_DAY_SUFFIX[@month][@day] + if y >= 1000 + y.to_s << suffix + elsif y >= 0 + format('%04d', y) << suffix + else + format('-%04d', -y) << suffix + end + end - str.rjust(width, padding) + # Helpers for DateTime override + def internal_hour + 0 end - # C: format %z with width/flags/colons support - # Matches date_strftime.c case 'z' logic exactly. - # width: integer (-1 = not specified), flags: integer bitmask - def format_z(offset, width, flags, colons) - sign = offset < 0 ? '-' : '+' - aoff = offset.abs - hours = aoff / 3600 - minutes = (aoff % 3600) / 60 - seconds = aoff % 60 - - hl = hours < 10 ? 1 : 2 # actual digits needed for hours - hw = 2 # default hour width - hw = 1 if flags & FLAG_MINUS != 0 && hl == 1 - - precision = width # -1 means not specified - - # Calculate fixed chars (everything except hour digits) per colons variant - fixed = case colons - when 0 then 3 # sign(1) + mm(2) - when 1 then 4 # sign(1) + :(1) + mm(2) - when 2 then 7 # sign(1) + :(1) + mm(2) + :(1) + ss(2) - when 3 - if (aoff % 3600).zero? - 1 # sign(1) only - elsif (aoff % 60).zero? - 4 # sign(1) + :(1) + mm(2) - else - 7 # sign(1) + :(1) + mm(2) + :(1) + ss(2) - end - else - 3 - end - - # C: hour_precision = precision <= (fixed + hw) ? hw : precision - fixed - hp = precision <= (fixed + hw) ? hw : precision - fixed - - result = String.new - - # C: space padding — print spaces before sign, reduce hour precision - if flags & FLAG_SPACE != 0 && hp > hl - result << ' ' * (hp - hl) - hp = hl - end + def internal_min + 0 + end - result << sign - result << sprintf("%0#{hp}d", hours) - - # Append minutes/seconds based on colons - case colons - when 0 - result << sprintf('%02d', minutes) - when 1 - result << sprintf(':%02d', minutes) - when 2 - result << sprintf(':%02d:%02d', minutes, seconds) - when 3 - unless (aoff % 3600).zero? - result << sprintf(':%02d', minutes) - unless (aoff % 60).zero? - result << sprintf(':%02d', seconds) - end - end - end + def internal_sec + 0 + end - result + def _sec_frac + Rational(0) end - def jd_to_unix_time(jd) - unix_epoch_jd = 2440588 - (jd - unix_epoch_jd) * DAY_IN_SECONDS + def _of_seconds + 0 end + + def _zone_str + '+00:00' + end + end diff --git a/lib/date/strptime.rb b/lib/date/strptime.rb index d4889ca6..d343ff52 100644 --- a/lib/date/strptime.rb +++ b/lib/date/strptime.rb @@ -1,7 +1,5 @@ # frozen_string_literal: true -require 'strscan' -# Implementation of ruby/date/ext/date/date_strptime.c class Date class << self # call-seq: @@ -20,167 +18,25 @@ class << self # # Related: Date.strptime (returns a \Date object). def _strptime(string, format = '%F') - # Fast paths for the most common format strings. - case format - when '%F', '%Y-%m-%d' - m = /\A([+-]?\d+)-(\d{1,2})-(\d{1,2})/.match(string) - return nil unless m - mon = m[2].to_i - mday = m[3].to_i - return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 - h = { year: m[1].to_i, mon: mon, mday: mday } - rest = m.post_match - h[:leftover] = rest unless rest.empty? - return h - - when '%Y-%m-%d %H:%M:%S' - m = /\A([+-]?\d+)-(\d{1,2})-(\d{1,2}) (\d{1,2}):(\d{1,2}):(\d{1,2})/.match(string) - return nil unless m - mon = m[2].to_i - mday = m[3].to_i - hour = m[4].to_i - min = m[5].to_i - sec = m[6].to_i - return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 - return nil if hour > 24 || min > 59 || sec > 60 - h = { year: m[1].to_i, mon: mon, mday: mday, hour: hour, min: min, sec: sec } - rest = m.post_match - h[:leftover] = rest unless rest.empty? - return h - - when '%Y-%m-%dT%H:%M:%S' - m = /\A([+-]?\d+)-(\d{1,2})-(\d{1,2})T(\d{1,2}):(\d{1,2}):(\d{1,2})/.match(string) - return nil unless m - mon = m[2].to_i - mday = m[3].to_i - hour = m[4].to_i - min = m[5].to_i - sec = m[6].to_i - return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 - return nil if hour > 24 || min > 59 || sec > 60 - h = { year: m[1].to_i, mon: mon, mday: mday, hour: hour, min: min, sec: sec } - rest = m.post_match - h[:leftover] = rest unless rest.empty? - return h - end - - ss = StringScanner.new(string) + string = String === string ? string : string.to_str + format = String === format ? format : format.to_str + if format == '%F' || format == '%Y-%m-%d' + return _strptime_ymd(string) + end + if format == '%a %b %d %Y' + return _strptime_abdy(string) + end hash = {} - - i = 0 - fmt_len = format.length - while i < fmt_len - fb = format.getbyte(i) - if fb == 37 && i + 1 < fmt_len # '%' - i += 1 - - # Parse modifier (E, O) - modifier = nil - fb2 = format.getbyte(i) - if i < fmt_len && (fb2 == 69 || fb2 == 79) # 'E' == 69, 'O' == 79 - modifier = fb2 == 69 ? 'E' : 'O' - i += 1 - end - - # Parse colons for %:z, %::z, %:::z - colons = 0 - while i < fmt_len && format.getbyte(i) == 58 # ':' - colons += 1 - i += 1 - end - - # Parse width as integer (avoids String allocation and regex digit check) - field_width = nil - while i < fmt_len - db = format.getbyte(i) - break if db < 48 || db > 57 # '0'..'9' - field_width = (field_width || 0) * 10 + db - 48 - i += 1 - end - - break if i >= fmt_len - - spec = format[i] - i += 1 - - # Handle E/O modifier validity - if modifier - valid = case modifier - when 'E' - %w[c C x X y Y].include?(spec) - when 'O' - %w[d e H I m M S u U V w W y].include?(spec) - else - false - end - unless valid - literal = "%#{modifier}#{':' * colons}#{field_width}#{spec}" - if ss.string[ss.pos, literal.length] == literal - ss.pos += literal.length - else - return nil - end - next - end - end - - # Handle colon+z - if colons > 0 && spec == 'z' - result = _strptime_zone_colon(ss.string, ss.pos, colons) - return nil unless result - ss.pos = result[:pos] - hash[:zone] = result[:zone] - hash[:offset] = result[:offset] - next - elsif colons > 0 - # Invalid colon usage - return nil - end - - # C: NUM_PATTERN_P() - check if next format element is a digit-consuming pattern. - next_is_num = num_pattern_p(format, i) - - return nil unless _strptime_spec(ss, spec, field_width, hash, next_is_num) - elsif fb == 37 && i + 1 == fmt_len # Trailing % - match literal - if ss.string.getbyte(ss.pos) == 37 # '%' - ss.pos += 1 - else - return nil - end - i += 1 - elsif fb == 32 || fb == 9 || fb == 10 || fb == 13 || fb == 11 || fb == 12 # whitespace - # Whitespace in format matches zero or more whitespace in input - i += 1 - skip_ws(ss) - else - # Literal match - if ss.string.getbyte(ss.pos) == fb - ss.pos += 1 - else - return nil - end - i += 1 - end + si = _sp_run(string, 0, format, hash) + return nil if hash.delete(:_fail) + hash[:leftover] = string[si..] if si < string.length + if (cent = hash.delete(:_cent)) + hash[:year] = hash[:year] + cent * 100 if hash.key?(:year) + hash[:cwyear] = hash[:cwyear] + cent * 100 if hash.key?(:cwyear) end - - # Store leftover if any - hash[:leftover] = ss.rest unless ss.eos? - - # --- Post-processing (C: date__strptime, date_strptime.c:524-546) --- - - # C: cent = del_hash("_cent"); - hash.delete(:_century) - hash.delete(:_century_set) - - # C: merid = del_hash("_merid"); - merid = hash.delete(:_merid) - if merid - hour = hash[:hour] - if hour - hash[:hour] = (hour % 12) + merid - end + if (merid = hash.delete(:_merid)) + hash[:hour] = hash[:hour] % 12 + merid if hash.key?(:hour) end - hash end @@ -208,621 +64,1429 @@ def _strptime(string, format = '%F') # # Related: Date._strptime (returns a hash). def strptime(string = JULIAN_EPOCH_DATE, format = '%F', start = DEFAULT_SG) + str = String === string ? string : string.to_str + if format == '%F' || format == '%Y-%m-%d' + result = _strptime_ymd_to_date(str, start) + return result if result + raise Error, 'invalid date' + end + if format == '%a %b %d %Y' + result = _strptime_abdy_to_date(str, start) + return result if result + raise Error, 'invalid date' + end hash = _strptime(string, format) - raise Error, "invalid strptime format - `#{format}'" unless hash - - # Apply comp for 2-digit year - if hash[:year] && !hash[:_century_set] - # If year came from %y (2-digit), comp_year69 was already applied + raise Error, 'invalid date' if hash.nil? + if !hash.key?(:seconds) && !hash.key?(:leftover) && + !hash.key?(:_cent) && !hash.key?(:_merid) && + (year = hash[:year]) && (mon = hash[:mon]) && (mday = hash[:mday]) + jd = internal_valid_civil?(year, mon, mday, start) + raise Error, 'invalid date' if jd.nil? + return _new_from_jd(jd, start) end - - new_by_frags(hash, start) + _new_by_frags(hash, start) end - private - # Advances StringScanner past zero or more ASCII whitespace bytes - # (space=32, tab=9, LF=10, CR=13, VT=11, FF=12). - # Avoids regex overhead compared to ss.skip(/[ \t\n\r\v\f]*/). - def skip_ws(ss) - str = ss.string - p = ss.pos - len = str.length - while p < len - b = str.getbyte(p) - break unless b == 32 || b == 9 || b == 10 || b == 13 || b == 11 || b == 12 - p += 1 - end - ss.pos = p - end + private - # Scans unsigned decimal integer from +str+ at +pos+, up to +max+ digits. - # Returns [value, new_pos] or nil if no digit found. - def scan_uint(str, pos, max) - val = 0 - count = 0 - len = str.length - while count < max && pos + count < len - b = str.getbyte(pos + count) - break unless b >= 48 && b <= 57 # '0'..'9' - val = val * 10 + b - 48 - count += 1 - end - count > 0 ? [val, pos + count] : nil + # Returns true if the format at position fi starts a numeric conversion spec. + # All byte-level comparison, no String allocation. + def _sp_num_p_b?(fmt, fi, flen) + return false if fi >= flen + c = fmt.getbyte(fi) + return true if c >= 48 && c <= 57 # '0'..'9' + if c == 37 # '%' + i = fi + 1 + return false if i >= flen + c2 = fmt.getbyte(i) + if c2 == 69 || c2 == 79 # 'E' or 'O' + i += 1 + return false if i >= flen + c2 = fmt.getbyte(i) + end + return STRPTIME_NUMERIC_SPEC_SET[c2] + end + false end - # Scans signed decimal integer (optional leading +/-) from +str+ at +pos+. - # Returns [value, new_pos] or nil if no digit found. - def scan_sint(str, pos, max) - b = str.getbyte(pos) - if b == 43 # '+' - result = scan_uint(str, pos + 1, max) - result - elsif b == 45 # '-' - result = scan_uint(str, pos + 1, max) - result ? [-result[0], result[1]] : nil - else - scan_uint(str, pos, max) + # Read up to max_w decimal digits from str starting at si. + # Returns [value, chars_consumed] or [nil, 0] if no digit found. + def _sp_digits(str, si, slen, max_w) + l = 0 + v = 0 + while si + l < slen + c = str.getbyte(si + l) + break unless c && c >= 48 && c <= 57 # '0'..'9' + break if l >= max_w + v = v * 10 + (c - 48) + l += 1 end + return nil, 0 if l == 0 + return v, l end - # C: num_pattern_p (date_strptime.c:48) - # Returns true if the format string at position `i` starts with a - # digit-consuming pattern (a literal digit or a %-specifier that reads digits). - # Uses byte-level operations to avoid String allocations. - def num_pattern_p(format, i) - return false if i >= format.length - b = format.getbyte(i) - return true if b >= 48 && b <= 57 # '0'..'9' - if b == 37 # '%' - i += 1 - return false if i >= format.length - b2 = format.getbyte(i) - # Skip E/O modifier (E=69, O=79) - if b2 == 69 || b2 == 79 - i += 1 - return false if i >= format.length - b2 = format.getbyte(i) - end - return true if (b2 >= 48 && b2 <= 57) || NUM_PATTERN_SPECS_TABLE[b2] - end - false + # Whitespace byte check (space, tab, newline, carriage return, vertical tab, form feed) + def _sp_ws?(b) + b == 32 || b == 9 || b == 10 || b == 13 || b == 11 || b == 12 end - # Modifies +hash+ in-place with parsed values for +spec+. - # Advances +ss+ position on success. Returns true on success, nil on failure. - def _strptime_spec(ss, spec, width, hash, next_is_num = false) - str = ss.string - pos = ss.pos - - case spec - when 'Y' # Full year (possibly negative) - year, new_pos = scan_sint(str, pos, width || (next_is_num ? 4 : 40)) - return nil unless year - hash[:year] = year - ss.pos = new_pos - true - - when 'C' # Century - century, new_pos = scan_sint(str, pos, width || (next_is_num ? 2 : 40)) - return nil unless century - hash[:_century] = century - if hash[:year] && !hash[:_century_set] - hash[:year] = century * 100 + (hash[:year] % 100) - hash[:_century_set] = true - end - ss.pos = new_pos - true - - when 'y' # 2-digit year - y, new_pos = scan_uint(str, pos, width || 2) - return nil unless y - if hash[:_century] - hash[:year] = hash[:_century] * 100 + y - hash[:_century_set] = true - else - hash[:year] = y >= 69 ? y + 1900 : y + 2000 - end - ss.pos = new_pos - true - - when 'm' # Month (01-12) - mon, new_pos = scan_uint(str, pos, width || 2) - return nil unless mon - return nil if mon < 1 || mon > 12 - hash[:mon] = mon - ss.pos = new_pos - true - - when 'd', 'e' # Day of month - if str.getbyte(pos) == 32 # ' ' - day, new_pos = scan_uint(str, pos + 1, 1) - return nil unless day - return nil if day < 1 || day > 31 - hash[:mday] = day - ss.pos = new_pos - else - day, new_pos = scan_uint(str, pos, width || 2) - return nil unless day - return nil if day < 1 || day > 31 - hash[:mday] = day - ss.pos = new_pos - end - true - - when 'j' # Day of year (001-366) - yday, new_pos = scan_uint(str, pos, width || 3) - return nil unless yday - return nil if yday < 1 || yday > 366 - hash[:yday] = yday - ss.pos = new_pos - true - - when 'H', 'k' # Hour (00-24) - if str.getbyte(pos) == 32 # ' ' - hour, new_pos = scan_uint(str, pos + 1, 1) - return nil unless hour - return nil if hour > 24 - hash[:hour] = hour - ss.pos = new_pos - else - hour, new_pos = scan_uint(str, pos, width || 2) - return nil unless hour - return nil if hour > 24 - hash[:hour] = hour - ss.pos = new_pos + # Core scanner: walks format string and string simultaneously. + # All comparisons use getbyte for zero-allocation byte-level operation. + # Returns new string index si on success. + # Sets hash[:_fail]=true and returns -1 on failure. + def _sp_run(str, si, fmt, hash) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + fi = 0 + flen = fmt.bytesize + slen = str.bytesize + + while fi < flen + ch = fmt.getbyte(fi) + + # Whitespace in format: skip any whitespace in both format and string + if _sp_ws?(ch) + while si < slen && _sp_ws?(str.getbyte(si)) + si += 1 + end + fi += 1 + while fi < flen && _sp_ws?(fmt.getbyte(fi)) + fi += 1 + end + next end - true - - when 'I', 'l' # Hour (01-12) - if str.getbyte(pos) == 32 # ' ' - hour, new_pos = scan_uint(str, pos + 1, 1) - return nil unless hour - return nil if hour < 1 || hour > 12 - hash[:hour] = hour - ss.pos = new_pos - else - hour, new_pos = scan_uint(str, pos, width || 2) - return nil unless hour - return nil if hour < 1 || hour > 12 - hash[:hour] = hour - ss.pos = new_pos + + if ch != 37 # '%' + if si >= slen + hash[:_fail] = true + return -1 + end + if str.getbyte(si) != ch + hash[:_fail] = true + return -1 + end + si += 1 + fi += 1 + next end - true - - when 'M' # Minute (00-59) - min, new_pos = scan_uint(str, pos, width || 2) - return nil unless min - return nil if min > 59 - hash[:min] = min - ss.pos = new_pos - true - - when 'S' # Second (00-60) - sec, new_pos = scan_uint(str, pos, width || 2) - return nil unless sec - return nil if sec > 60 - hash[:sec] = sec - ss.pos = new_pos - true - - when 'L' # Milliseconds — normalize digit string to 3-digit precision - w = width || (next_is_num ? 3 : 40) - val, count = 0, 0 - str_len = str.length - while count < w && pos + count < str_len - b = str.getbyte(pos + count) - break unless b >= 48 && b <= 57 - val = val * 10 + b - 48 - count += 1 + + fi += 1 # skip '%' + + # Handle colon modifiers: %:z, %::z, %:::z + colons = 0 + while fi < flen && fmt.getbyte(fi) == 58 # ':' + colons += 1 + fi += 1 end - return nil if count == 0 - val *= 10 ** (3 - count) if count < 3 - val /= 10 ** (count - 3) if count > 3 - hash[:sec_fraction] = Rational(val, 1000) - ss.pos = pos + count - true - - when 'N' # Nanoseconds — normalize digit string to 9-digit precision - w = width || (next_is_num ? 9 : 40) - val, count = 0, 0 - str_len = str.length - while count < w && pos + count < str_len - b = str.getbyte(pos + count) - break unless b >= 48 && b <= 57 - val = val * 10 + b - 48 - count += 1 + if colons > 0 + unless fi < flen && fmt.getbyte(fi) == 122 # 'z' + hash[:_fail] = true + return -1 + end + fi += 1 + new_si = _sp_zone(str, si, slen, hash) + if new_si < 0 + hash[:_fail] = true + return -1 + end + si = new_si + next end - return nil if count == 0 - val *= 10 ** (9 - count) if count < 9 - val /= 10 ** (count - 9) if count > 9 - hash[:sec_fraction] = Rational(val, 1_000_000_000) - ss.pos = pos + count - true - - when 'p', 'P' # AM/PM - m = ss.scan(/a\.?m\.?|p\.?m\.?/i) - return nil unless m - ampm = m.delete('.').upcase - hash[:_merid] = (ampm == 'PM') ? 12 : 0 - true - - when 'A', 'a' # Day name (full or abbreviated) - # Zero-alloc integer key from 3 bytes (lowercase via | 0x20). - # Check byte 4 to skip full-name string comparison in the common case. - b0 = str.getbyte(pos) - b1 = str.getbyte(pos + 1) - b2 = str.getbyte(pos + 2) - if b0 && b1 && b2 - k0 = b0 | 0x20; k1 = b1 | 0x20; k2 = b2 | 0x20 - if k0 >= 97 && k0 <= 122 && k1 >= 97 && k1 <= 122 && k2 >= 97 && k2 <= 122 - ikey = (k0 << 16) | (k1 << 8) | k2 - if (info = STRPTIME_DAYNAME_BY_INT_KEY[ikey]) - idx, full, full_len, abbr_len = info - b3 = str.getbyte(pos + abbr_len) - # If next byte is non-alpha, it's an abbreviated name. - if b3.nil? || (t = b3 | 0x20) < 97 || t > 122 - hash[:wday] = idx - ss.pos = pos + abbr_len - elsif str[pos, full_len]&.downcase == full - hash[:wday] = idx - ss.pos = pos + full_len - else - hash[:wday] = idx - ss.pos = pos + abbr_len - end - true + + # Handle E/O locale modifiers + fb = fi < flen ? fmt.getbyte(fi) : nil + if fb == 69 || fb == 79 # 'E' or 'O' + valid_set = fb == 69 ? STRPTIME_E_VALID_SET : STRPTIME_O_VALID_SET + fb2 = fi + 1 < flen ? fmt.getbyte(fi + 1) : nil + if fb2 && valid_set[fb2] + fi += 1 # skip E/O, fall through to handle spec + else + # Invalid combo: match '%' literally in string + if si >= slen || str.getbyte(si) != 37 # '%' + hash[:_fail] = true + return -1 end + si += 1 + next end end - when 'B', 'b', 'h' # Month name (full or abbreviated) - # Zero-alloc integer key from 3 bytes (lowercase via | 0x20). - b0 = str.getbyte(pos) - b1 = str.getbyte(pos + 1) - b2 = str.getbyte(pos + 2) - if b0 && b1 && b2 - k0 = b0 | 0x20; k1 = b1 | 0x20; k2 = b2 | 0x20 - if k0 >= 97 && k0 <= 122 && k1 >= 97 && k1 <= 122 && k2 >= 97 && k2 <= 122 - ikey = (k0 << 16) | (k1 << 8) | k2 - if (info = STRPTIME_MONNAME_BY_INT_KEY[ikey]) - idx, full, full_len, abbr_len = info - b3 = str.getbyte(pos + abbr_len) - if b3.nil? || (t = b3 | 0x20) < 97 || t > 122 - hash[:mon] = idx - ss.pos = pos + abbr_len - elsif str[pos, full_len]&.downcase == full - hash[:mon] = idx - ss.pos = pos + full_len - else - hash[:mon] = idx - ss.pos = pos + abbr_len - end - true + spec = fi < flen ? fmt.getbyte(fi) : nil + fi += 1 + + case spec + when 65, 97 # 'A', 'a' + # Weekday name: 3-byte key O(1) lookup + if si + 2 >= slen + hash[:_fail] = true + return -1 + end + key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + entry = ABBR_DAY_3KEY[key] + unless entry + hash[:_fail] = true + return -1 + end + wday_i = entry[0] + day_full_len = entry[1] + if si + day_full_len <= slen && _sp_head_match?(str, si, slen, DAY_LOWER_BYTES[wday_i], day_full_len) + si += day_full_len + else + si += 3 + end + hash[:wday] = wday_i + + when 66, 98, 104 # 'B', 'b', 'h' + # Month name: 3-byte key O(1) lookup + if si + 2 >= slen + hash[:_fail] = true + return -1 + end + key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + entry = ABBR_MONTH_3KEY[key] + unless entry + hash[:_fail] = true + return -1 + end + mon_i = entry[0] + mon_full_len = entry[1] + if si + mon_full_len <= slen && _sp_head_match?(str, si, slen, MONTH_LOWER_BYTES[mon_i], mon_full_len) + si += mon_full_len + else + si += 3 + end + hash[:mon] = mon_i + + when 67 # 'C' + # Century: greedy unless next spec is numeric + w = _sp_num_p_b?(fmt, fi, flen) ? 2 : 10000 + sb = si < slen ? str.getbyte(si) : nil + if sb == 43 || sb == 45 # '+' or '-' + sign = sb == 45 ? -1 : 1 + si += 1 + else + sign = 1 + end + n, l = _sp_digits(str, si, slen, w) + if l == 0 + hash[:_fail] = true + return -1 + end + si += l + hash[:_cent] = sign * n + + when 99 # 'c' + new_si = _sp_run(str, si, '%a %b %e %H:%M:%S %Y', hash) + return new_si if new_si < 0 + si = new_si + + when 68 # 'D' + new_si = _sp_run(str, si, '%m/%d/%y', hash) + return new_si if new_si < 0 + si = new_si + + when 100, 101 # 'd', 'e' + # Day of month (leading space allowed for single-digit) - inlined + if si < slen && str.getbyte(si) == 32 # ' ' + si += 1 + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + else + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + b = si < slen ? str.getbyte(si) : nil + if b && b >= 48 && b <= 57 + n = n * 10 + (b - 48) + si += 1 end end - end + if n < 1 || n > 31 + hash[:_fail] = true + return -1 + end + hash[:mday] = n + + when 70 # 'F' + new_si = _sp_run(str, si, '%Y-%m-%d', hash) + return new_si if new_si < 0 + si = new_si + + when 71 # 'G' + # ISO week-based year: greedy unless next spec is numeric + sb = si < slen ? str.getbyte(si) : nil + if sb == 43 || sb == 45 # '+' or '-' + sign = sb == 45 ? -1 : 1 + si += 1 + else + sign = 1 + end + w = _sp_num_p_b?(fmt, fi, flen) ? 4 : 10000 + n, l = _sp_digits(str, si, slen, w) + if l == 0 + hash[:_fail] = true + return -1 + end + si += l + hash[:cwyear] = sign * n + + when 103 # 'g' + # 2-digit ISO week year + n, l = _sp_digits(str, si, slen, 2) + if l == 0 || n > 99 + hash[:_fail] = true + return -1 + end + si += l + hash[:cwyear] = n + hash[:_cent] ||= n >= 69 ? 19 : 20 + + when 72, 107 # 'H', 'k' + # 24-hour clock (leading space allowed) - inlined + if si < slen && str.getbyte(si) == 32 # ' ' + si += 1 + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + else + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + b = si < slen ? str.getbyte(si) : nil + if b && b >= 48 && b <= 57 + n = n * 10 + (b - 48) + si += 1 + end + end + if n > 24 + hash[:_fail] = true + return -1 + end + hash[:hour] = n + + when 73, 108 # 'I', 'l' + # 12-hour clock (leading space allowed) - inlined + if si < slen && str.getbyte(si) == 32 # ' ' + si += 1 + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + else + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + b = si < slen ? str.getbyte(si) : nil + if b && b >= 48 && b <= 57 + n = n * 10 + (b - 48) + si += 1 + end + end + if n < 1 || n > 12 + hash[:_fail] = true + return -1 + end + hash[:hour] = n + + when 106 # 'j' + # Day of year (3-digit) + n, l = _sp_digits(str, si, slen, 3) + if l == 0 || n < 1 || n > 366 + hash[:_fail] = true + return -1 + end + si += l + hash[:yday] = n + + when 76 # 'L' + # Milliseconds: greedy unless next spec is numeric + sb = si < slen ? str.getbyte(si) : nil + if sb == 43 || sb == 45 # '+' or '-' + sign = sb == 45 ? -1 : 1 + si += 1 + else + sign = 1 + end + osi = si + w = _sp_num_p_b?(fmt, fi, flen) ? 3 : 10000 + n, l = _sp_digits(str, si, slen, w) + if l == 0 + hash[:_fail] = true + return -1 + end + si += l + n = -n if sign == -1 + hash[:sec_fraction] = Rational(n, 10**(si - osi)) + + when 77 # 'M' + # Minute - inlined + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + b = si < slen ? str.getbyte(si) : nil + if b && b >= 48 && b <= 57 + n = n * 10 + (b - 48) + si += 1 + end + if n > 59 + hash[:_fail] = true + return -1 + end + hash[:min] = n + + when 109 # 'm' + # Month - inlined + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + b = si < slen ? str.getbyte(si) : nil + if b && b >= 48 && b <= 57 + n = n * 10 + (b - 48) + si += 1 + end + if n < 1 || n > 12 + hash[:_fail] = true + return -1 + end + hash[:mon] = n + + when 78 # 'N' + # Nanoseconds (or sub-second fraction): greedy unless next spec is numeric + sb = si < slen ? str.getbyte(si) : nil + if sb == 43 || sb == 45 # '+' or '-' + sign = sb == 45 ? -1 : 1 + si += 1 + else + sign = 1 + end + osi = si + w = _sp_num_p_b?(fmt, fi, flen) ? 9 : 10000 + n, l = _sp_digits(str, si, slen, w) + if l == 0 + hash[:_fail] = true + return -1 + end + si += l + n = -n if sign == -1 + hash[:sec_fraction] = Rational(n, 10**(si - osi)) + + when 110, 116 # 'n', 't' + # Match any whitespace + new_si = _sp_run(str, si, ' ', hash) + return new_si if new_si < 0 + si = new_si + + when 80, 112 # 'P', 'p' + # AM/PM with optional dot notation (A.M./P.M.) + if si >= slen + hash[:_fail] = true + return -1 + end + c0 = str.getbyte(si) + if c0 == 80 || c0 == 112 # 'P' or 'p' + merid = 12 + elsif c0 == 65 || c0 == 97 # 'A' or 'a' + merid = 0 + else + hash[:_fail] = true + return -1 + end + if si + 1 < slen && str.getbyte(si + 1) == 46 # '.' + # Dot notation: X.M. + if si + 3 >= slen || str.getbyte(si + 3) != 46 # '.' + hash[:_fail] = true + return -1 + end + c_m = str.getbyte(si + 2) + unless c_m == 77 || c_m == 109 # 'M' or 'm' + hash[:_fail] = true + return -1 + end + si += 4 + else + if si + 1 >= slen + hash[:_fail] = true + return -1 + end + c_m = str.getbyte(si + 1) + unless c_m == 77 || c_m == 109 # 'M' or 'm' + hash[:_fail] = true + return -1 + end + si += 2 + end + hash[:_merid] = merid + + when 81 # 'Q' + # Milliseconds since Unix epoch + sign = 1 + if si < slen && str.getbyte(si) == 45 # '-' + sign = -1 + si += 1 + end + n, l = _sp_digits(str, si, slen, 10000) + if l == 0 + hash[:_fail] = true + return -1 + end + si += l + n = -n if sign == -1 + hash[:seconds] = Rational(n, 1000) + + when 82 # 'R' + new_si = _sp_run(str, si, '%H:%M', hash) + return new_si if new_si < 0 + si = new_si + + when 114 # 'r' + new_si = _sp_run(str, si, '%I:%M:%S %p', hash) + return new_si if new_si < 0 + si = new_si + + when 83 # 'S' + # Second (0-60 to allow leap second) - inlined + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + b = si < slen ? str.getbyte(si) : nil + if b && b >= 48 && b <= 57 + n = n * 10 + (b - 48) + si += 1 + end + if n > 60 + hash[:_fail] = true + return -1 + end + hash[:sec] = n + + when 115 # 's' + # Seconds since Unix epoch + sign = 1 + if si < slen && str.getbyte(si) == 45 # '-' + sign = -1 + si += 1 + end + n, l = _sp_digits(str, si, slen, 10000) + if l == 0 + hash[:_fail] = true + return -1 + end + si += l + n = -n if sign == -1 + hash[:seconds] = n + + when 84 # 'T' + new_si = _sp_run(str, si, '%H:%M:%S', hash) + return new_si if new_si < 0 + si = new_si + + when 85 # 'U' + # Week number (Sunday-based) + n, l = _sp_digits(str, si, slen, 2) + if l == 0 || n > 53 + hash[:_fail] = true + return -1 + end + si += l + hash[:wnum0] = n + + when 117 # 'u' + # ISO weekday (1=Mon..7=Sun) + n, l = _sp_digits(str, si, slen, 1) + if l == 0 || n < 1 || n > 7 + hash[:_fail] = true + return -1 + end + si += l + hash[:cwday] = n + + when 86 # 'V' + # ISO week number + n, l = _sp_digits(str, si, slen, 2) + if l == 0 || n < 1 || n > 53 + hash[:_fail] = true + return -1 + end + si += l + hash[:cweek] = n + + when 118 # 'v' + new_si = _sp_run(str, si, '%e-%b-%Y', hash) + return new_si if new_si < 0 + si = new_si + + when 87 # 'W' + # Week number (Monday-based) + n, l = _sp_digits(str, si, slen, 2) + if l == 0 || n > 53 + hash[:_fail] = true + return -1 + end + si += l + hash[:wnum1] = n + + when 119 # 'w' + # Weekday (0=Sun..6=Sat) + n, l = _sp_digits(str, si, slen, 1) + if l == 0 || n > 6 + hash[:_fail] = true + return -1 + end + si += l + hash[:wday] = n + + when 88 # 'X' + new_si = _sp_run(str, si, '%H:%M:%S', hash) + return new_si if new_si < 0 + si = new_si + + when 120 # 'x' + new_si = _sp_run(str, si, '%m/%d/%y', hash) + return new_si if new_si < 0 + si = new_si + + when 89 # 'Y' + # Full year: greedy unless next spec is numeric - inlined + sb = si < slen ? str.getbyte(si) : nil + if sb == 43 || sb == 45 # '+' or '-' + sign = sb == 45 ? -1 : 1 + si += 1 + else + sign = 1 + end + w = _sp_num_p_b?(fmt, fi, flen) ? 4 : 10000 + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + l = 1 + while l < w && si < slen + b = str.getbyte(si) + break unless b && b >= 48 && b <= 57 + n = n * 10 + (b - 48) + si += 1 + l += 1 + end + hash[:year] = sign * n + + when 121 # 'y' + # 2-digit year - inlined + b = si < slen ? str.getbyte(si) : nil + unless b && b >= 48 && b <= 57 + hash[:_fail] = true + return -1 + end + n = b - 48 + si += 1 + b = si < slen ? str.getbyte(si) : nil + if b && b >= 48 && b <= 57 + n = n * 10 + (b - 48) + si += 1 + end + if n > 99 + hash[:_fail] = true + return -1 + end + hash[:year] = n + hash[:_cent] ||= n >= 69 ? 19 : 20 + + when 90, 122 # 'Z', 'z' + new_si = _sp_zone(str, si, slen, hash) + if new_si < 0 + hash[:_fail] = true + return -1 + end + si = new_si - when 'w' # Weekday number (0-6, Sunday=0) - b = str.getbyte(pos) - return nil unless b && b >= 48 && b <= 54 # '0'..'6' - hash[:wday] = b - 48 - ss.pos = pos + 1 - true - - when 'u' # Weekday number (1-7, Monday=1) - b = str.getbyte(pos) - return nil unless b && b >= 49 && b <= 55 # '1'..'7' - hash[:cwday] = b - 48 - ss.pos = pos + 1 - true - - when 'U' # Week number (Sunday start, 00-53) - wnum, new_pos = scan_uint(str, pos, width || 2) - return nil unless wnum - return nil if wnum > 53 - hash[:wnum0] = wnum - ss.pos = new_pos - true - - when 'W' # Week number (Monday start, 00-53) - wnum, new_pos = scan_uint(str, pos, width || 2) - return nil unless wnum - return nil if wnum > 53 - hash[:wnum1] = wnum - ss.pos = new_pos - true - - when 'V' # ISO week number (01-53) - cweek, new_pos = scan_uint(str, pos, width || 2) - return nil unless cweek - return nil if cweek < 1 || cweek > 53 - hash[:cweek] = cweek - ss.pos = new_pos - true - - when 'G' # ISO week year - cwyear, new_pos = scan_sint(str, pos, width || (next_is_num ? 4 : 40)) - return nil unless cwyear - hash[:cwyear] = cwyear - ss.pos = new_pos - true - - when 'g' # ISO week year (2-digit) - y, new_pos = scan_uint(str, pos, width || 2) - return nil unless y - if hash[:_century] - hash[:cwyear] = hash[:_century] * 100 + y - hash[:_century_set] = true - else - hash[:cwyear] = y >= 69 ? y + 1900 : y + 2000 - end - ss.pos = new_pos - true - - when 'Z', 'z' # Timezone - result = _strptime_zone(str, pos) - return nil unless result - hash[:zone] = result[:zone] - hash[:offset] = result[:offset] unless result[:offset].nil? - ss.pos = result[:pos] - true - - when 's' # Seconds since epoch - secs, new_pos = scan_sint(str, pos, 40) - return nil unless secs - hash[:seconds] = secs - ss.pos = new_pos - true - - when 'Q' # Milliseconds since epoch - msecs, new_pos = scan_sint(str, pos, 40) - return nil unless msecs - hash[:seconds] = Rational(msecs, 1000) - ss.pos = new_pos - true - - when 'n', 't' # Newline / Tab — match any whitespace - skip_ws(ss) - true - - when '%' # Literal % - return nil unless str.getbyte(pos) == 37 # '%' - ss.pos = pos + 1 - true - - when 'F' # %Y-%m-%d - result = _strptime_composite(ss, '%Y-%m-%d', hash) - return nil unless result - hash.merge!(result) - true - - when 'D', 'x' # %m/%d/%y - result = _strptime_composite(ss, '%m/%d/%y', hash) - return nil unless result - hash.merge!(result) - true - - when 'T', 'X' # %H:%M:%S - result = _strptime_composite(ss, '%H:%M:%S', hash) - return nil unless result - hash.merge!(result) - true - - when 'R' # %H:%M - result = _strptime_composite(ss, '%H:%M', hash) - return nil unless result - hash.merge!(result) - true - - when 'r' # %I:%M:%S %p - result = _strptime_composite(ss, '%I:%M:%S %p', hash) - return nil unless result - hash.merge!(result) - true - - when 'c' # %a %b %e %H:%M:%S %Y - result = _strptime_composite(ss, '%a %b %e %H:%M:%S %Y', hash) - return nil unless result - hash.merge!(result) - true - - when 'v' # %e-%b-%Y - result = _strptime_composite(ss, '%e-%b-%Y', hash) - return nil unless result - hash.merge!(result) - true - - when '+' # %a %b %e %H:%M:%S %Z %Y - result = _strptime_composite(ss, '%a %b %e %H:%M:%S %Z %Y', hash) - return nil unless result - hash.merge!(result) - true + when 37 # '%' + if si >= slen || str.getbyte(si) != 37 + hash[:_fail] = true + return -1 + end + si += 1 + + when 43 # '+' + new_si = _sp_run(str, si, '%a %b %e %H:%M:%S %Z %Y', hash) + return new_si if new_si < 0 + si = new_si - else - # Unknown specifier - try to match literal - literal = "%#{spec}" - if str[pos, literal.length] == literal - ss.pos = pos + literal.length - true else - nil + # Unknown spec: match '%' then spec literally + if si >= slen || str.getbyte(si) != 37 # '%' + hash[:_fail] = true + return -1 + end + si += 1 + if spec + if si >= slen || str.getbyte(si) != spec + hash[:_fail] = true + return -1 + end + si += 1 + end end end + + si end - def _strptime_composite(ss, format, context_hash) - merged_hash = context_hash.dup + # Case-insensitive byte-level head match. + # Compares str[si..si+len-1] against pre-computed lowercase byte array. + # Uses | 0x20 for ASCII alpha downcase (works for A-Z only). + def _sp_head_match?(str, si, slen, lower_bytes, len) + return false if si + len > slen i = 0 - fmt_len = format.length - while i < fmt_len - fb = format.getbyte(i) - if fb == 37 && i + 1 < fmt_len # '%' - i += 1 - spec = format[i] - i += 1 - return nil unless _strptime_spec(ss, spec, nil, merged_hash) - elsif fb == 32 || fb == 9 || fb == 10 || fb == 13 || fb == 11 || fb == 12 # whitespace - i += 1 - skip_ws(ss) - else - if ss.string.getbyte(ss.pos) == fb - ss.pos += 1 - else - return nil - end - i += 1 + while i < len + return false if (str.getbyte(si + i) | 0x20) != lower_bytes[i] + i += 1 + end + true + end + + # Fast path for %Y-%m-%d / %F format. + # For common "YYYY-MM-DD" format, uses byteslice+to_i (fewer method calls). + # Falls back to getbyte loop for non-standard lengths or signed years. + def _strptime_ymd(str) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + slen = str.bytesize + + # Fast path for "YYYY-MM-DD" (exactly 10 chars) or "YYYY-MM-DD..." + if slen >= 10 && str.getbyte(4) == 45 && str.getbyte(7) == 45 + b0 = str.getbyte(0) + if b0 >= 48 && b0 <= 57 # first char is digit (positive 4-digit year) + year = str.byteslice(0, 4).to_i + mon = str.byteslice(5, 2).to_i + mday = str.byteslice(8, 2).to_i + return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 + hash = { year: year, mon: mon, mday: mday } + hash[:leftover] = str.byteslice(10, slen - 10) if slen > 10 + return hash end end - # Return only newly parsed or updated keys - new_hash = {} - merged_hash.each { |k, v| new_hash[k] = v unless context_hash.key?(k) && context_hash[k] == v } - merged_hash.each { |k, v| new_hash[k] = v if context_hash[k] != v } - new_hash + + # General path for signed years, short years, etc. + si = 0 + sign = 1 + b = str.getbyte(si) + if b == 43 # '+' + si += 1 + b = str.getbyte(si) + elsif b == 45 # '-' + sign = -1 + si += 1 + b = str.getbyte(si) + end + return nil unless b && b >= 48 && b <= 57 + year = b - 48 + si += 1 + while si < slen + b = str.getbyte(si) + break unless b && b >= 48 && b <= 57 + year = year * 10 + (b - 48) + si += 1 + end + year = -year if sign == -1 + + return nil unless si < slen && str.getbyte(si) == 45 + si += 1 + b = str.getbyte(si) + return nil unless b && b >= 48 && b <= 57 + mon = b - 48 + si += 1 + b = str.getbyte(si) + if b && b >= 48 && b <= 57 + mon = mon * 10 + (b - 48) + si += 1 + end + return nil if mon < 1 || mon > 12 + + return nil unless si < slen && str.getbyte(si) == 45 + si += 1 + b = str.getbyte(si) + return nil unless b && b >= 48 && b <= 57 + mday = b - 48 + si += 1 + b = str.getbyte(si) + if b && b >= 48 && b <= 57 + mday = mday * 10 + (b - 48) + si += 1 + end + return nil if mday < 1 || mday > 31 + + hash = { year: year, mon: mon, mday: mday } + hash[:leftover] = str.byteslice(si, slen - si) if si < slen + hash end - def _strptime_zone(str, pos) - remaining = str[pos..] - return nil if remaining.nil? || remaining.empty? - - # Try numeric timezone: +HH:MM, -HH:MM, +HH:MM:SS, -HH:MM:SS, +HHMM, -HHMM, +HH, -HH - # Also: GMT+HH, GMT-HH:MM, etc. and decimal offsets - # Colon-separated pattern (requires colon) tried first, then plain digits. - m = remaining.match(/\A( - (?:GMT|UTC)? - [+-] - (?:\d{1,2}:\d{2}(?::\d{2})? - | - \d+(?:[.,]\d+)?) - )/xi) - - if m - zone_str = m[1] - offset = _parse_zone_offset(zone_str) - return { pos: pos + zone_str.length, zone: zone_str, offset: offset } - end - - # Try named timezone (multi-word: "E. Australia Standard Time", "Mountain Daylight Time") - # Match alphabetic words with dots and spaces - m = remaining.match(/\A([A-Za-z][A-Za-z.]*(?:\s+[A-Za-z][A-Za-z.]*)*)/i) - if m - zone_candidate = m[1] - # Try progressively shorter matches (longest first) - words = zone_candidate.split(/\s+/) - (words.length).downto(1) do |n| - try_zone = words[0, n].join(' ') - offset = _zone_name_to_offset(try_zone) - if offset - # Compute actual consumed length preserving original spacing - if n == words.length - actual_zone = zone_candidate - else - # Find end of nth word in original string - end_pos = 0 - n.times do |wi| - end_pos = zone_candidate.index(words[wi], end_pos) - end_pos += words[wi].length + # Ultra-fast path: parse %Y-%m-%d and directly create Date object. + # Skips Hash creation, _sp_complete_frags, and _sp_valid_date_frags_p entirely. + # Returns Date object on success, nil on failure. + def _strptime_ymd_to_date(str, sg) # rubocop:disable Metrics/MethodLength + slen = str.bytesize + + # Ultra-fast path for exactly "YYYY-MM-DD" (10 chars, positive 4-digit year) + if slen == 10 && str.getbyte(4) == 45 && str.getbyte(7) == 45 + b0 = str.getbyte(0) + if b0 >= 48 && b0 <= 57 + year = str.byteslice(0, 4).to_i + mon = str.byteslice(5, 2).to_i + mday = str.byteslice(8, 2).to_i + if mon >= 1 && mon <= 12 && mday >= 1 && mday <= 31 + # Inline civil validation + JD + if sg != Float::INFINITY + dim = DAYS_IN_MONTH_GREGORIAN[mon] + if mon == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) + dim = 29 end - actual_zone = zone_candidate[0, end_pos] + return nil if mday > dim + gy = mon <= 2 ? year - 1 : year + gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[mon] + mday + a = gy / 100 + gjd = gjd_base - 1524 + 2 - a + a / 4 + jd = gjd >= sg ? gjd : gjd_base - 1524 + return _new_from_jd(jd, sg) + else + jd = internal_valid_civil?(year, mon, mday, sg) + return jd ? _new_from_jd(jd, sg) : nil end - return { pos: pos + actual_zone.length, zone: actual_zone, offset: offset } end + return nil end - # Unknown timezone - return full match with nil offset - # (Military single-letter zones like 'z' are already in ZONE_TABLE - # and handled by the loop above) - return { pos: pos + zone_candidate.length, zone: zone_candidate, offset: nil } end - nil + # General path for signed years, non-standard lengths + si = 0 + sign = 1 + b = str.getbyte(si) + if b == 43 # '+' + si += 1 + b = str.getbyte(si) + elsif b == 45 # '-' + sign = -1 + si += 1 + b = str.getbyte(si) + end + return nil unless b && b >= 48 && b <= 57 + year = b - 48 + si += 1 + while si < slen + b = str.getbyte(si) + break unless b && b >= 48 && b <= 57 + year = year * 10 + (b - 48) + si += 1 + end + year = -year if sign == -1 + return nil unless si < slen && str.getbyte(si) == 45 + si += 1 + b = str.getbyte(si) + return nil unless b && b >= 48 && b <= 57 + mon = b - 48 + si += 1 + b = str.getbyte(si) + if b && b >= 48 && b <= 57 + mon = mon * 10 + (b - 48) + si += 1 + end + return nil if mon < 1 || mon > 12 + return nil unless si < slen && str.getbyte(si) == 45 + si += 1 + b = str.getbyte(si) + return nil unless b && b >= 48 && b <= 57 + mday = b - 48 + si += 1 + b = str.getbyte(si) + if b && b >= 48 && b <= 57 + mday = mday * 10 + (b - 48) + si += 1 + end + return nil if mday < 1 || mday > 31 + return nil if si < slen + + # Inline civil validation + JD computation + # For common Gregorian dates with valid day-of-month, compute JD directly + if sg != Float::INFINITY # Gregorian path (most common) + dim = DAYS_IN_MONTH_GREGORIAN[mon] + if mon == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) + dim = 29 + end + return nil if mday > dim + # Inline civil_to_jd for Gregorian + gy = mon <= 2 ? year - 1 : year + offset = GJD_MONTH_OFFSET[mon] + gjd_base = (1461 * (gy + 4716)) / 4 + offset + mday + a = gy / 100 + gjd = gjd_base - 1524 + 2 - a + a / 4 + jd = gjd >= sg ? gjd : gjd_base - 1524 + else + jd = internal_valid_civil?(year, mon, mday, sg) + return nil unless jd + end + _new_from_jd(jd, sg) end - def _strptime_zone_colon(str, pos, colons) - remaining = str[pos..] - return nil if remaining.nil? || remaining.empty? - - case colons - when 1 # %:z -> +HH:MM - m = remaining.match(/\A([+-])(\d{2}):(\d{2})/) - return nil unless m - sign = m[1] == '-' ? -1 : 1 - offset = sign * (m[2].to_i * 3600 + m[3].to_i * 60) - zone = m[0] - { pos: pos + zone.length, zone: zone, offset: offset } - when 2 # %::z -> +HH:MM:SS - m = remaining.match(/\A([+-])(\d{2}):(\d{2}):(\d{2})/) - return nil unless m - sign = m[1] == '-' ? -1 : 1 - offset = sign * (m[2].to_i * 3600 + m[3].to_i * 60 + m[4].to_i) - zone = m[0] - { pos: pos + zone.length, zone: zone, offset: offset } - when 3 # %:::z -> +HH[:MM[:SS]] - m = remaining.match(/\A([+-])(\d{2})(?::(\d{2})(?::(\d{2}))?)?/) - return nil unless m - sign = m[1] == '-' ? -1 : 1 - offset = sign * (m[2].to_i * 3600 + (m[3] ? m[3].to_i * 60 : 0) + (m[4] ? m[4].to_i : 0)) - zone = m[0] - { pos: pos + zone.length, zone: zone, offset: offset } + # Fast path for "%a %b %d %Y" format (complex benchmark). + # Byte-level name matching + digit parsing. Zero String allocation. + def _strptime_abdy(str) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + slen = str.bytesize + si = 0 + + # Match weekday name using 3-byte key lookup + return nil if si + 2 >= slen + key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + entry = ABBR_DAY_3KEY[key] + return nil unless entry + wday = entry[0] + full_len = entry[1] + if si + full_len <= slen && _sp_head_match?(str, si, slen, DAY_LOWER_BYTES[wday], full_len) + si += full_len else - nil + si += 3 + end + + # Expect space(s) + return nil if si >= slen || str.getbyte(si) != 32 + si += 1 + si += 1 while si < slen && str.getbyte(si) == 32 + + # Match month name using 3-byte key lookup + return nil if si + 2 >= slen + key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + entry = ABBR_MONTH_3KEY[key] + return nil unless entry + mon = entry[0] + full_len = entry[1] + if si + full_len <= slen && _sp_head_match?(str, si, slen, MONTH_LOWER_BYTES[mon], full_len) + si += full_len + else + si += 3 + end + + # Expect space(s) + return nil if si >= slen || str.getbyte(si) != 32 + si += 1 + si += 1 while si < slen && str.getbyte(si) == 32 + + # Parse day (1-2 digits) + b = str.getbyte(si) + return nil unless b && b >= 48 && b <= 57 + mday = b - 48 + si += 1 + b = str.getbyte(si) + if b && b >= 48 && b <= 57 + mday = mday * 10 + (b - 48) + si += 1 + end + return nil if mday < 1 || mday > 31 + + # Expect space(s) + return nil if si >= slen || str.getbyte(si) != 32 + si += 1 + si += 1 while si < slen && str.getbyte(si) == 32 + + # Parse year: optional sign + greedy digits + sign = 1 + b = str.getbyte(si) + if b == 43 # '+' + si += 1 + b = str.getbyte(si) + elsif b == 45 # '-' + sign = -1 + si += 1 + b = str.getbyte(si) + end + + return nil unless b && b >= 48 && b <= 57 + year = b - 48 + si += 1 + while si < slen + b = str.getbyte(si) + break unless b && b >= 48 && b <= 57 + year = year * 10 + (b - 48) + si += 1 + end + year = -year if sign == -1 + + hash = { year: year, mon: mon, mday: mday, wday: wday } + hash[:leftover] = str.byteslice(si, slen - si) if si < slen + hash + end + + # Ultra-fast path: parse "%a %b %d %Y" and directly create Date object. + # Combines parsing + civil validation + JD computation without Hash. + def _strptime_abdy_to_date(str, sg) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + slen = str.bytesize + si = 0 + + # Match weekday name using 3-byte key lookup + return nil if si + 2 >= slen + key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + entry = ABBR_DAY_3KEY[key] + return nil unless entry + full_len = entry[1] + # Try full name first, then abbreviation + if si + full_len <= slen && _sp_head_match?(str, si, slen, DAY_LOWER_BYTES[entry[0]], full_len) + si += full_len + else + si += 3 + end + + # Expect space(s) + return nil if si >= slen || str.getbyte(si) != 32 + si += 1 + si += 1 while si < slen && str.getbyte(si) == 32 + + # Match month name using 3-byte key lookup + return nil if si + 2 >= slen + key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + entry = ABBR_MONTH_3KEY[key] + return nil unless entry + mon = entry[0] + full_len = entry[1] + if si + full_len <= slen && _sp_head_match?(str, si, slen, MONTH_LOWER_BYTES[mon], full_len) + si += full_len + else + si += 3 + end + + # Expect space(s) + return nil if si >= slen || str.getbyte(si) != 32 + si += 1 + si += 1 while si < slen && str.getbyte(si) == 32 + + # Parse day (1-2 digits) + b = str.getbyte(si) + return nil unless b && b >= 48 && b <= 57 + mday = b - 48 + si += 1 + b = str.getbyte(si) + if b && b >= 48 && b <= 57 + mday = mday * 10 + (b - 48) + si += 1 + end + return nil if mday < 1 || mday > 31 + + # Expect space(s) + return nil if si >= slen || str.getbyte(si) != 32 + si += 1 + si += 1 while si < slen && str.getbyte(si) == 32 + + # Parse year: optional sign + greedy digits + sign = 1 + b = str.getbyte(si) + if b == 43 # '+' + si += 1 + b = str.getbyte(si) + elsif b == 45 # '-' + sign = -1 + si += 1 + b = str.getbyte(si) + end + return nil unless b && b >= 48 && b <= 57 + year = b - 48 + si += 1 + while si < slen + b = str.getbyte(si) + break unless b && b >= 48 && b <= 57 + year = year * 10 + (b - 48) + si += 1 + end + year = -year if sign == -1 + + # Must consume entire string + return nil if si < slen + + # Inline civil validation + JD computation + if sg != Float::INFINITY + dim = DAYS_IN_MONTH_GREGORIAN[mon] + if mon == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) + dim = 29 + end + return nil if mday > dim + gy = mon <= 2 ? year - 1 : year + offset = GJD_MONTH_OFFSET[mon] + gjd_base = (1461 * (gy + 4716)) / 4 + offset + mday + a = gy / 100 + gjd = gjd_base - 1524 + 2 - a + a / 4 + jd = gjd >= sg ? gjd : gjd_base - 1524 + else + jd = internal_valid_civil?(year, mon, mday, sg) + return nil unless jd end + _new_from_jd(jd, sg) + end + + # Parse zone from string at position si; update hash[:zone] and hash[:offset]. + # Returns new si on success, -1 on failure. + def _sp_zone(str, si, slen, hash) + m = STRPTIME_ZONE_PAT.match(str[si..]) + return -1 unless m + zone_str = m[1] + hash[:zone] = zone_str + hash[:offset] = _sp_zone_to_diff(zone_str) + si + m[0].length end - def _parse_zone_offset(zone_str) - # Strip GMT/UTC prefix - s = zone_str.sub(/\A(?:GMT|UTC)/i, '') - return 0 if s.empty? - - m = s.match(/\A([+-])(\d+(?:[.,]\d+)?)$/) - if m - sign = m[1] == '-' ? -1 : 1 - num = m[2].tr(',', '.') - if num.include?('.') - # Decimal hours - hours = num.to_f - return nil if hours.abs >= 24 - return sign * (hours * 3600).to_i + # Convert a zone string to seconds offset from UTC. + # Returns Integer (seconds) or Rational, or nil if unparseable. + # Mirrors date_zone_to_diff() in ext/date/date_parse.c. + def _sp_zone_to_diff(zone_str) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + # Fast path for common numeric zones + len = zone_str.length + b0 = zone_str.getbyte(0) + if b0 == 43 || b0 == 45 # '+' or '-' + sign = b0 == 45 ? -1 : 1 + if len == 6 && zone_str.getbyte(3) == 58 # +HH:MM + b1 = zone_str.getbyte(1) + b2 = zone_str.getbyte(2) + b4 = zone_str.getbyte(4) + b5 = zone_str.getbyte(5) + if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b4 >= 48 && b4 <= 57 && b5 >= 48 && b5 <= 57 + h = (b1 - 48) * 10 + (b2 - 48) + m = (b4 - 48) * 10 + (b5 - 48) + return nil if h > 23 || m > 59 + return sign * (h * 3600 + m * 60) + end + elsif len == 5 # +HHMM + b1 = zone_str.getbyte(1) + b2 = zone_str.getbyte(2) + b3 = zone_str.getbyte(3) + b4 = zone_str.getbyte(4) + if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && b4 >= 48 && b4 <= 57 + return sign * ((b1 - 48) * 36000 + (b2 - 48) * 3600 + (b3 - 48) * 600 + (b4 - 48) * 60) + end + end + elsif len == 1 && (b0 == 90 || b0 == 122) # Z/z + return 0 + elsif len <= 3 + off = ZONE_TABLE[zone_str.downcase] + return off if off + end + + s = zone_str.dup + dst = false + + # Strip trailing " time" (optionally preceded by "standard" or "daylight") + strip_word = lambda do |str, len, word| + n = word.length + return nil unless len > n + return nil unless str[len - n - 1] =~ /[[:space:]]/ + return nil unless str[len - n, n].casecmp(word) == 0 + n += 1 + n += 1 while len > n && str[len - n - 1] =~ /[[:space:]]/ + n + end + + l = s.length + if (w = strip_word.call(s, l, 'time')) + l -= w + if (w2 = strip_word.call(s, l, 'standard')) + l -= w2 + elsif (w2 = strip_word.call(s, l, 'daylight')) + l -= w2 + dst = true else - # Could be HH, HHMM, or HHMMSS - digits = num - case digits.length - when 1, 2 - h = digits.to_i - return nil if h >= 24 - return sign * h * 3600 - when 3, 4 - h = digits[0, 2].to_i - min = digits[2, 2].to_i - return nil if h >= 24 || min >= 60 - return sign * (h * 3600 + min * 60) - when 5, 6 - h = digits[0, 2].to_i - min = digits[2, 2].to_i - sec = digits[4, 2].to_i - return nil if h >= 24 || min >= 60 || sec >= 60 - return sign * (h * 3600 + min * 60 + sec) - else - return nil + l += w # revert + end + elsif (w = strip_word.call(s, l, 'dst')) + l -= w + dst = true + end + + shrunk = s[0, l].gsub(/[[:space:]]+/, ' ').strip + if (offset = ZONE_TABLE[shrunk.downcase]) + return dst ? offset + 3600 : offset + end + + # Numeric parsing + t = s[0, l].strip + t = t[3..] if t =~ /\Agmt/i + t = t[$&.length..] if t =~ /\Autc?/i + return nil unless t && t.length > 0 && (t[0] == '+' || t[0] == '-') + + sign = t[0] == '-' ? -1 : 1 + t = t[1..] + + if (m = t.match(/\A(\d+):(\d+)(?::(\d+))?\z/)) + h = m[1].to_i + mn = m[2].to_i + sc = m[3] ? m[3].to_i : 0 + return nil if h > 23 || mn > 59 || sc > 59 + sign * (h * 3600 + mn * 60 + sc) + elsif (m = t.match(/\A(\d+)[,.](\d*)/)) + h = m[1].to_i + return nil if h > 23 + frac_s = m[2] + n = [frac_s.length, 7].min + digits = frac_s[0, n].to_i + digits += 1 if frac_s.length > n && frac_s[n].to_i >= 5 + sec = digits * 36 + os = if n == 0 + h * 3600 + elsif n == 1 + sec * 10 + h * 3600 + elsif n == 2 + sec + h * 3600 + else + denom = 10**(n - 2) + r = Rational(sec, denom) + h * 3600 + r.denominator == 1 ? r.numerator : r + end + sign == -1 ? -os : os + elsif t =~ /\A(\d+)\z/ + digits = $1 + dlen = digits.length + h = digits[0, 2 - dlen % 2].to_i + mn = dlen >= 3 ? digits[2 - dlen % 2, 2].to_i : 0 + sc = dlen >= 5 ? digits[4 - dlen % 2, 2].to_i : 0 + sign * (h * 3600 + mn * 60 + sc) + else + nil + end + end + + # Rewrite :seconds (from %s/%Q) into jd + time components. + # Offset is applied first (converts UTC epoch to local time). + def _sp_rewrite_frags(hash) + seconds = hash.delete(:seconds) + return hash unless seconds + + offset = hash[:offset] || 0 + seconds = seconds + offset if offset != 0 + + d, fr = seconds.divmod(86400) + h, fr = fr.divmod(3600) + m, fr = fr.divmod(60) + s, fr = fr.divmod(1) + + hash[:jd] = 2440588 + d + hash[:hour] = h + hash[:min] = m + hash[:sec] = s + hash[:sec_fraction] = fr + hash + end + + # Complete partial date fragments by filling defaults from today's date. + # Mirrors rt_complete_frags() in C. + def _sp_complete_frags(klass, hash) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + # Fast path: detect :civil case (most common) without iterating all entries + k = nil + a = nil + if hash.key?(:year) || hash.key?(:mon) || hash.key?(:mday) + civil_n = 0 + civil_n += 1 if hash.key?(:year) + civil_n += 1 if hash.key?(:mon) + civil_n += 1 if hash.key?(:mday) + civil_n += 1 if hash.key?(:hour) + civil_n += 1 if hash.key?(:min) + civil_n += 1 if hash.key?(:sec) + # Check if any other pattern matches better + best_n = civil_n + skip_civil = false + if hash.key?(:jd) # jd entry has 1 element + skip_civil = true if 1 > best_n + end + if hash.key?(:yday) # ordinal [:year, :yday, :hour, :min, :sec] + ord_n = (hash.key?(:year) ? 1 : 0) + 1 + (hash.key?(:hour) ? 1 : 0) + (hash.key?(:min) ? 1 : 0) + (hash.key?(:sec) ? 1 : 0) + skip_civil = true if ord_n > best_n + end + if hash.key?(:cwyear) || hash.key?(:cweek) || hash.key?(:cwday) + com_n = (hash.key?(:cwyear) ? 1 : 0) + (hash.key?(:cweek) ? 1 : 0) + (hash.key?(:cwday) ? 1 : 0) + (hash.key?(:hour) ? 1 : 0) + (hash.key?(:min) ? 1 : 0) + (hash.key?(:sec) ? 1 : 0) + skip_civil = true if com_n > best_n + end + if hash.key?(:wnum0) + wn0_n = (hash.key?(:year) ? 1 : 0) + 1 + (hash.key?(:wday) ? 1 : 0) + (hash.key?(:hour) ? 1 : 0) + (hash.key?(:min) ? 1 : 0) + (hash.key?(:sec) ? 1 : 0) + skip_civil = true if wn0_n > best_n + end + if hash.key?(:wnum1) + wn1_n = (hash.key?(:year) ? 1 : 0) + 1 + (hash.key?(:wday) ? 1 : 0) + (hash.key?(:hour) ? 1 : 0) + (hash.key?(:min) ? 1 : 0) + (hash.key?(:sec) ? 1 : 0) + skip_civil = true if wn1_n > best_n + end + unless skip_civil + k = :civil + a = [:year, :mon, :mday, :hour, :min, :sec] + end + end + + unless k + best_k = nil + best_a = nil + best_n = 0 + COMPLETE_FRAGS_TAB.each do |ek, ea| + n = ea.count { |sym| hash.key?(sym) } + if n > best_n + best_k = ek + best_a = ea + best_n = n + end + end + k = best_k + a = best_a + end + + if k && best_n < a.length + today = nil + case k + when :ordinal + hash[:year] ||= (today ||= Date.today).year + hash[:yday] ||= 1 + when :civil + a.each do |sym| + break unless hash[sym].nil? + hash[sym] = (today ||= Date.today).__send__(sym) + end + hash[:mon] ||= 1 + hash[:mday] ||= 1 + when :commercial + a.each do |sym| + break unless hash[sym].nil? + hash[sym] = (today ||= Date.today).__send__(sym) + end + hash[:cweek] ||= 1 + hash[:cwday] ||= 1 + when :wday + today ||= Date.today + hash[:jd] = (today - today.wday + hash[:wday]).jd + when :wnum0 + a.each do |sym| + break unless hash[sym].nil? + hash[sym] = (today ||= Date.today).year end + hash[:wnum0] ||= 0 + hash[:wday] ||= 0 + when :wnum1 + a.each do |sym| + break unless hash[sym].nil? + hash[sym] = (today ||= Date.today).year + end + hash[:wnum1] ||= 0 + hash[:wday] ||= 1 end end - # +HH:MM or +HH:MM:SS - m = s.match(/\A([+-])(\d{1,2}):(\d{2})(?::(\d{2}))?$/) - if m - sign = m[1] == '-' ? -1 : 1 - h = m[2].to_i - min = m[3].to_i - sec = m[4] ? m[4].to_i : 0 - return nil if h >= 24 || min >= 60 || sec >= 60 - return sign * (h * 3600 + min * 60 + sec) + if k == :time && klass <= DateTime + hash[:jd] ||= Date.today.jd + end + + hash[:hour] ||= 0 + hash[:min] ||= 0 + hash[:sec] = if hash[:sec].nil? + 0 + elsif hash[:sec] > 59 + 59 + else + hash[:sec] + end + hash + end + + # Convert year/week/wday to Julian Day number. + # f=0: Sunday-based (%U), d=0=Sun..6=Sat + # f=1: Monday-based (%W), d=0=Mon..6=Sun (Mon-based) + # Mirrors c_weeknum_to_jd() in ext/date/date_core.c: + # rjd2 = JD(Jan 1) + 6 (= JD of Jan 7) + # return (rjd2 - MOD((rjd2 - f + 1), 7) - 7) + 7*w + d + def _sp_weeknum_to_jd(y, w, d, f, sg) + jd_jan7 = civil_to_jd(y, 1, 1, sg) + 6 + (jd_jan7 - (jd_jan7 - f + 1) % 7 - 7) + 7 * w + d + end + + # Find the Julian Day number from the fragment hash. + # Tries jd, ordinal, civil, commercial, wnum0, wnum1 in order. + # Returns jd integer or nil. + def _sp_valid_date_frags_p(hash, sg) # rubocop:disable Metrics/CyclomaticComplexity + return hash[:jd] if hash[:jd] + + if (yday = hash[:yday]) && (year = hash[:year]) + jd = internal_valid_ordinal?(year, yday, sg) + return jd if jd + end + + if (mday = hash[:mday]) && (mon = hash[:mon]) && (year = hash[:year]) + jd = internal_valid_civil?(year, mon, mday, sg) + return jd if jd + end + + # Commercial (ISO week): prefer cwday, else wday (treating 0 as 7) + wday = hash[:cwday] + if wday.nil? + wday = hash[:wday] + wday = 7 if !wday.nil? && wday == 0 + end + if wday && (week = hash[:cweek]) && (year = hash[:cwyear]) + jd = internal_valid_commercial?(year, week, wday, sg) + return jd if jd + end + + # wnum0 (Sunday-start): prefer wday (0=Sun), else cwday (converting 7→0) + wday = hash[:wday] + if wday.nil? + wday = hash[:cwday] + wday = 0 if !wday.nil? && wday == 7 + end + if wday && (week = hash[:wnum0]) && (year = hash[:year]) + jd = _sp_weeknum_to_jd(year, week, wday, 0, sg) + return jd if jd + end + + # wnum1 (Monday-start): convert to Mon-based 0=Mon using (wday-1)%7 + # Uses original wday (0=Sun) or cwday (1=Mon..7=Sun) — no 7→0 conversion here + wday = hash[:wday] + wday = hash[:cwday] if wday.nil? + wday = (wday - 1) % 7 if wday + if wday && (week = hash[:wnum1]) && (year = hash[:year]) + jd = _sp_weeknum_to_jd(year, week, wday, 1, sg) + return jd if jd end nil end - def _zone_name_to_offset(name) - ZONE_TABLE[name.downcase.gsub(/\s+/, ' ')] + # Create a Date object from parsed fragment hash. + def _new_by_frags(hash, sg) + raise Error, 'invalid date' if hash.nil? + hash = _sp_rewrite_frags(hash) + hash = _sp_complete_frags(Date, hash) + jd = _sp_valid_date_frags_p(hash, sg) + raise Error, 'invalid date' if jd.nil? + _new_from_jd(jd, sg) end end end diff --git a/lib/date/time.rb b/lib/date/time.rb index 3b73236b..ee8ef7c3 100644 --- a/lib/date/time.rb +++ b/lib/date/time.rb @@ -1,59 +1,31 @@ # frozen_string_literal: true class Time + # call-seq: + # t.to_time -> time + # + # Returns self. def to_time self end unless method_defined?(:to_time) + # call-seq: + # t.to_date -> date + # + # Returns a Date object which denotes self. def to_date - y = year - m = month - d = day - - nth, ry = Date.send(:decode_year, y, -1) - - # First, create it in GREGORIAN (dates during the reform period are also valid). - obj = Date.send(:d_simple_new_internal, - nth, 0, - Date::GREGORIAN, - ry, m, d, - 0x04) # Date::HAVE_CIVIL - - # Then change to DEFAULT_SG. - obj.send(:set_sg, Date::ITALY) - - obj + jd = Date.__send__(:gregorian_to_jd, year, mon, mday) + Date.__send__(:_new_from_jd, jd, Date::ITALY) end unless method_defined?(:to_date) + # call-seq: + # t.to_datetime -> datetime + # + # Returns a DateTime object which denotes self. def to_datetime - y = year - m = month - d = day - h = hour - mi = min - s = sec - of_sec = utc_offset - sf = nsec - - nth, ry = Date.send(:decode_year, y, -1) - rjd, _ = Date.send(:c_civil_to_jd, ry, m, d, Date::GREGORIAN) - - df = h * 3600 + mi * 60 + s - - # Convert local to UTC - df_utc = df - of_sec - jd_utc = rjd - if df_utc < 0 - jd_utc -= 1 - df_utc += 86400 - elsif df_utc >= 86400 - jd_utc += 1 - df_utc -= 86400 - end - - obj = DateTime.send(:new_with_jd_and_time, nth, jd_utc, df_utc, sf, of_sec, Date::GREGORIAN) - obj.send(:set_sg, Date::ITALY) - - obj + jd = Date.__send__(:gregorian_to_jd, year, mon, mday) + dt = DateTime.allocate + dt.__send__(:_init_datetime, jd, hour, min, sec, subsec, utc_offset, Date::ITALY) + dt end unless method_defined?(:to_datetime) end From d276c804d635db5bf707e6c5c0df4534e562361d Mon Sep 17 00:00:00 2001 From: jinroq Date: Mon, 2 Mar 2026 01:32:06 +0900 Subject: [PATCH 06/11] Auto-generate lib/date/zonetab.rb from ext/date/zonetab.list Add ext/date/generate-zonetab-rb script that reads zonetab.list and produces lib/date/zonetab.rb, ensuring the Ruby hash table stays in sync with the C gperf header (zonetab.h) from the same sources. - Update ext/date/prereq.mk to run generate-zonetab-rb after update-abbr - Update .github/workflows/update.yml to include lib/date/zonetab.rb in the weekly auto-commit - Remove 75 "xxx standard time" entries from zonetab.rb that did not exist in zonetab.list or the C extension (316 entries, matching zonetab.list exactly) --- .github/workflows/update.yml | 2 +- ext/date/generate-zonetab-rb | 59 +++ ext/date/prereq.mk | 1 + lib/date/zonetab.rb | 718 ++++++++++++++++------------------- 4 files changed, 380 insertions(+), 400 deletions(-) create mode 100755 ext/date/generate-zonetab-rb diff --git a/.github/workflows/update.yml b/.github/workflows/update.yml index 9e0d465e..540a9967 100644 --- a/.github/workflows/update.yml +++ b/.github/workflows/update.yml @@ -31,7 +31,7 @@ jobs: echo "diff=true" >> $GITHUB_OUTPUT - name: Commit run: | - git commit --message="Update zonetab.h at $(date +%F)" ext/date + git commit --message="Update zonetab at $(date +%F)" ext/date lib/date/zonetab.rb git pull --ff-only origin ${GITHUB_REF#refs/heads/} git push origin ${GITHUB_REF#refs/heads/} env: diff --git a/ext/date/generate-zonetab-rb b/ext/date/generate-zonetab-rb new file mode 100755 index 00000000..64b72c7e --- /dev/null +++ b/ext/date/generate-zonetab-rb @@ -0,0 +1,59 @@ +# -*- mode: ruby -*- +# Generate lib/date/zonetab.rb from ext/date/zonetab.list +# +# Usage: ruby -C ext/date generate-zonetab-rb +# +# This script reads zonetab.list (the same source used to generate zonetab.h +# via gperf) and produces the equivalent Ruby hash table. + +list_path = File.join(__dir__, 'zonetab.list') +output_path = File.join(__dir__, '..', '..', 'lib', 'date', 'zonetab.rb') + +entries = {} +in_entries = false + +File.foreach(list_path) do |line| + line.chomp! + if line == '%%' + if in_entries + break + else + in_entries = true + next + end + end + next unless in_entries + + abbr, offset_expr = line.split(',', 2) + next unless offset_expr + + abbr.strip! + offset_expr.strip! + + # Evaluate offset expression (e.g., "0*3600", "-5*3600", "-(1*3600+1800)", "16200") + offset = eval(offset_expr) + + entries[abbr] = offset +end + +sorted = entries.sort_by { |k, _| k } + +max_key_len = sorted.map { |k, _| k.length }.max + +File.open(output_path, 'w') do |f| + f.puts '# frozen_string_literal: true' + f.puts + f.puts '# Timezone name => UTC offset (seconds) mapping table.' + f.puts '# Auto-generated from ext/date/zonetab.list by ext/date/generate-zonetab-rb.' + f.puts '# Do not edit manually.' + f.puts 'class Date' + f.puts ' ZONE_TABLE = {' + sorted.each do |abbr, offset| + key = abbr.include?(' ') ? %Q("#{abbr}") : %Q("#{abbr}") + f.puts " %-#{max_key_len + 3}s => %d," % [key, offset] + end + f.puts ' }.freeze' + f.puts 'end' +end + +puts "Generated #{output_path} with #{entries.size} entries." diff --git a/ext/date/prereq.mk b/ext/date/prereq.mk index b5d271a3..7f8e0bbf 100644 --- a/ext/date/prereq.mk +++ b/ext/date/prereq.mk @@ -10,6 +10,7 @@ zonetab.h: zonetab.list .PHONY: update-zonetab update-zonetab: $(RUBY) -C $(srcdir) update-abbr + $(RUBY) -C $(srcdir) generate-zonetab-rb .PHONY: update-nothing update-nothing: diff --git a/lib/date/zonetab.rb b/lib/date/zonetab.rb index c26262f0..b7e22c37 100644 --- a/lib/date/zonetab.rb +++ b/lib/date/zonetab.rb @@ -1,405 +1,325 @@ # frozen_string_literal: true -# Timezone name => UTC offset (seconds) mapping table -# Converted C's zonetab.h (gperf-generated hash table) to a Ruby hash. -# 316 zones in total. -# Search ignores case (.downcase on the caller before searching). -# -# Original data source: zonetab.h #included in date_parse.c -# gperf --ignore-case -L ANSI-C -C -c -P -p -j1 -i 1 -g -o -t \ -# -N zonetab zonetab.list -# The complete static hash table generated by was converted equivalently to a Ruby hash. +# Timezone name => UTC offset (seconds) mapping table. +# Auto-generated from ext/date/zonetab.list by ext/date/generate-zonetab-rb. +# Do not edit manually. class Date ZONE_TABLE = { - "a" => 3600, - "acdt" => 37800, - "acst" => 34200, - "act" => -18000, - "acwst" => 31500, - "adt" => -10800, - "aedt" => 39600, - "aest" => 36000, - "afghanistan" => 16200, - "aft" => 16200, - "ahst" => -36000, - "akdt" => -28800, - "akst" => -32400, - "alaskan" => -32400, - "almt" => 21600, - "anast" => 43200, - "anat" => 43200, - "aoe" => -43200, - "aqtt" => 18000, - "arab" => 10800, - "arabian" => 14400, - "arabic" => 10800, - "art" => -10800, - "ast" => -14400, - "at" => -7200, - "atlantic" => -14400, - "aus central" => 34200, - "aus eastern" => 36000, - "awdt" => 32400, - "awst" => 28800, - "azores" => -3600, - "azost" => 0, - "azot" => -3600, - "azst" => 18000, - "azt" => 14400, - "b" => 7200, - "bnt" => 28800, - "bot" => -14400, - "brst" => -7200, - "brt" => -10800, - "bst" => 3600, - "bt" => 10800, - "btt" => 21600, - "c" => 10800, - "canada central" => -21600, - "cape verde" => -3600, - "cast" => 28800, - "cat" => 7200, - "caucasus" => 14400, - "cct" => 23400, - "cdt" => -18000, - "cen. australia" => 34200, - "central" => -21600, - "central america" => -21600, - "central asia" => 21600, - "central europe" => 3600, - "central european" => 3600, - "central pacific" => 39600, - "cest" => 7200, - "cet" => 3600, - "chadt" => 49500, - "chast" => 45900, - "china" => 28800, - "chost" => 32400, - "chot" => 28800, - "chst" => 36000, - "chut" => 36000, - "cidst" => -14400, - "cist" => -18000, - "ckt" => -36000, - "clst" => -10800, - "clt" => -14400, - "cot" => -18000, - "cst" => -21600, - "cvt" => -3600, - "cxt" => 25200, - "d" => 14400, - "dateline" => -43200, - "davt" => 25200, - "ddut" => 36000, - "e" => 18000, - "e. africa" => 10800, - "e. australia" => 36000, - "e. europe" => 7200, - "e. south america" => -10800, - "eadt" => 39600, - "easst" => -18000, - "east" => -21600, - "eastern" => -18000, - "eat" => 10800, - "ect" => -18000, - "edt" => -14400, - "eest" => 10800, - "eet" => 7200, - "egst" => 0, - "egt" => -3600, - "egypt" => 7200, - "ekaterinburg" => 18000, - "est" => -18000, - "f" => 21600, - "fet" => 10800, - "fiji" => 43200, - "fjst" => 46800, - "fjt" => 43200, - "fkst" => -10800, - "fkt" => -14400, - "fle" => 7200, - "fnt" => -7200, - "fst" => 7200, - "fwt" => 3600, - "g" => 25200, - "galt" => -21600, - "gamt" => -32400, - "get" => 14400, - "gft" => -10800, - "gilt" => 43200, - "gmt" => 0, - "greenland" => -10800, - "greenwich" => 0, - "gst" => 36000, - "gtb" => 7200, - "gyt" => -14400, - "h" => 28800, - "hadt" => -32400, - "hast" => -36000, - "hawaiian" => -36000, - "hdt" => -32400, - "hkt" => 28800, - "hovst" => 28800, - "hovt" => 25200, - "hst" => -36000, - "i" => 32400, - "ict" => 25200, - "idle" => 43200, - "idlw" => -43200, - "idt" => 10800, - "india" => 19800, - "iot" => 21600, - "iran" => 12600, - "irdt" => 16200, - "irkst" => 32400, - "irkt" => 28800, - "irst" => 12600, - "ist" => 19800, - "jerusalem" => 7200, - "jst" => 32400, - "k" => 36000, - "kgt" => 21600, - "korea" => 32400, - "kost" => 39600, - "krast" => 28800, - "krat" => 25200, - "kst" => 32400, - "kuyt" => 14400, - "l" => 39600, - "lhdt" => 39600, - "lhst" => 37800, - "lint" => 50400, - "m" => 43200, - "magst" => 43200, - "magt" => 39600, - "malay peninsula" => 28800, - "mart" => -30600, - "mawt" => 18000, - "mdt" => -21600, - "mest" => 7200, - "mesz" => 7200, - "met" => 3600, - "mewt" => 3600, - "mexico" => -21600, - "mez" => 3600, - "mht" => 43200, - "mid-atlantic" => -7200, - "mmt" => 23400, - "mountain" => -25200, - "msd" => 14400, - "msk" => 10800, - "mst" => -25200, - "mut" => 14400, - "mvt" => 18000, - "myanmar" => 23400, - "myt" => 28800, - "n" => -3600, - "n. central asia" => 21600, - "nct" => 39600, - "ndt" => -5400, - "nepal" => 20700, - "new zealand" => 43200, - "newfoundland" => -12600, - "nfdt" => 43200, - "nft" => 39600, - "north asia" => 25200, - "north asia east" => 28800, - "novst" => 25200, - "novt" => 25200, - "npt" => 20700, - "nrt" => 43200, - "nst" => -9000, - "nt" => -39600, - "nut" => -39600, - "nzdt" => 46800, - "nzst" => 43200, - "nzt" => 43200, - "o" => -7200, - "omsst" => 25200, - "omst" => 21600, - "orat" => 18000, - "p" => -10800, - "pacific" => -28800, - "pacific sa" => -14400, - "pdt" => -25200, - "pet" => -18000, - "petst" => 43200, - "pett" => 43200, - "pgt" => 36000, - "phot" => 46800, - "pht" => 28800, - "pkt" => 18000, - "pmdt" => -7200, - "pmst" => -10800, - "pont" => 39600, - "pst" => -28800, - "pwt" => 32400, - "pyst" => -10800, - "q" => -14400, - "qyzt" => 21600, - "r" => -18000, - "ret" => 14400, - "romance" => 3600, - "rott" => -10800, - "russian" => 10800, - "s" => -21600, - "sa eastern" => -10800, - "sa pacific" => -18000, - "sa western" => -14400, - "sakt" => 39600, - "samoa" => -39600, - "samt" => 14400, - "sast" => 7200, - "sbt" => 39600, - "sct" => 14400, - "se asia" => 25200, - "sgt" => 28800, - "south africa" => 7200, - "sret" => 39600, - "sri lanka" => 21600, - "srt" => -10800, - "sst" => -39600, - "swt" => 3600, - "syot" => 10800, - "t" => -25200, - "taht" => -36000, - "taipei" => 28800, - "tasmania" => 36000, - "tft" => 18000, - "tjt" => 18000, - "tkt" => 46800, - "tlt" => 32400, - "tmt" => 18000, - "tokyo" => 32400, - "tonga" => 46800, - "tost" => 50400, - "tot" => 46800, - "trt" => 10800, - "tvt" => 43200, - "u" => -28800, - "ulast" => 32400, - "ulat" => 28800, - "us eastern" => -18000, - "us mountain" => -25200, - "ut" => 0, - "utc" => 0, - "uyst" => -7200, - "uyt" => -10800, - "uzt" => 18000, - "v" => -32400, - "vet" => -14400, - "vladivostok" => 36000, - "vlast" => 39600, - "vlat" => 36000, - "vost" => 21600, - "vut" => 39600, - "w" => -36000, - "w. australia" => 28800, - "w. central africa" => 3600, - "w. europe" => 3600, - "wadt" => 28800, - "wakt" => 43200, - "warst" => -10800, - "wast" => 7200, - "wat" => 3600, - "west" => 3600, - "west asia" => 18000, - "west pacific" => 36000, - "wet" => 0, - "wft" => 43200, - "wgst" => -3600, - "wgt" => -7200, - "wib" => 25200, - "wit" => 32400, - "wita" => 28800, - "wt" => 0, - "x" => -39600, - "y" => -43200, - "yakst" => 36000, - "yakt" => 32400, - "yakutsk" => 32400, - "yapt" => 36000, - "ydt" => -28800, - "yekst" => 21600, - "yekt" => 18000, - "yst" => -32400, - "z" => 0, - "zp4" => 14400, - "zp5" => 18000, - "zp6" => 21600, - # Multi-word timezone names from C's zonetab.list - "met dst" => 7200, - "mountain standard time" => -25200, - "mountain daylight time" => -21600, - "pacific standard time" => -28800, - "pacific daylight time" => -25200, - "eastern standard time" => -18000, - "eastern daylight time" => -14400, - "central standard time" => -21600, - "central daylight time" => -18000, - "atlantic standard time" => -14400, - "atlantic daylight time" => -10800, - "e. australia standard time" => 36000, - "cen. australia standard time" => 34200, - "w. australia standard time" => 28800, - "dateline standard time" => -43200, - "fiji standard time" => 43200, - "samoa standard time" => -39600, - "new zealand standard time" => 43200, - "taipei standard time" => 28800, - "tokyo standard time" => 32400, - "china standard time" => 28800, - "india standard time" => 19800, - "korea standard time" => 32400, - "singapore standard time" => 28800, - "north asia standard time" => 25200, - "north asia east standard time" => 28800, - "se asia standard time" => 25200, - "west asia standard time" => 18000, - "romance standard time" => 3600, - "russian standard time" => 10800, - "us eastern standard time" => -18000, - "us mountain standard time" => -25200, - "sa western standard time" => -14400, - "sa pacific standard time" => -18000, - "sa eastern standard time" => -10800, - "e. south america standard time" => -10800, - "greenland standard time" => -10800, - "mid-atlantic standard time" => -7200, - "azores standard time" => -3600, - "cape verde standard time" => -3600, - "gmt standard time" => 0, - "greenwich standard time" => 0, - "w. europe standard time" => 3600, - "central europe standard time" => 3600, - "central european standard time" => 3600, - "gtb standard time" => 7200, - "e. europe standard time" => 7200, - "egypt standard time" => 7200, - "south africa standard time" => 7200, - "fle standard time" => 7200, - "israel standard time" => 7200, - "arabian standard time" => 14400, - "arab standard time" => 10800, - "e. africa standard time" => 10800, - "iran standard time" => 12600, - "west pacific standard time" => 36000, - "aus central standard time" => 34200, - "aus eastern standard time" => 36000, - "central pacific standard time" => 39600, - "tasmania standard time" => 36000, - "canada central standard time" => -21600, - "mexico standard time" => -21600, - "mexico standard time 2" => -25200, - "central america standard time" => -21600, - "nepal standard time" => 20700, - "sri lanka standard time" => 21600, - "n. central asia standard time" => 21600, - "central asia standard time" => 21600, - "afghanistan standard time" => 16200, - "ekaterinburg standard time" => 18000, - "alaska standard time" => -32400, - "alaska daylight time" => -28800, - "hawaii standard time" => -36000, + "a" => 3600, + "acdt" => 37800, + "acst" => 34200, + "act" => -18000, + "acwst" => 31500, + "adt" => -10800, + "aedt" => 39600, + "aest" => 36000, + "afghanistan" => 16200, + "aft" => 16200, + "ahst" => -36000, + "akdt" => -28800, + "akst" => -32400, + "alaskan" => -32400, + "almt" => 21600, + "anast" => 43200, + "anat" => 43200, + "aoe" => -43200, + "aqtt" => 18000, + "arab" => 10800, + "arabian" => 14400, + "arabic" => 10800, + "art" => -10800, + "ast" => -14400, + "at" => -7200, + "atlantic" => -14400, + "aus central" => 34200, + "aus eastern" => 36000, + "awdt" => 32400, + "awst" => 28800, + "azores" => -3600, + "azost" => 0, + "azot" => -3600, + "azst" => 18000, + "azt" => 14400, + "b" => 7200, + "bnt" => 28800, + "bot" => -14400, + "brst" => -7200, + "brt" => -10800, + "bst" => 3600, + "bt" => 10800, + "btt" => 21600, + "c" => 10800, + "canada central" => -21600, + "cape verde" => -3600, + "cast" => 28800, + "cat" => 7200, + "caucasus" => 14400, + "cct" => 23400, + "cdt" => -18000, + "cen. australia" => 34200, + "central" => -21600, + "central america" => -21600, + "central asia" => 21600, + "central europe" => 3600, + "central european" => 3600, + "central pacific" => 39600, + "cest" => 7200, + "cet" => 3600, + "chadt" => 49500, + "chast" => 45900, + "china" => 28800, + "chost" => 32400, + "chot" => 28800, + "chst" => 36000, + "chut" => 36000, + "cidst" => -14400, + "cist" => -18000, + "ckt" => -36000, + "clst" => -10800, + "clt" => -14400, + "cot" => -18000, + "cst" => -21600, + "cvt" => -3600, + "cxt" => 25200, + "d" => 14400, + "dateline" => -43200, + "davt" => 25200, + "ddut" => 36000, + "e" => 18000, + "e. africa" => 10800, + "e. australia" => 36000, + "e. europe" => 7200, + "e. south america" => -10800, + "eadt" => 39600, + "easst" => -18000, + "east" => -21600, + "eastern" => -18000, + "eat" => 10800, + "ect" => -18000, + "edt" => -14400, + "eest" => 10800, + "eet" => 7200, + "egst" => 0, + "egt" => -3600, + "egypt" => 7200, + "ekaterinburg" => 18000, + "est" => -18000, + "f" => 21600, + "fet" => 10800, + "fiji" => 43200, + "fjst" => 46800, + "fjt" => 43200, + "fkst" => -10800, + "fkt" => -14400, + "fle" => 7200, + "fnt" => -7200, + "fst" => 7200, + "fwt" => 3600, + "g" => 25200, + "galt" => -21600, + "gamt" => -32400, + "get" => 14400, + "gft" => -10800, + "gilt" => 43200, + "gmt" => 0, + "greenland" => -10800, + "greenwich" => 0, + "gst" => 36000, + "gtb" => 7200, + "gyt" => -14400, + "h" => 28800, + "hadt" => -32400, + "hast" => -36000, + "hawaiian" => -36000, + "hdt" => -32400, + "hkt" => 28800, + "hovst" => 28800, + "hovt" => 25200, + "hst" => -36000, + "i" => 32400, + "ict" => 25200, + "idle" => 43200, + "idlw" => -43200, + "idt" => 10800, + "india" => 19800, + "iot" => 21600, + "iran" => 12600, + "irdt" => 16200, + "irkst" => 32400, + "irkt" => 28800, + "irst" => 12600, + "ist" => 19800, + "jerusalem" => 7200, + "jst" => 32400, + "k" => 36000, + "kgt" => 21600, + "korea" => 32400, + "kost" => 39600, + "krast" => 28800, + "krat" => 25200, + "kst" => 32400, + "kuyt" => 14400, + "l" => 39600, + "lhdt" => 39600, + "lhst" => 37800, + "lint" => 50400, + "m" => 43200, + "magst" => 43200, + "magt" => 39600, + "malay peninsula" => 28800, + "mart" => -30600, + "mawt" => 18000, + "mdt" => -21600, + "mest" => 7200, + "mesz" => 7200, + "met" => 3600, + "mewt" => 3600, + "mexico" => -21600, + "mez" => 3600, + "mht" => 43200, + "mid-atlantic" => -7200, + "mmt" => 23400, + "mountain" => -25200, + "msd" => 14400, + "msk" => 10800, + "mst" => -25200, + "mut" => 14400, + "mvt" => 18000, + "myanmar" => 23400, + "myt" => 28800, + "n" => -3600, + "n. central asia" => 21600, + "nct" => 39600, + "ndt" => -5400, + "nepal" => 20700, + "new zealand" => 43200, + "newfoundland" => -12600, + "nfdt" => 43200, + "nft" => 39600, + "north asia" => 25200, + "north asia east" => 28800, + "novst" => 25200, + "novt" => 25200, + "npt" => 20700, + "nrt" => 43200, + "nst" => -9000, + "nt" => -39600, + "nut" => -39600, + "nzdt" => 46800, + "nzst" => 43200, + "nzt" => 43200, + "o" => -7200, + "omsst" => 25200, + "omst" => 21600, + "orat" => 18000, + "p" => -10800, + "pacific" => -28800, + "pacific sa" => -14400, + "pdt" => -25200, + "pet" => -18000, + "petst" => 43200, + "pett" => 43200, + "pgt" => 36000, + "phot" => 46800, + "pht" => 28800, + "pkt" => 18000, + "pmdt" => -7200, + "pmst" => -10800, + "pont" => 39600, + "pst" => -28800, + "pwt" => 32400, + "pyst" => -10800, + "q" => -14400, + "qyzt" => 21600, + "r" => -18000, + "ret" => 14400, + "romance" => 3600, + "rott" => -10800, + "russian" => 10800, + "s" => -21600, + "sa eastern" => -10800, + "sa pacific" => -18000, + "sa western" => -14400, + "sakt" => 39600, + "samoa" => -39600, + "samt" => 14400, + "sast" => 7200, + "sbt" => 39600, + "sct" => 14400, + "se asia" => 25200, + "sgt" => 28800, + "south africa" => 7200, + "sret" => 39600, + "sri lanka" => 21600, + "srt" => -10800, + "sst" => -39600, + "swt" => 3600, + "syot" => 10800, + "t" => -25200, + "taht" => -36000, + "taipei" => 28800, + "tasmania" => 36000, + "tft" => 18000, + "tjt" => 18000, + "tkt" => 46800, + "tlt" => 32400, + "tmt" => 18000, + "tokyo" => 32400, + "tonga" => 46800, + "tost" => 50400, + "tot" => 46800, + "trt" => 10800, + "tvt" => 43200, + "u" => -28800, + "ulast" => 32400, + "ulat" => 28800, + "us eastern" => -18000, + "us mountain" => -25200, + "ut" => 0, + "utc" => 0, + "uyst" => -7200, + "uyt" => -10800, + "uzt" => 18000, + "v" => -32400, + "vet" => -14400, + "vladivostok" => 36000, + "vlast" => 39600, + "vlat" => 36000, + "vost" => 21600, + "vut" => 39600, + "w" => -36000, + "w. australia" => 28800, + "w. central africa" => 3600, + "w. europe" => 3600, + "wadt" => 28800, + "wakt" => 43200, + "warst" => -10800, + "wast" => 7200, + "wat" => 3600, + "west" => 3600, + "west asia" => 18000, + "west pacific" => 36000, + "wet" => 0, + "wft" => 43200, + "wgst" => -3600, + "wgt" => -7200, + "wib" => 25200, + "wit" => 32400, + "wita" => 28800, + "wt" => 0, + "x" => -39600, + "y" => -43200, + "yakst" => 36000, + "yakt" => 32400, + "yakutsk" => 32400, + "yapt" => 36000, + "ydt" => -28800, + "yekst" => 21600, + "yekt" => 18000, + "yst" => -32400, + "z" => 0, + "zp4" => 14400, + "zp5" => 18000, + "zp6" => 21600, }.freeze end From 2b938aa228d14cde20c90a6cf03bb29f3a863442 Mon Sep 17 00:00:00 2001 From: jinroq Date: Mon, 2 Mar 2026 02:20:56 +0900 Subject: [PATCH 07/11] Remove redundant .encode(Encoding::US_ASCII).freeze from constants.rb The file already has `# encoding: US-ASCII` magic comment, which makes string literals US-ASCII by default. Additionally, `# frozen_string_literal: true` makes .freeze unnecessary for string literals. - Remove .encode(Encoding::US_ASCII).freeze from MONTH_DAY_SUFFIX (keep .freeze since format() returns a new mutable string) - Remove .encode(Encoding::US_ASCII).freeze from DEFAULT_STRFTIME_FMT - Remove .encode(Encoding::US_ASCII).freeze from YMD_FMT --- lib/date/constants.rb | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/lib/date/constants.rb b/lib/date/constants.rb index c9333b6a..c2b9313a 100644 --- a/lib/date/constants.rb +++ b/lib/date/constants.rb @@ -101,17 +101,17 @@ class Date MONTH_DAY_SUFFIX = Array.new(13) { |m| Array.new(32) { |d| next nil if m == 0 || d == 0 - format('-%02d-%02d', m, d).encode(Encoding::US_ASCII).freeze + format('-%02d-%02d', m, d).freeze }.freeze }.freeze private_constant :MONTH_DAY_SUFFIX # === String formatting (from strftime.rb) === - DEFAULT_STRFTIME_FMT = '%F'.encode(Encoding::US_ASCII).freeze + DEFAULT_STRFTIME_FMT = '%F' private_constant :DEFAULT_STRFTIME_FMT - YMD_FMT = '%Y-%m-%d'.encode(Encoding::US_ASCII).freeze + YMD_FMT = '%Y-%m-%d' private_constant :YMD_FMT # Locale-independent month/day name tables (same as C ext) From fb3743926ed83bef4cc928f6d64989721e5327a1 Mon Sep 17 00:00:00 2001 From: jinroq Date: Mon, 2 Mar 2026 10:39:04 +0900 Subject: [PATCH 08/11] Optimize Date.new by delegating to Date.civil directly Skip Class#new -> allocate -> initialize overhead by defining Date.new as a class method that delegates to Date.civil. Also replace rescue-based type guard with direct Integer === checks to eliminate rescue frame cost. Add DateTime.new override to prevent infinite recursion from inheritance. Performance comparison (Date.new): | Method | C ext (i/s) | Pure Ruby Before (i/s) | Pure Ruby After (i/s) | vs C ext | |------------|---------------|------------------------|-----------------------|----------| | Date.new | 4,648,499 | 1,531,119 (32.9%) | 2,011,298 (43.3%) | 43.3% | | Date.civil | 4,648,499 | 2,137,457 (46.0%) | 2,118,545 (45.6%) | 45.6% | --- lib/date/core.rb | 155 +++++++++++++++++++++++-------------------- lib/date/datetime.rb | 19 ++++-- lib/date/parse.rb | 4 +- lib/date/strftime.rb | 34 +++++----- lib/date/strptime.rb | 12 ++-- lib/date/time.rb | 2 +- 6 files changed, 122 insertions(+), 104 deletions(-) diff --git a/lib/date/core.rb b/lib/date/core.rb index e625ddd2..886a7c02 100644 --- a/lib/date/core.rb +++ b/lib/date/core.rb @@ -12,42 +12,46 @@ class Date class << self # Same as Date.new. def civil(year = -4712, month = 1, day = 1, start = DEFAULT_SG) - unless (Integer === (year + month + day) rescue false) && month >= 1 && month <= 12 - return new(year, month, day, start) - end - if day >= 1 && day <= 28 - gy = month > 2 ? year : year - 1 - gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[month] + day - a = gy / 100 - jd_julian = gjd_base - 1524 - gjd = jd_julian + 2 - a + a / 4 - obj = allocate - obj.__send__(:_init_from_jd, gjd >= start ? gjd : jd_julian, start) - return obj - elsif day >= -31 - dim = if month == 2 - if start == Float::INFINITY - year % 4 == 0 ? 29 : 28 - else - (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? 29 : 28 - end - else - DAYS_IN_MONTH_GREGORIAN[month] - end - d = day < 0 ? day + dim + 1 : day - if d >= 1 && d <= dim + if Integer === year && Integer === month && Integer === day && month >= 1 && month <= 12 + if day >= 1 && day <= 28 gy = month > 2 ? year : year - 1 - gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[month] + d + gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[month] + day a = gy / 100 jd_julian = gjd_base - 1524 gjd = jd_julian + 2 - a + a / 4 obj = allocate - obj.__send__(:_init_from_jd, gjd >= start ? gjd : jd_julian, start) + obj.__send__(:init_from_jd, gjd >= start ? gjd : jd_julian, start) return obj + elsif day >= -31 + dim = if month == 2 + if start == Float::INFINITY + year % 4 == 0 ? 29 : 28 + else + (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)) ? 29 : 28 + end + else + DAYS_IN_MONTH_GREGORIAN[month] + end + d = day < 0 ? day + dim + 1 : day + if d >= 1 && d <= dim + gy = month > 2 ? year : year - 1 + gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[month] + d + a = gy / 100 + jd_julian = gjd_base - 1524 + gjd = jd_julian + 2 - a + a / 4 + obj = allocate + obj.__send__(:init_from_jd, gjd >= start ? gjd : jd_julian, start) + return obj + end end end - new(year, month, day, start) + civil_fallback(year, month, day, start) + end + + def new(year = -4712, month = 1, day = 1, start = DEFAULT_SG) + civil(year, month, day, start) end + # call-seq: # Date.valid_civil?(year, month, mday, start = Date::ITALY) -> true or false # @@ -94,7 +98,7 @@ def valid_civil?(year, month, day, start = DEFAULT_SG) def jd(jd = 0, start = DEFAULT_SG) jd = Integer(jd) obj = allocate - obj.__send__(:_init_from_jd, jd, start) + obj.__send__(:init_from_jd, jd, start) obj end @@ -180,14 +184,14 @@ def ordinal(year = -4712, yday = 1, start = DEFAULT_SG) gjd = gjd_base - 1524 + 2 - a + a / 4 jd1 = gjd >= start ? gjd : gjd_base - 1524 obj = allocate - obj.__send__(:_init_from_jd, jd1 + yday - 1, start) + obj.__send__(:init_from_jd, jd1 + yday - 1, start) return obj end year = Integer(year) yday = Integer(yday) jd = internal_valid_ordinal?(year, yday, start) raise Date::Error, "invalid date" unless jd - _new_from_jd(jd, start) + new_from_jd(jd, start) end # call-seq: @@ -263,7 +267,7 @@ def commercial(cwyear = -4712, cweek = 1, cwday = 1, start = DEFAULT_SG) mon_wk1 = jd_jan4 - (wday_jan4 == 0 ? 6 : wday_jan4 - 1) jd = mon_wk1 + (cweek - 1) * 7 + (cwday - 1) obj = allocate - obj.__send__(:_init_from_jd, jd, start) + obj.__send__(:init_from_jd, jd, start) return obj end cwyear = Integer(cwyear) @@ -271,7 +275,7 @@ def commercial(cwyear = -4712, cweek = 1, cwday = 1, start = DEFAULT_SG) cwday = Integer(cwday) jd = internal_valid_commercial?(cwyear, cweek, cwday, start) raise Date::Error, "invalid date" unless jd - _new_from_jd(jd, start) + new_from_jd(jd, start) end # call-seq: @@ -307,7 +311,7 @@ def weeknum(year = -4712, week = 0, wday = 1, wstart = 0, start = DEFAULT_SG) # Verify the resulting date is in the same year (week must be valid) y2, = jd_to_civil(jd, start) raise Date::Error, "invalid date" if y2 != year - _new_from_jd(jd, start) + new_from_jd(jd, start) end # call-seq: @@ -324,7 +328,7 @@ def nth_kday(year = -4712, month = 1, n = 1, k = 1, start = DEFAULT_SG) # Verify the result is in the same month y2, m2, = jd_to_civil(jd, start) raise Date::Error, "invalid date" if y2 != year || m2 != month - _new_from_jd(jd, start) + new_from_jd(jd, start) end # call-seq: @@ -339,7 +343,7 @@ def nth_kday(year = -4712, month = 1, n = 1, k = 1, start = DEFAULT_SG) def today(start = DEFAULT_SG) t = Time.now jd = civil_to_jd(t.year, t.mon, t.mday, start) - _new_from_jd(jd, start) + new_from_jd(jd, start) end # :nodoc: @@ -358,12 +362,21 @@ def new!(ajd = 0, of = 0, sg = DEFAULT_SG) jd = raw_jd.floor df = raw_jd - jd obj = allocate - obj.__send__(:_init_from_jd, jd, sg, df == 0 ? nil : df) + obj.__send__(:init_from_jd, jd, sg, df == 0 ? nil : df) obj end private + def civil_fallback(year, month, day, start) + year = Integer(year) + month = Integer(month) + day = Integer(day) + jd = internal_valid_civil?(year, month, day, start) + raise Date::Error, "invalid date" unless jd + new_from_jd(jd, start) + end + # --------------------------------------------------------------------------- # Internal calendar arithmetic (pure Ruby, no C dependency) # --------------------------------------------------------------------------- @@ -602,14 +615,14 @@ def internal_valid_commercial?(y, w, d, sg) # --------------------------------------------------------------------------- # Build a Date from a Julian Day Number (integer part), start, and optional day fraction. - def _new_from_jd(jd, sg, df = nil) + def new_from_jd(jd, sg, df = nil) obj = allocate - obj.__send__(:_init_from_jd, jd, sg, df) + obj.__send__(:init_from_jd, jd, sg, df) obj end # Parse offset string like "+09:00", "-07:30", "Z" to seconds. - def _offset_str_to_sec(str) + def offset_str_to_sec(str) case str when 'Z', 'z', 'UTC', 'GMT' 0 @@ -696,7 +709,7 @@ def initialize(year = -4712, month = 1, day = 1, start = DEFAULT_SG) day = Integer(day) jd = self.class.__send__(:internal_valid_civil?, year, month, day, start) raise Date::Error, "invalid date" unless jd - _init_from_jd(jd, start) + init_from_jd(jd, start) end # --------------------------------------------------------------------------- @@ -712,7 +725,7 @@ def initialize(year = -4712, month = 1, day = 1, start = DEFAULT_SG) # (Date.new(1, 1, 1) - 1).year # => 0 # def year - _civil unless @year + internal_civil unless @year @year end @@ -724,7 +737,7 @@ def year # Date.new(2001, 2, 3).mon # => 2 # def month - _civil unless @year + internal_civil unless @year @month end alias mon month @@ -737,7 +750,7 @@ def month # Date.new(2001, 2, 3).mday # => 3 # def day - _civil unless @year + internal_civil unless @year @day end alias mday day @@ -838,7 +851,7 @@ def ld # def yday return @yday if @yday - _civil unless @year + internal_civil unless @year # inline civil_to_jd(@year, 1, 1, @sg): month=1 (<= 2 so y-=1), day=1 yy = @year - 1 gjd_base = (1461 * (yy + 4716)) / 4 + 429 # GJD_MONTH_OFFSET[1](=428) + 1 @@ -884,7 +897,7 @@ def cwday # Date.new(2001, 2, 3).cweek # => 5 # def cweek - @cweek || _compute_commercial[1] + @cweek || compute_commercial[1] end # call-seq: @@ -897,7 +910,7 @@ def cweek # Date.new(2000, 1, 1).cwyear # => 1999 # def cwyear - @cwyear || _compute_commercial[0] + @cwyear || compute_commercial[0] end # call-seq: @@ -920,7 +933,7 @@ def day_fraction # Date.new(2001).leap? # => false # def leap? - _civil unless @year + internal_civil unless @year if @jd < @sg # julian? @year % 4 == 0 else @@ -1236,7 +1249,7 @@ def +(other) obj.instance_variable_set(:@sg, @sg) obj else - self.class.__send__(:_new_from_jd, @jd + other, @sg, @df) + self.class.__send__(:new_from_jd, @jd + other, @sg, @df) end when Numeric r = other.to_r @@ -1244,7 +1257,7 @@ def +(other) total = r + (@df || 0) days = total.floor frac = total - days - self.class.__send__(:_new_from_jd, @jd + days, @sg, frac == 0 ? nil : frac) + self.class.__send__(:new_from_jd, @jd + days, @sg, frac == 0 ? nil : frac) else raise TypeError, "expected numeric" end @@ -1278,7 +1291,7 @@ def -(other) obj.instance_variable_set(:@sg, @sg) obj else - self.class.__send__(:_new_from_jd, @jd - other, @sg, @df) + self.class.__send__(:new_from_jd, @jd - other, @sg, @df) end when Numeric r = other.to_r @@ -1286,7 +1299,7 @@ def -(other) total = (@df || 0) - r days = total.floor frac = total - days - self.class.__send__(:_new_from_jd, @jd + days, @sg, frac == 0 ? nil : frac) + self.class.__send__(:new_from_jd, @jd + days, @sg, frac == 0 ? nil : frac) else raise TypeError, "expected numeric" end @@ -1318,7 +1331,7 @@ def -(other) # d2 = d1 >> -1 # => # # def >>(n) - _civil unless @year + internal_civil unless @year m2 = @month + n.to_i y2 = @year + (m2 - 1).div(12) m2 = (m2 - 1) % 12 + 1 @@ -1340,7 +1353,7 @@ def >>(n) a = yy / 100 gjd = gjd_base - 1524 + 2 - a + a / 4 jd2 = gjd >= @sg ? gjd : gjd_base - 1524 - # inline _new_from_jd + # inline new_from_jd obj = self.class.allocate obj.instance_variable_set(:@jd, jd2) obj.instance_variable_set(:@sg, @sg) @@ -1638,22 +1651,22 @@ def marshal_load(array) # Format 1.4/1.6: [jd_like, sg_or_bool] jd_like, sg_or_bool = array sg = sg_or_bool == true ? GREGORIAN : (sg_or_bool == false ? JULIAN : sg_or_bool.to_f) - _init_from_jd(jd_like.to_i, sg) + init_from_jd(jd_like.to_i, sg) when 3 # Format 1.8: [ajd, of, sg] ajd, _of, sg = array raw_jd = ajd + Rational(1, 2) jd = raw_jd.floor df = raw_jd - jd - _init_from_jd(jd, sg, df == 0 ? nil : df) + init_from_jd(jd, sg, df == 0 ? nil : df) when 6 # Current format: [nth, jd, df, sf, of, sg] _nth, jd, df, sf, _of, sg = array if df != 0 || sf != 0 day_frac = (Rational(df) + sf) / 86400 - _init_from_jd(jd, sg, day_frac) + init_from_jd(jd, sg, day_frac) else - _init_from_jd(jd, sg) + init_from_jd(jd, sg) end else raise TypeError, "invalid marshal data" @@ -1697,20 +1710,20 @@ def deconstruct_keys(keys) if keys.size == 1 case keys[0] when :year - _civil unless @year + internal_civil unless @year { year: @year } when :month - _civil unless @year + internal_civil unless @year { month: @month } when :day - _civil unless @year + internal_civil unless @year { day: @day } when :wday then { wday: (@jd + 1) % 7 } when :yday then { yday: yday } else {} end else - _civil unless @year + internal_civil unless @year h = {} keys.each do |k| case k @@ -1724,7 +1737,7 @@ def deconstruct_keys(keys) h end else - _civil unless @year + internal_civil unless @year { year: @year, month: @month, day: @day, wday: (@jd + 1) % 7, yday: yday } end end @@ -1745,7 +1758,7 @@ def deconstruct_keys(keys) # See {asctime}[https://linux.die.net/man/3/asctime]. # def asctime - _civil unless @year + internal_civil unless @year d = @day d_s = d < 10 ? " #{d}" : d.to_s y = @year @@ -1794,7 +1807,7 @@ def rfc3339 # Date.new(2001, 2, 3).rfc2822 # => "Sat, 3 Feb 2001 00:00:00 +0000" # def rfc2822 - _civil unless @year + internal_civil unless @year w = (@jd + 1) % 7 y = @year y_s = y >= 1000 ? y.to_s : (y >= 0 ? format('%04d', y) : format('-%04d', -y)) @@ -1815,7 +1828,7 @@ def rfc2822 # Date.new(2001, 2, 3).httpdate # => "Sat, 03 Feb 2001 00:00:00 GMT" # def httpdate - _civil unless @year + internal_civil unless @year w = (@jd + 1) % 7 y = @year y_s = y >= 1000 ? y.to_s : (y >= 0 ? format('%04d', y) : format('-%04d', -y)) @@ -1835,7 +1848,7 @@ def httpdate # Date.new(2001, 2, 3).jisx0301 # => "H13.02.03" # def jisx0301 - _civil unless @year + internal_civil unless @year jd = @jd m = @month d = @day @@ -1865,7 +1878,7 @@ def jisx0301 # Date.new(2001, 2, 3).to_s # => "2001-02-03" # def to_s - _civil + internal_civil suffix = MONTH_DAY_SUFFIX[@month][@day] y = @year if y >= 1000 @@ -1893,7 +1906,7 @@ def inspect # override def freeze - _civil # compute and cache civil date before freezing + internal_civil # compute and cache civil date before freezing super end @@ -1903,13 +1916,13 @@ def freeze private - def _init_from_jd(jd, sg, df = nil) + def init_from_jd(jd, sg, df = nil) @jd = jd @sg = sg @df = df end - def _civil + def internal_civil return if @year jd = @jd if @sg == Float::INFINITY # always Julian @@ -1932,7 +1945,7 @@ def _civil end # Inline jd_to_commercial: compute and cache cwyear/cweek - def _compute_commercial + def compute_commercial jd = @jd wday_val = (jd + 1) % 7 cwday_val = wday_val == 0 ? 7 : wday_val diff --git a/lib/date/datetime.rb b/lib/date/datetime.rb index aa68c08c..3bf636d7 100644 --- a/lib/date/datetime.rb +++ b/lib/date/datetime.rb @@ -356,13 +356,13 @@ def deconstruct_keys(keys) if keys.size == 1 case keys[0] when :year - _civil unless @year + internal_civil unless @year { year: @year } when :month - _civil unless @year + internal_civil unless @year { month: @month } when :day - _civil unless @year + internal_civil unless @year { day: @day } when :wday then { wday: (@jd + 1) % 7 } when :yday then { yday: yday } @@ -374,7 +374,7 @@ def deconstruct_keys(keys) else {} end else - _civil unless @year + internal_civil unless @year h = {} keys.each do |k| case k @@ -393,7 +393,7 @@ def deconstruct_keys(keys) h end else - _civil unless @year + internal_civil unless @year { year: @year, month: @month, day: @day, wday: (@jd + 1) % 7, yday: yday, hour: @hour, min: @min, sec: @sec_i, sec_fraction: @sec_frac, zone: _of2str(@of) } end @@ -476,7 +476,7 @@ def marshal_load(array) # # Returns a Date object which denotes self. def to_date - Date.__send__(:_new_from_jd, @jd, @sg) + Date.__send__(:new_from_jd, @jd, @sg) end # call-seq: @@ -505,6 +505,11 @@ def to_time # --------------------------------------------------------------------------- class << self + def new(year = -4712, month = 1, day = 1, hour = 0, minute = 0, second = 0, offset = 0, start = Date::ITALY) + instance = allocate + instance.__send__(:initialize, year, month, day, hour, minute, second, offset, start) + instance + end alias_method :civil, :new undef_method :today @@ -859,7 +864,7 @@ def _dt_new_by_frags(hash, sg) # rubocop:disable Metrics/MethodLength def _parse_of(offset) case offset when String - Date.__send__(:_offset_str_to_sec, offset) + Date.__send__(:offset_str_to_sec, offset) when Rational (offset * 86400).to_i when Numeric diff --git a/lib/date/parse.rb b/lib/date/parse.rb index 682f6b40..0f05cd75 100644 --- a/lib/date/parse.rb +++ b/lib/date/parse.rb @@ -1688,11 +1688,11 @@ def fast_new_date(hash, sg) if y >= 1583 && m >= 1 && m <= 12 && d >= 1 && d <= 28 && sg <= 2299161 gy = m <= 2 ? y - 1 : y a = gy / 100 - _new_from_jd((1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[m] + d - 1524 + 2 - a + a / 4, sg) + new_from_jd((1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[m] + d - 1524 + 2 - a + a / 4, sg) else jd = internal_valid_civil?(y, m, d, sg) raise Error, 'invalid date' if jd.nil? - _new_from_jd(jd, sg) + new_from_jd(jd, sg) end else _new_by_frags(hash, sg) diff --git a/lib/date/strftime.rb b/lib/date/strftime.rb index d86ad7a9..681854c2 100644 --- a/lib/date/strftime.rb +++ b/lib/date/strftime.rb @@ -14,12 +14,12 @@ class Date # {Formats for Dates and Times}[rdoc-ref:language/strftime_formatting.rdoc]. def strftime(format = DEFAULT_STRFTIME_FMT) if format.equal?(DEFAULT_STRFTIME_FMT) - _civil unless @year + internal_civil unless @year return _fast_ymd.force_encoding(Encoding::US_ASCII) end fmt = format.to_str if fmt == YMD_FMT - _civil unless @year + internal_civil unless @year return _fast_ymd.force_encoding(Encoding::US_ASCII) end internal_strftime(fmt).force_encoding(fmt.encoding) @@ -31,15 +31,15 @@ def internal_strftime(fmt) # rubocop:disable Metrics/MethodLength,Metrics/Cyclom # Fast path for common format strings (whole-string match) case fmt when '%Y-%m-%d', '%F' - _civil unless @year + internal_civil unless @year return _fast_ymd when '%H:%M:%S', '%T', '%X' return instance_of?(Date) ? +'00:00:00' : "#{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]}" when '%m/%d/%y', '%D', '%x' - _civil unless @year + internal_civil unless @year return "#{PAD2[@month]}/#{PAD2[@day]}/#{PAD2[@year.abs % 100]}" when '%Y-%m-%dT%H:%M:%S%z' - _civil unless @year + internal_civil unless @year if instance_of?(Date) return _fast_ymd << 'T00:00:00+0000' else @@ -49,10 +49,10 @@ def internal_strftime(fmt) # rubocop:disable Metrics/MethodLength,Metrics/Cyclom return "#{_fast_ymd}T#{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]}#{sign}#{PAD2[abs / 3600]}#{PAD2[(abs % 3600) / 60]}" end when '%a %b %e %H:%M:%S %Y', '%c' - _civil unless @year + internal_civil unless @year return _fmt_asctime_str when '%A, %B %d, %Y' - _civil unless @year + internal_civil unless @year w = (@jd + 1) % 7 y = @year y_s = y >= 1000 ? y.to_s : (y >= 0 ? format('%04d', y) : format('-%04d', -y)) @@ -194,7 +194,7 @@ def _fmt_asctime_str def _fast_spec(spec) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity case spec when 89 # 'Y' - _civil unless @year + internal_civil unless @year y = @year if y >= 1000 s = y.to_s @@ -206,13 +206,13 @@ def _fast_spec(spec) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticCo format('-%04d', -y) end when 109 # 'm' - _civil unless @year + internal_civil unless @year PAD2[@month] when 100 # 'd' - _civil unless @year + internal_civil unless @year PAD2[@day] when 101 # 'e' - _civil unless @year + internal_civil unless @year d = @day d < 10 ? " #{d}" : d.to_s when 72 # 'H' @@ -226,10 +226,10 @@ def _fast_spec(spec) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticCo when 65 # 'A' STRFTIME_DAYS_FULL[(@jd + 1) % 7] when 98, 104 # 'b', 'h' - _civil unless @year + internal_civil unless @year STRFTIME_MONTHS_ABBR[@month] when 66 # 'B' - _civil unless @year + internal_civil unless @year STRFTIME_MONTHS_FULL[@month] when 112 # 'p' internal_hour < 12 ? 'AM' : 'PM' @@ -255,7 +255,7 @@ def _fast_spec(spec) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticCo when 117 # 'u' cwday.to_s when 121 # 'y' - _civil unless @year + internal_civil unless @year PAD2[@year.abs % 100] when 90 # 'Z' _zone_str @@ -268,15 +268,15 @@ def _fast_spec(spec) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticCo ((@jd - 2440588) * 86400 - _of_seconds + internal_hour * 3600 + internal_min * 60 + internal_sec).to_s # Composite specs — inline expansion when 99 # 'c' - _civil unless @year + internal_civil unless @year _fmt_asctime_str when 70 # 'F' - _civil unless @year + internal_civil unless @year _fast_ymd when 84, 88 # 'T', 'X' instance_of?(Date) ? '00:00:00' : "#{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]}" when 68, 120 # 'D', 'x' - _civil unless @year + internal_civil unless @year "#{PAD2[@month]}/#{PAD2[@day]}/#{PAD2[@year.abs % 100]}" when 82 # 'R' instance_of?(Date) ? '00:00' : "#{PAD2[internal_hour]}:#{PAD2[internal_min]}" diff --git a/lib/date/strptime.rb b/lib/date/strptime.rb index d343ff52..3a482be0 100644 --- a/lib/date/strptime.rb +++ b/lib/date/strptime.rb @@ -82,7 +82,7 @@ def strptime(string = JULIAN_EPOCH_DATE, format = '%F', start = DEFAULT_SG) (year = hash[:year]) && (mon = hash[:mon]) && (mday = hash[:mday]) jd = internal_valid_civil?(year, mon, mday, start) raise Error, 'invalid date' if jd.nil? - return _new_from_jd(jd, start) + return new_from_jd(jd, start) end _new_by_frags(hash, start) end @@ -881,10 +881,10 @@ def _strptime_ymd_to_date(str, sg) # rubocop:disable Metrics/MethodLength a = gy / 100 gjd = gjd_base - 1524 + 2 - a + a / 4 jd = gjd >= sg ? gjd : gjd_base - 1524 - return _new_from_jd(jd, sg) + return new_from_jd(jd, sg) else jd = internal_valid_civil?(year, mon, mday, sg) - return jd ? _new_from_jd(jd, sg) : nil + return jd ? new_from_jd(jd, sg) : nil end end return nil @@ -958,7 +958,7 @@ def _strptime_ymd_to_date(str, sg) # rubocop:disable Metrics/MethodLength jd = internal_valid_civil?(year, mon, mday, sg) return nil unless jd end - _new_from_jd(jd, sg) + new_from_jd(jd, sg) end # Fast path for "%a %b %d %Y" format (complex benchmark). @@ -1149,7 +1149,7 @@ def _strptime_abdy_to_date(str, sg) # rubocop:disable Metrics/MethodLength,Metri jd = internal_valid_civil?(year, mon, mday, sg) return nil unless jd end - _new_from_jd(jd, sg) + new_from_jd(jd, sg) end # Parse zone from string at position si; update hash[:zone] and hash[:offset]. @@ -1486,7 +1486,7 @@ def _new_by_frags(hash, sg) hash = _sp_complete_frags(Date, hash) jd = _sp_valid_date_frags_p(hash, sg) raise Error, 'invalid date' if jd.nil? - _new_from_jd(jd, sg) + new_from_jd(jd, sg) end end end diff --git a/lib/date/time.rb b/lib/date/time.rb index ee8ef7c3..cc463b5c 100644 --- a/lib/date/time.rb +++ b/lib/date/time.rb @@ -15,7 +15,7 @@ def to_time # Returns a Date object which denotes self. def to_date jd = Date.__send__(:gregorian_to_jd, year, mon, mday) - Date.__send__(:_new_from_jd, jd, Date::ITALY) + Date.__send__(:new_from_jd, jd, Date::ITALY) end unless method_defined?(:to_date) # call-seq: From a65aca656dfbef94af8ed97ec05a17c5183fda82 Mon Sep 17 00:00:00 2001 From: jinroq Date: Tue, 3 Mar 2026 16:21:31 +0900 Subject: [PATCH 09/11] Refactor getbyte to StringScanner, and optimize strptime Replace all getbyte-based byte manipulation with StringScanner and regex patterns across parse.rb, strftime.rb, and strptime.rb for improved readability and maintainability. Key changes: - Replace getbyte loops with StringScanner#scan/skip and regex patterns - Optimize strptime fast paths using match? + byteslice instead of StringScanner allocation - Add 17 pre-compiled regex constants for YJIT inline cache efficiency - Inline sp_digits_sc and sp_num_p? helper methods - Replace hash[:_fail] error propagation with throw/catch(:sp_fail) - Extract compute_3key into lib/date/shared.rb Performance (iterations/s, pure Ruby + YJIT vs C ext + YJIT): | Benchmark | C ext+YJIT | pure Ruby+YJIT | Ratio | |------------------------|-------------|-----------------|-------| | Date._strptime | 2,263,815 | 1,284,553 | 57% | | Date.strptime | 1,156,519 | 1,189,801 | 103% | | Date.strptime(complex) | 905,983 | 424,281 | 47% | --- lib/date.rb | 2 + lib/date/constants.rb | 42 +- lib/date/datetime.rb | 14 +- lib/date/parse.rb | 358 ++++--------- lib/date/shared.rb | 13 + lib/date/strftime.rb | 239 ++++----- lib/date/strptime.rb | 1189 ++++++++++++----------------------------- 7 files changed, 555 insertions(+), 1302 deletions(-) create mode 100644 lib/date/shared.rb diff --git a/lib/date.rb b/lib/date.rb index 1bb5da3f..d5869a61 100644 --- a/lib/date.rb +++ b/lib/date.rb @@ -2,10 +2,12 @@ # date.rb: Written by Tadayoshi Funaba 1998-2011 require 'timeout' +require 'strscan' if RUBY_VERSION >= "3.3" require_relative "date/version" require_relative "date/constants" + require_relative "date/shared" require_relative "date/core" require_relative "date/strftime" require_relative "date/parse" diff --git a/lib/date/constants.rb b/lib/date/constants.rb index c2b9313a..707018ed 100644 --- a/lib/date/constants.rb +++ b/lib/date/constants.rb @@ -18,18 +18,6 @@ class Date DEFAULT_SG = ITALY private_constant :DEFAULT_SG - # Pre-computed lowercase byte arrays for fast case-insensitive name matching in strptime - ABBR_DAY_LOWER_BYTES = ABBR_DAYNAMES.map { |n| n.downcase.bytes.freeze }.freeze - DAY_LOWER_BYTES = DAYNAMES.map { |n| n.downcase.bytes.freeze }.freeze - ABBR_MONTH_LOWER_BYTES = ABBR_MONTHNAMES.each_with_object([]) { |n, a| - a << (n ? n.downcase.bytes.freeze : nil) - }.freeze - MONTH_LOWER_BYTES = MONTHNAMES.each_with_object([]) { |n, a| - a << (n ? n.downcase.bytes.freeze : nil) - }.freeze - private_constant :ABBR_DAY_LOWER_BYTES, :DAY_LOWER_BYTES, - :ABBR_MONTH_LOWER_BYTES, :MONTH_LOWER_BYTES - # 3-byte integer key lookup tables for O(1) abbreviated name matching. # Key = (byte0_lower << 16) | (byte1_lower << 8) | byte2_lower # Value = [index, full_name_length] @@ -54,6 +42,12 @@ class Date ABBR_DAY_NUM = ABBR_DAYNAMES.each_with_index.to_h { |n, i| [n.downcase, i] }.freeze private_constant :ABBR_MONTH_NUM, :ABBR_DAY_NUM + # Lowercase full name strings for StringScanner-based head matching + DAY_LOWER_STRS = DAYNAMES.map { |n| n.downcase.freeze }.freeze + MONTH_LOWER_STRS = MONTHNAMES.map { |n| n&.downcase&.freeze }.freeze + private_constant :DAY_LOWER_STRS, :MONTH_LOWER_STRS + + JULIAN_EPOCH_DATE = '-4712-01-01'.freeze JULIAN_EPOCH_DATETIME = '-4712-01-01T00:00:00+00:00'.freeze JULIAN_EPOCH_DATETIME_RFC2822 = 'Mon, 1 Jan -4712 00:00:00 +0000'.freeze @@ -340,10 +334,6 @@ class Date # === Strptime constants (from strptime.rb) === - # Specs that produce numeric output (used by NUM_PATTERN_P lookahead) - STRPTIME_NUMERIC_SPECS = 'CDdeFGgHIjkLlMmNQRrSsTUuVvWwXxYy'.freeze - private_constant :STRPTIME_NUMERIC_SPECS - # Zone pattern matching: numeric offsets and named zones # Matches (case-insensitive): # - Numeric: +/-HHMM, +/-HH:MM, +/-HH:MM:SS, +/-HH,frac, +/-HH.frac @@ -371,24 +361,4 @@ class Date [nil, [:year, :wnum1, :cwday, :hour, :min, :sec]], ].freeze private_constant :COMPLETE_FRAGS_TAB - - # O(1) boolean lookup table for numeric specs (used by _sp_num_p_b?) - # Includes both STRPTIME_NUMERIC_SPECS chars and digits '0'..'9' - STRPTIME_NUMERIC_SPEC_SET = Array.new(256, false).tap { |a| - STRPTIME_NUMERIC_SPECS.each_byte { |b| a[b] = true } - 48.upto(57) { |b| a[b] = true } # '0'..'9' - }.freeze - private_constant :STRPTIME_NUMERIC_SPEC_SET - - # O(1) boolean lookup table for E-modifier valid specs - STRPTIME_E_VALID_SET = Array.new(256, false).tap { |a| - 'cCxXyY'.each_byte { |b| a[b] = true } - }.freeze - private_constant :STRPTIME_E_VALID_SET - - # O(1) boolean lookup table for O-modifier valid specs - STRPTIME_O_VALID_SET = Array.new(256, false).tap { |a| - 'deHImMSuUVwWy'.each_byte { |b| a[b] = true } - }.freeze - private_constant :STRPTIME_O_VALID_SET end diff --git a/lib/date/datetime.rb b/lib/date/datetime.rb index 3bf636d7..fe990943 100644 --- a/lib/date/datetime.rb +++ b/lib/date/datetime.rb @@ -839,12 +839,12 @@ def jisx0301(string = '-4712-01-01T00:00:00+00:00', start = Date::ITALY, limit: # Create a DateTime object from parsed fragment hash. # Uses the same fragment rewrite/complete/validate logic as Date._new_by_frags # but additionally extracts time components (hour, min, sec, offset, sec_fraction). - def _dt_new_by_frags(hash, sg) # rubocop:disable Metrics/MethodLength + def _dt_new_by_frags(hash, sg) raise Date::Error, 'invalid date' if hash.nil? - hash = _sp_rewrite_frags(hash) + hash = sp_rewrite_frags(hash) orig_sec = hash[:sec] - hash = _sp_complete_frags(DateTime, hash) - jd = _sp_valid_date_frags_p(hash, sg) + hash = sp_complete_frags(DateTime, hash) + jd = sp_valid_date_frags_p(hash, sg) raise Date::Error, 'invalid date' if jd.nil? h = hash[:hour] || 0 @@ -904,15 +904,15 @@ def internal_sec @sec_i end - def _sec_frac + def sec_frac @sec_frac end - def _of_seconds + def of_seconds @of end - def _zone_str + def zone_str _of2str(@of) end diff --git a/lib/date/parse.rb b/lib/date/parse.rb index 0f05cd75..72f55646 100644 --- a/lib/date/parse.rb +++ b/lib/date/parse.rb @@ -35,56 +35,21 @@ def _rfc3339(string, limit: 128) # Fast path: YYYY-MM-DDTHH:MM:SS+HH:MM (25 bytes) or YYYY-MM-DDTHH:MM:SSZ (20 bytes) len = string.length if len == 25 || len == 20 - b0 = string.getbyte(0) - if b0 >= 48 && b0 <= 57 && - string.getbyte(4) == 45 && string.getbyte(7) == 45 && - (string.getbyte(10) | 32) == 116 && # T or t - string.getbyte(13) == 58 && string.getbyte(16) == 58 - b1 = string.getbyte(1) - b2 = string.getbyte(2) - b3 = string.getbyte(3) - b5 = string.getbyte(5) - b6 = string.getbyte(6) - b8 = string.getbyte(8) - b9 = string.getbyte(9) - b11 = string.getbyte(11) - b12 = string.getbyte(12) - b14 = string.getbyte(14) - b15 = string.getbyte(15) - b17 = string.getbyte(17) - b18 = string.getbyte(18) - if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && - b5 >= 48 && b5 <= 57 && b6 >= 48 && b6 <= 57 && - b8 >= 48 && b8 <= 57 && b9 >= 48 && b9 <= 57 && - b11 >= 48 && b11 <= 57 && b12 >= 48 && b12 <= 57 && - b14 >= 48 && b14 <= 57 && b15 >= 48 && b15 <= 57 && - b17 >= 48 && b17 <= 57 && b18 >= 48 && b18 <= 57 - h = { - year: (b0 - 48) * 1000 + (b1 - 48) * 100 + (b2 - 48) * 10 + (b3 - 48), - mon: (b5 - 48) * 10 + (b6 - 48), - mday: (b8 - 48) * 10 + (b9 - 48), - hour: (b11 - 48) * 10 + (b12 - 48), - min: (b14 - 48) * 10 + (b15 - 48), - sec: (b17 - 48) * 10 + (b18 - 48) - } - b19 = string.getbyte(19) - if (b19 == 90 || b19 == 122) && len == 20 # Z or z - h[:zone] = string[19, 1] - h[:offset] = 0 - elsif (b19 == 43 || b19 == 45) && len == 25 && string.getbyte(22) == 58 - zone = string[19, 6] - h[:zone] = zone - b20 = string.getbyte(20) - b21 = string.getbyte(21) - b23 = string.getbyte(23) - b24 = string.getbyte(24) - if b20 >= 48 && b20 <= 57 && b21 >= 48 && b21 <= 57 && - b23 >= 48 && b23 <= 57 && b24 >= 48 && b24 <= 57 - h[:offset] = (b19 == 45 ? -1 : 1) * ((b20 - 48) * 36000 + (b21 - 48) * 3600 + (b23 - 48) * 600 + (b24 - 48) * 60) - return h - end - end - return h if h.key?(:zone) + sc = StringScanner.new(string) + if sc.scan(/(\d{4})-(\d{2})-(\d{2})[Tt](\d{2}):(\d{2}):(\d{2})/) + h = { + year: sc[1].to_i, mon: sc[2].to_i, mday: sc[3].to_i, + hour: sc[4].to_i, min: sc[5].to_i, sec: sc[6].to_i + } + if sc.scan(/[Zz]\z/) + h[:zone] = sc.matched + h[:offset] = 0 + return h + elsif sc.scan(/([+-])(\d{2}):(\d{2})\z/) + zone = sc.matched + h[:zone] = zone + h[:offset] = (sc[1] == '-' ? -1 : 1) * (sc[2].to_i * 3600 + sc[3].to_i * 60) + return h end end end @@ -92,24 +57,18 @@ def _rfc3339(string, limit: 128) h = {} if (m = RFC3339_RE.match(string)) h[:year] = m[1].to_i - s = m[2] - h[:mon] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) - s = m[3] - h[:mday] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) - s = m[4] - h[:hour] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) - s = m[5] - h[:min] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) - s = m[6] - h[:sec] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:mon] = m[2].to_i + h[:mday] = m[3].to_i + h[:hour] = m[4].to_i + h[:min] = m[5].to_i + h[:sec] = m[6].to_i h[:sec_fraction] = Rational(m[7].to_i, 10 ** m[7].length) if m[7] zone = m[8] h[:zone] = zone - b0 = zone.getbyte(0) - if b0 == 90 || b0 == 122 # Z or z + if zone[0] == 'Z' || zone[0] == 'z' h[:offset] = 0 else - h[:offset] = (b0 == 45 ? -1 : 1) * ((zone.getbyte(1) - 48) * 36000 + (zone.getbyte(2) - 48) * 3600 + (zone.getbyte(4) - 48) * 600 + (zone.getbyte(5) - 48) * 60) + h[:offset] = (zone[0] == '-' ? -1 : 1) * (zone[1, 2].to_i * 3600 + zone[4, 2].to_i * 60) end end h @@ -140,30 +99,20 @@ def _httpdate(string, limit: 128) return {} if string.empty? raise ArgumentError, "string length (#{string.length}) exceeds the limit #{limit}" if limit && string.length > limit - # Byte-level fast path for Type 1: "Dow, DD Mon YYYY HH:MM:SS GMT" (29 bytes) - # Avoids all regex and string allocation overhead + # Fast path for Type 1: "Dow, DD Mon YYYY HH:MM:SS GMT" (29 bytes) len = string.length if len == 29 - b0 = string.getbyte(0) - if b0 >= 65 && string.getbyte(3) == 44 && string.getbyte(4) == 32 && # alpha, ',', ' ' - string.getbyte(7) == 32 && string.getbyte(11) == 32 && - string.getbyte(16) == 32 && string.getbyte(19) == 58 && - string.getbyte(22) == 58 && string.getbyte(25) == 32 && - string.getbyte(26) == 71 && string.getbyte(27) == 77 && string.getbyte(28) == 84 # 'G','M','T' - wkey = ((b0 | 32) << 16) | ((string.getbyte(1) | 32) << 8) | (string.getbyte(2) | 32) + sc = StringScanner.new(string) + if sc.scan(/([A-Za-z]{3}), (\d{2}) ([A-Za-z]{3}) (\d{4}) (\d{2}):(\d{2}):(\d{2}) (GMT)\z/i) + wkey = compute_3key(sc[1]) wday_info = ABBR_DAY_3KEY[wkey] if wday_info - mkey = ((string.getbyte(8) | 32) << 16) | ((string.getbyte(9) | 32) << 8) | (string.getbyte(10) | 32) + mkey = compute_3key(sc[3]) mon_info = ABBR_MONTH_3KEY[mkey] if mon_info return { - wday: wday_info[0], - mday: (string.getbyte(5) - 48) * 10 + (string.getbyte(6) - 48), - mon: mon_info[0], - year: (string.getbyte(12) - 48) * 1000 + (string.getbyte(13) - 48) * 100 + (string.getbyte(14) - 48) * 10 + (string.getbyte(15) - 48), - hour: (string.getbyte(17) - 48) * 10 + (string.getbyte(18) - 48), - min: (string.getbyte(20) - 48) * 10 + (string.getbyte(21) - 48), - sec: (string.getbyte(23) - 48) * 10 + (string.getbyte(24) - 48), + wday: wday_info[0], mday: sc[2].to_i, mon: mon_info[0], + year: sc[4].to_i, hour: sc[5].to_i, min: sc[6].to_i, sec: sc[7].to_i, zone: 'GMT', offset: 0 } end @@ -174,43 +123,32 @@ def _httpdate(string, limit: 128) h = {} if (m = HTTPDATE_TYPE1_RE.match(string)) h[:wday] = HTTPDATE_WDAY[m[1].downcase] - s = m[2] - h[:mday] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:mday] = m[2].to_i h[:mon] = ABBR_MONTH_NUM[m[3].downcase] h[:year] = m[4].to_i - s = m[5] - h[:hour] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) - s = m[6] - h[:min] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) - s = m[7] - h[:sec] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:hour] = m[5].to_i + h[:min] = m[6].to_i + h[:sec] = m[7].to_i h[:zone] = m[8] h[:offset] = 0 elsif (m = HTTPDATE_TYPE2_RE.match(string)) h[:wday] = HTTPDATE_FULL_WDAY[m[1].downcase] - s = m[2] - h[:mday] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:mday] = m[2].to_i h[:mon] = ABBR_MONTH_NUM[m[3].downcase] y = m[4].to_i h[:year] = y >= 69 ? y + 1900 : y + 2000 - s = m[5] - h[:hour] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) - s = m[6] - h[:min] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) - s = m[7] - h[:sec] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:hour] = m[5].to_i + h[:min] = m[6].to_i + h[:sec] = m[7].to_i h[:zone] = m[8] h[:offset] = 0 elsif (m = HTTPDATE_TYPE3_RE.match(string)) h[:wday] = HTTPDATE_WDAY[m[1].downcase] h[:mon] = ABBR_MONTH_NUM[m[2].downcase] h[:mday] = m[3].to_i - s = m[4] - h[:hour] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) - s = m[5] - h[:min] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) - s = m[6] - h[:sec] = (s.getbyte(0) - 48) * 10 + (s.getbyte(1) - 48) + h[:hour] = m[4].to_i + h[:min] = m[5].to_i + h[:sec] = m[6].to_i h[:year] = m[7].to_i end h @@ -243,41 +181,26 @@ def _rfc2822(string, limit: 128) return {} if string.empty? raise ArgumentError, "string length (#{string.length}) exceeds the limit #{limit}" if limit && string.length > limit - # Byte-level fast path: "Dow, DD Mon YYYY HH:MM:SS +ZZZZ" (31 bytes, 2-digit day) - # Avoids all regex and string allocation overhead + # Fast path: "Dow, DD Mon YYYY HH:MM:SS +ZZZZ" (31 bytes, 2-digit day) len = string.length if len == 31 - b0 = string.getbyte(0) - if b0 >= 65 && string.getbyte(3) == 44 && string.getbyte(4) == 32 && # alpha, ',', ' ' - string.getbyte(7) == 32 && string.getbyte(11) == 32 && - string.getbyte(16) == 32 && string.getbyte(19) == 58 && - string.getbyte(22) == 58 && string.getbyte(25) == 32 - bz0 = string.getbyte(26) - if bz0 == 43 || bz0 == 45 # '+' or '-' - wkey = ((b0 | 32) << 16) | ((string.getbyte(1) | 32) << 8) | (string.getbyte(2) | 32) - wday_info = ABBR_DAY_3KEY[wkey] - if wday_info - mkey = ((string.getbyte(8) | 32) << 16) | ((string.getbyte(9) | 32) << 8) | (string.getbyte(10) | 32) - mon_info = ABBR_MONTH_3KEY[mkey] - if mon_info - bz1 = string.getbyte(27) - bz2 = string.getbyte(28) - bz3 = string.getbyte(29) - bz4 = string.getbyte(30) - sign = bz0 == 45 ? -1 : 1 - offset_val = sign * ((bz1 - 48) * 36000 + (bz2 - 48) * 3600 + (bz3 - 48) * 600 + (bz4 - 48) * 60) - zone = (bz0 == 43 && bz1 == 48 && bz2 == 48 && bz3 == 48 && bz4 == 48) ? '+0000' : string.byteslice(26, 5) - return { - wday: wday_info[0], - mday: (string.getbyte(5) - 48) * 10 + (string.getbyte(6) - 48), - mon: mon_info[0], - year: (string.getbyte(12) - 48) * 1000 + (string.getbyte(13) - 48) * 100 + (string.getbyte(14) - 48) * 10 + (string.getbyte(15) - 48), - hour: (string.getbyte(17) - 48) * 10 + (string.getbyte(18) - 48), - min: (string.getbyte(20) - 48) * 10 + (string.getbyte(21) - 48), - sec: (string.getbyte(23) - 48) * 10 + (string.getbyte(24) - 48), - zone: zone, offset: offset_val - } - end + sc = StringScanner.new(string) + if sc.scan(/([A-Za-z]{3}), (\d{2}) ([A-Za-z]{3}) (\d{4}) (\d{2}):(\d{2}):(\d{2}) ([+-]\d{4})\z/) + wkey = compute_3key(sc[1]) + wday_info = ABBR_DAY_3KEY[wkey] + if wday_info + mkey = compute_3key(sc[3]) + mon_info = ABBR_MONTH_3KEY[mkey] + if mon_info + zone = sc[8] + sign = zone[0] == '-' ? -1 : 1 + offset_val = sign * (zone[1, 2].to_i * 3600 + zone[3, 2].to_i * 60) + zone = '+0000' if zone == '+0000' + return { + wday: wday_info[0], mday: sc[2].to_i, mon: mon_info[0], + year: sc[4].to_i, hour: sc[5].to_i, min: sc[6].to_i, sec: sc[7].to_i, + zone: zone, offset: offset_val + } end end end @@ -293,7 +216,7 @@ def _rfc2822(string, limit: 128) h[:mon] = ABBR_MONTH_NUM[m[3].downcase] y_s = m[4] y = y_s.to_i - ylen = y_s.getbyte(0) == 45 ? y_s.length - 1 : y_s.length + ylen = y_s[0] == '-' ? y_s.length - 1 : y_s.length if ylen < 4 if ylen == 3 h[:year] = y + 1900 @@ -303,14 +226,9 @@ def _rfc2822(string, limit: 128) else h[:year] = y end - s5 = m[5] - h[:hour] = (s5.getbyte(0) - 48) * 10 + (s5.getbyte(1) - 48) - s6 = m[6] - h[:min] = (s6.getbyte(0) - 48) * 10 + (s6.getbyte(1) - 48) - if m[7] - s7 = m[7] - h[:sec] = (s7.getbyte(0) - 48) * 10 + (s7.getbyte(1) - 48) - end + h[:hour] = m[5].to_i + h[:min] = m[6].to_i + h[:sec] = m[7].to_i if m[7] h[:zone] = m[8] h[:offset] = fast_zone_offset(m[8]) end @@ -346,26 +264,9 @@ def _xmlschema(string, limit: 128) # Fast path: YYYY-MM-DD (exactly 10 bytes, all ASCII) if string.length == 10 - b0 = string.getbyte(0) - if b0 >= 48 && b0 <= 57 - b1 = string.getbyte(1) - b2 = string.getbyte(2) - b3 = string.getbyte(3) - if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && - string.getbyte(4) == 45 && string.getbyte(7) == 45 - b5 = string.getbyte(5) - b6 = string.getbyte(6) - b8 = string.getbyte(8) - b9 = string.getbyte(9) - if b5 >= 48 && b5 <= 57 && b6 >= 48 && b6 <= 57 && - b8 >= 48 && b8 <= 57 && b9 >= 48 && b9 <= 57 - return { - year: (b0 - 48) * 1000 + (b1 - 48) * 100 + (b2 - 48) * 10 + (b3 - 48), - mon: (b5 - 48) * 10 + (b6 - 48), - mday: (b8 - 48) * 10 + (b9 - 48) - } - end - end + sc = StringScanner.new(string) + if sc.scan(/(\d{4})-(\d{2})-(\d{2})\z/) + return { year: sc[1].to_i, mon: sc[2].to_i, mday: sc[3].to_i } end end @@ -425,26 +326,9 @@ def _iso8601(string, limit: 128) # Fast path: YYYY-MM-DD (exactly 10 bytes, all ASCII) if string.length == 10 - b0 = string.getbyte(0) - if b0 >= 48 && b0 <= 57 - b1 = string.getbyte(1) - b2 = string.getbyte(2) - b3 = string.getbyte(3) - if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && - string.getbyte(4) == 45 && string.getbyte(7) == 45 - b5 = string.getbyte(5) - b6 = string.getbyte(6) - b8 = string.getbyte(8) - b9 = string.getbyte(9) - if b5 >= 48 && b5 <= 57 && b6 >= 48 && b6 <= 57 && - b8 >= 48 && b8 <= 57 && b9 >= 48 && b9 <= 57 - return { - mday: (b8 - 48) * 10 + (b9 - 48), - year: (b0 - 48) * 1000 + (b1 - 48) * 100 + (b2 - 48) * 10 + (b3 - 48), - mon: (b5 - 48) * 10 + (b6 - 48) - } - end - end + sc = StringScanner.new(string) + if sc.scan(/(\d{4})-(\d{2})-(\d{2})\z/) + return { mday: sc[3].to_i, year: sc[1].to_i, mon: sc[2].to_i } end end @@ -498,23 +382,14 @@ def _jisx0301(string, limit: 128) # Fast path: X##.##.## (9 bytes: era + YY.MM.DD) if string.length == 9 - b0 = string.getbyte(0) | 32 # downcase - era_offset = JISX0301_ERA[b0.chr] - if era_offset && - string.getbyte(3) == 46 && string.getbyte(6) == 46 # '.' - b1 = string.getbyte(1) - b2 = string.getbyte(2) - b4 = string.getbyte(4) - b5 = string.getbyte(5) - b7 = string.getbyte(7) - b8 = string.getbyte(8) - if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && - b4 >= 48 && b4 <= 57 && b5 >= 48 && b5 <= 57 && - b7 >= 48 && b7 <= 57 && b8 >= 48 && b8 <= 57 + sc = StringScanner.new(string) + if sc.scan(/([A-Za-z])(\d{2})\.(\d{2})\.(\d{2})\z/) + era_offset = JISX0301_ERA[sc[1].downcase] + if era_offset return { - year: (b1 - 48) * 10 + (b2 - 48) + era_offset, - mon: (b4 - 48) * 10 + (b5 - 48), - mday: (b7 - 48) * 10 + (b8 - 48) + year: sc[2].to_i + era_offset, + mon: sc[3].to_i, + mday: sc[4].to_i } end end @@ -582,49 +457,17 @@ def _parse(string, comp = true, limit: 128) # Fast ISO: YYYY-MM-DD (exactly 10 ASCII bytes) if len == 10 - b0 = string.getbyte(0) - if b0 >= 48 && b0 <= 57 - b1 = string.getbyte(1) - b2 = string.getbyte(2) - b3 = string.getbyte(3) - if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && - string.getbyte(4) == 45 && string.getbyte(7) == 45 - b5 = string.getbyte(5) - b6 = string.getbyte(6) - b8 = string.getbyte(8) - b9 = string.getbyte(9) - if b5 >= 48 && b5 <= 57 && b6 >= 48 && b6 <= 57 && - b8 >= 48 && b8 <= 57 && b9 >= 48 && b9 <= 57 - return { - year: (b0 - 48) * 1000 + (b1 - 48) * 100 + (b2 - 48) * 10 + (b3 - 48), - mon: (b5 - 48) * 10 + (b6 - 48), - mday: (b8 - 48) * 10 + (b9 - 48) - } - end - end + sc = StringScanner.new(string) + if sc.scan(/(\d{4})-(\d{2})-(\d{2})\z/) + return { year: sc[1].to_i, mon: sc[2].to_i, mday: sc[3].to_i } end end # Fast compact: YYYYMMDD (exactly 8 ASCII digit bytes) if len == 8 - b0 = string.getbyte(0) - if b0 >= 48 && b0 <= 57 - b1 = string.getbyte(1) - b2 = string.getbyte(2) - b3 = string.getbyte(3) - b4 = string.getbyte(4) - b5 = string.getbyte(5) - b6 = string.getbyte(6) - b7 = string.getbyte(7) - if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && - b4 >= 48 && b4 <= 57 && b5 >= 48 && b5 <= 57 && - b6 >= 48 && b6 <= 57 && b7 >= 48 && b7 <= 57 - return { - year: (b0 - 48) * 1000 + (b1 - 48) * 100 + (b2 - 48) * 10 + (b3 - 48), - mon: (b4 - 48) * 10 + (b5 - 48), - mday: (b6 - 48) * 10 + (b7 - 48) - } - end + sc = StringScanner.new(string) + if sc.scan(/(\d{4})(\d{2})(\d{2})\z/) + return { year: sc[1].to_i, mon: sc[2].to_i, mday: sc[3].to_i } end end @@ -981,33 +824,18 @@ def parse_sec_fraction(frac_str) # Fast zone offset calculation for common patterns. # Handles: Z/z, +HH:MM/-HH:MM, +HHMM/-HHMM, short named zones. - # Falls back to _sp_zone_to_diff for complex cases. - def fast_zone_offset(zone_str) # rubocop:disable Metrics/CyclomaticComplexity + # Falls back to sp_zone_to_diff for complex cases. + def fast_zone_offset(zone_str) len = zone_str.length - b0 = zone_str.getbyte(0) # Z/z - return 0 if len == 1 && (b0 == 90 || b0 == 122) - - if b0 == 43 || b0 == 45 # '+' or '-' - sign = b0 == 45 ? -1 : 1 - if len == 6 && zone_str.getbyte(3) == 58 # +HH:MM - b1 = zone_str.getbyte(1) - b2 = zone_str.getbyte(2) - b4 = zone_str.getbyte(4) - b5 = zone_str.getbyte(5) - if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b4 >= 48 && b4 <= 57 && b5 >= 48 && b5 <= 57 - return sign * ((b1 - 48) * 36000 + (b2 - 48) * 3600 + (b4 - 48) * 600 + (b5 - 48) * 60) - end - end - if len == 5 # +HHMM - b1 = zone_str.getbyte(1) - b2 = zone_str.getbyte(2) - b3 = zone_str.getbyte(3) - b4 = zone_str.getbyte(4) - if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && b4 >= 48 && b4 <= 57 - return sign * ((b1 - 48) * 36000 + (b2 - 48) * 3600 + (b3 - 48) * 600 + (b4 - 48) * 60) - end + return 0 if len == 1 && (zone_str[0] == 'Z' || zone_str[0] == 'z') + + if zone_str[0] == '+' || zone_str[0] == '-' + sc = StringScanner.new(zone_str) + if sc.scan(/([+-])(\d{2}):?(\d{2})\z/) + sign = sc[1] == '-' ? -1 : 1 + return sign * (sc[2].to_i * 3600 + sc[3].to_i * 60) end end @@ -1018,7 +846,7 @@ def fast_zone_offset(zone_str) # rubocop:disable Metrics/CyclomaticComplexity end # Fall back to full parser - _sp_zone_to_diff(zone_str) + sp_zone_to_diff(zone_str) end # ------------------------------------------------------------------ @@ -1522,7 +1350,7 @@ def parse_frag(str, h) # s3e: 3-element (year, month, day) disambiguation # Faithfully mirrors the C implementation's s3e() logic. # Arguments: y, m, d are strings (or Integer for m when month name was parsed) - def s3e(h, y, m, d, bc) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + def s3e(h, y, m, d, bc) # Fast path: y is unambiguously a year (3+ digits or signed), m and d are simple digits. # This covers ISO "2001-02-03" but not ambiguous cases like "23/5/1999". if y && m && d && !bc && y.is_a?(String) && m.is_a?(String) && d.is_a?(String) && @@ -1695,7 +1523,7 @@ def fast_new_date(hash, sg) new_from_jd(jd, sg) end else - _new_by_frags(hash, sg) + internal_new_by_frags(hash, sg) end end diff --git a/lib/date/shared.rb b/lib/date/shared.rb new file mode 100644 index 00000000..24dd65f3 --- /dev/null +++ b/lib/date/shared.rb @@ -0,0 +1,13 @@ +# frozen_string_literal: true + +# Shared methods used across multiple Date implementation files. +class Date + # Generate a case-insensitive 3-byte integer key from a 3-character string. + # Used for O(1) abbreviated day/month name lookup in parse.rb and strptime.rb. + # Key = (byte0_lower << 16) | (byte1_lower << 8) | byte2_lower + def self.compute_3key(s) + b = s.bytes + ((b[0] | 0x20) << 16) | ((b[1] | 0x20) << 8) | (b[2] | 0x20) + end + private_class_method :compute_3key +end diff --git a/lib/date/strftime.rb b/lib/date/strftime.rb index 681854c2..65e6444c 100644 --- a/lib/date/strftime.rb +++ b/lib/date/strftime.rb @@ -15,24 +15,24 @@ class Date def strftime(format = DEFAULT_STRFTIME_FMT) if format.equal?(DEFAULT_STRFTIME_FMT) internal_civil unless @year - return _fast_ymd.force_encoding(Encoding::US_ASCII) + return fast_ymd.force_encoding(Encoding::US_ASCII) end fmt = format.to_str if fmt == YMD_FMT internal_civil unless @year - return _fast_ymd.force_encoding(Encoding::US_ASCII) + return fast_ymd.force_encoding(Encoding::US_ASCII) end internal_strftime(fmt).force_encoding(fmt.encoding) end private - def internal_strftime(fmt) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + def internal_strftime(fmt) # Fast path for common format strings (whole-string match) case fmt when '%Y-%m-%d', '%F' internal_civil unless @year - return _fast_ymd + return fast_ymd when '%H:%M:%S', '%T', '%X' return instance_of?(Date) ? +'00:00:00' : "#{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]}" when '%m/%d/%y', '%D', '%x' @@ -41,16 +41,16 @@ def internal_strftime(fmt) # rubocop:disable Metrics/MethodLength,Metrics/Cyclom when '%Y-%m-%dT%H:%M:%S%z' internal_civil unless @year if instance_of?(Date) - return _fast_ymd << 'T00:00:00+0000' + return fast_ymd << 'T00:00:00+0000' else - of = _of_seconds + of = of_seconds sign = of < 0 ? '-' : '+' abs = of.abs - return "#{_fast_ymd}T#{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]}#{sign}#{PAD2[abs / 3600]}#{PAD2[(abs % 3600) / 60]}" + return "#{fast_ymd}T#{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]}#{sign}#{PAD2[abs / 3600]}#{PAD2[(abs % 3600) / 60]}" end when '%a %b %e %H:%M:%S %Y', '%c' internal_civil unless @year - return _fmt_asctime_str + return fmt_asctime_str when '%A, %B %d, %Y' internal_civil unless @year w = (@jd + 1) % 7 @@ -60,124 +60,87 @@ def internal_strftime(fmt) # rubocop:disable Metrics/MethodLength,Metrics/Cyclom end result = +''.encode(fmt.encoding) - i = 0 - len = fmt.bytesize - - while i < len - b = fmt.getbyte(i) + sc = StringScanner.new(fmt) + until sc.eos? # Batch collect literal (non-%) characters - if b != 37 # '%' - lit_start = i - i += 1 - i += 1 while i < len && fmt.getbyte(i) != 37 - result << fmt.byteslice(lit_start, i - lit_start) + if (lit = sc.scan(/[^%]+/)) + result << lit next end - i += 1 # skip '%' - if i >= len + # Must be '%' or something unexpected + unless sc.skip(/%/) + result << sc.getch + next + end + + if sc.eos? result << '%' break end - # Quick dispatch: if next byte is a simple letter spec (A-Z or a-z, - # excluding E/O locale modifiers), skip flag/width/prec parsing entirely. - # Flag chars '-'(45) '_'(95) '0'(48) '^'(94) '#'(35) ':'(58) are all - # outside A-Z(65-90) and a-z(97-122) ranges. - b = fmt.getbyte(i) - if (b >= 65 && b <= 90 && b != 69 && b != 79) || (b >= 97 && b <= 122) - fast = _fast_spec(b) + # Quick dispatch: if next char is a simple letter spec (A-Z excluding E/O, + # or a-z), skip flag/width/prec parsing entirely. + if (quick = sc.scan(/[A-DFG-NP-Za-z]/)) + fast = fast_spec(quick.ord) if fast result << fast - i += 1 next end + sc.unscan end - # Parse flags (bitmask — no Hash allocation) + # Parse flags (bitmask) flags = 0 colons = 0 - loop do - b = fmt.getbyte(i) - case b - when 45 then flags |= FL_LEFT # '-' - when 95 then flags |= FL_SPACE # '_' - when 48 then flags |= FL_ZERO # '0' - when 94 then flags |= FL_UPPER # '^' - when 35 then flags |= FL_CHCASE # '#' - when 58 # ':' - colons += 1 - i += 1 - redo if fmt.getbyte(i) == 58 - break - else break + while (f = sc.scan(/[-_0^#]/)) + case f + when '-' then flags |= FL_LEFT + when '_' then flags |= FL_SPACE + when '0' then flags |= FL_ZERO + when '^' then flags |= FL_UPPER + when '#' then flags |= FL_CHCASE end - i += 1 end - - # Parse width (byte range check — no Regexp) - width = nil - b = fmt.getbyte(i) - if b && b >= 48 && b <= 57 # '0'..'9' - width = b - 48 - i += 1 - b = fmt.getbyte(i) - while b && b >= 48 && b <= 57 - width = width * 10 + (b - 48) - i += 1 - b = fmt.getbyte(i) - end - raise Errno::ERANGE, "strftime" if width > STRFTIME_MAX_WIDTH + if (c = sc.scan(/:+/)) + colons = c.length end + # Parse width + width = sc.scan(/\d+/)&.to_i + raise Errno::ERANGE, "strftime" if width && width > STRFTIME_MAX_WIDTH + # Parse precision (after '.') - prec = nil - if fmt.getbyte(i) == 46 # '.' - i += 1 - prec = 0 - b = fmt.getbyte(i) - while b && b >= 48 && b <= 57 - prec = prec * 10 + (b - 48) - i += 1 - b = fmt.getbyte(i) - end - end + prec = sc.skip(/\./) ? (sc.scan(/\d+/)&.to_i || 0) : nil # Post-width colons (for %8:z, %11::z etc.) - while fmt.getbyte(i) == 58 # ':' - colons += 1 - i += 1 + if (c = sc.scan(/:+/)) + colons += c.length end # Locale modifier (%E or %O) - locale_mod = nil - b = fmt.getbyte(i) - if b == 69 || b == 79 # 'E' or 'O' - locale_mod = b - i += 1 - end + locale_mod = sc.scan(/[EO]/)&.ord - spec = fmt.getbyte(i) - i += 1 + spec = sc.getch&.ord # Inline fast path: no flags, no width, no prec, no locale mod, no colons if flags == 0 && width.nil? && prec.nil? && locale_mod.nil? && colons == 0 - fast = _fast_spec(spec) + fast = fast_spec(spec) if fast result << fast next end end - result << _format_spec_b(spec, flags, colons, width, prec, locale_mod) + result << format_spec_b(spec, flags, colons, width, prec, locale_mod) end result end # Format "%a %b %e %H:%M:%S %Y" directly (used by %c expansion and asctime) - def _fmt_asctime_str + def fmt_asctime_str w = (@jd + 1) % 7 d = @day d_s = d < 10 ? " #{d}" : d.to_s @@ -191,7 +154,7 @@ def _fmt_asctime_str end # Inline fast path for common specs with default formatting (no flags/width/prec) - def _fast_spec(spec) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + def fast_spec(spec) case spec when 89 # 'Y' internal_civil unless @year @@ -258,21 +221,21 @@ def _fast_spec(spec) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticCo internal_civil unless @year PAD2[@year.abs % 100] when 90 # 'Z' - _zone_str + zone_str when 122 # 'z' - of = _of_seconds + of = of_seconds sign = of < 0 ? '-' : '+' abs = of.abs "#{sign}#{PAD2[abs / 3600]}#{PAD2[(abs % 3600) / 60]}" when 115 # 's' - ((@jd - 2440588) * 86400 - _of_seconds + internal_hour * 3600 + internal_min * 60 + internal_sec).to_s + ((@jd - 2440588) * 86400 - of_seconds + internal_hour * 3600 + internal_min * 60 + internal_sec).to_s # Composite specs — inline expansion when 99 # 'c' internal_civil unless @year - _fmt_asctime_str + fmt_asctime_str when 70 # 'F' internal_civil unless @year - _fast_ymd + fast_ymd when 84, 88 # 'T', 'X' instance_of?(Date) ? '00:00:00' : "#{PAD2[internal_hour]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]}" when 68, 120 # 'D', 'x' @@ -289,12 +252,12 @@ def _fast_spec(spec) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticCo "#{PAD2[h]}:#{PAD2[internal_min]}:#{PAD2[internal_sec]} #{internal_hour < 12 ? 'AM' : 'PM'}" end else - nil # fall through to _format_spec_b + nil # fall through to format_spec_b end end - # Full spec handling with bitmask flags (called when _fast_spec returns nil or flags/width/prec present) - def _format_spec_b(spec, flags, colons, width, prec, locale_mod) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + # Full spec handling with bitmask flags (called when fast_spec returns nil or flags/width/prec present) + def format_spec_b(spec, flags, colons, width, prec, locale_mod) # Handle %E/%O locale modifiers if locale_mod valid = locale_mod == 69 ? STRFTIME_E_VALID_BYTES : STRFTIME_O_VALID_BYTES # 69='E' @@ -307,92 +270,92 @@ def _format_spec_b(spec, flags, colons, width, prec, locale_mod) # rubocop:disab case spec when 89, 71 # 'Y', 'G' y = spec == 89 ? year : cwyear - _fmt_year(y, width, prec, flags) + fmt_year(y, width, prec, flags) when 67 # 'C' cent = year.div(100) - _pad_num(cent, width || 2, flags) + pad_num(cent, width || 2, flags) when 121 # 'y' - _pad_num(year.abs % 100, width || 2, flags, zero: true) + pad_num(year.abs % 100, width || 2, flags, zero: true) when 103 # 'g' - _pad_num(cwyear.abs % 100, width || 2, flags, zero: true) + pad_num(cwyear.abs % 100, width || 2, flags, zero: true) when 109 # 'm' - _pad_num(month, width || 2, flags, zero: true) + pad_num(month, width || 2, flags, zero: true) when 100 # 'd' - _pad_num(day, width || 2, flags, zero: true) + pad_num(day, width || 2, flags, zero: true) when 101 # 'e' - _pad_num(day, width || 2, flags, zero: false) + pad_num(day, width || 2, flags, zero: false) when 106 # 'j' - _pad_num(yday, width || 3, flags, zero: true) + pad_num(yday, width || 3, flags, zero: true) when 72 # 'H' - _pad_num(internal_hour, width || 2, flags, zero: true) + pad_num(internal_hour, width || 2, flags, zero: true) when 107 # 'k' - _pad_num(internal_hour, width || 2, flags, zero: false) + pad_num(internal_hour, width || 2, flags, zero: false) when 73 # 'I' h = internal_hour % 12 h = 12 if h == 0 - _pad_num(h, width || 2, flags, zero: true) + pad_num(h, width || 2, flags, zero: true) when 108 # 'l' h = internal_hour % 12 h = 12 if h == 0 - _pad_num(h, width || 2, flags, zero: false) + pad_num(h, width || 2, flags, zero: false) when 77 # 'M' - _pad_num(internal_min, width || 2, flags, zero: true) + pad_num(internal_min, width || 2, flags, zero: true) when 83 # 'S' - _pad_num(internal_sec, width || 2, flags, zero: true) + pad_num(internal_sec, width || 2, flags, zero: true) when 76 # 'L' w = width || 3 - ms = (_sec_frac * (10**w)).floor + ms = (sec_frac * (10**w)).floor ms.to_s.rjust(w, '0') when 78 # 'N' w = width || prec || 9 - ns = (_sec_frac * (10**w)).floor + ns = (sec_frac * (10**w)).floor ns.to_s.rjust(w, '0') when 115 # 's' - unix = (@jd - 2440588) * 86400 - _of_seconds + + unix = (@jd - 2440588) * 86400 - of_seconds + internal_hour * 3600 + internal_min * 60 + internal_sec - _pad_num(unix, width || 1, flags) + pad_num(unix, width || 1, flags) when 81 # 'Q' - ms = ((@jd - 2440588) * 86400 - _of_seconds + + ms = ((@jd - 2440588) * 86400 - of_seconds + internal_hour * 3600 + internal_min * 60 + internal_sec) * 1000 + - (_sec_frac * 1000).floor - _pad_num(ms, width || 1, flags) + (sec_frac * 1000).floor + pad_num(ms, width || 1, flags) when 65 # 'A' - _fmt_str(STRFTIME_DAYS_FULL[wday], width, flags) + fmt_str(STRFTIME_DAYS_FULL[wday], width, flags) when 97 # 'a' - _fmt_str(STRFTIME_DAYS_ABBR[wday], width, flags) + fmt_str(STRFTIME_DAYS_ABBR[wday], width, flags) when 66 # 'B' - _fmt_str(STRFTIME_MONTHS_FULL[month], width, flags) + fmt_str(STRFTIME_MONTHS_FULL[month], width, flags) when 98, 104 # 'b', 'h' - _fmt_str(STRFTIME_MONTHS_ABBR[month], width, flags) + fmt_str(STRFTIME_MONTHS_ABBR[month], width, flags) when 112 # 'p' - _fmt_str(internal_hour < 12 ? 'AM' : 'PM', width, flags) + fmt_str(internal_hour < 12 ? 'AM' : 'PM', width, flags) when 80 # 'P' - _fmt_str(internal_hour < 12 ? 'am' : 'pm', width, flags) + fmt_str(internal_hour < 12 ? 'am' : 'pm', width, flags) when 90 # 'Z' - _fmt_str(_zone_str, width, flags) + fmt_str(zone_str, width, flags) when 122 # 'z' - _fmt_z(colons, width, prec, flags) + fmt_z(colons, width, prec, flags) when 117 # 'u' - _pad_num(cwday, width || 1, flags) + pad_num(cwday, width || 1, flags) when 119 # 'w' - _pad_num(wday, width || 1, flags) + pad_num(wday, width || 1, flags) when 85 # 'U' - _pad_num(_week_number(0), width || 2, flags, zero: true) + pad_num(week_number(0), width || 2, flags, zero: true) when 87 # 'W' - _pad_num(_week_number(1), width || 2, flags, zero: true) + pad_num(week_number(1), width || 2, flags, zero: true) when 86 # 'V' - _pad_num(cweek, width || 2, flags, zero: true) + pad_num(cweek, width || 2, flags, zero: true) when 37 # '%' '%' when 43 # '+' s = internal_strftime('%a %b %e %H:%M:%S %Z %Y') - _fmt_str(s, width, flags) + fmt_str(s, width, flags) else # Try composite expansion = STRFTIME_COMPOSITE_BYTE[spec] if expansion s = internal_strftime(expansion) - _fmt_str(s, width, flags) + fmt_str(s, width, flags) else "%#{spec&.chr}" end @@ -400,7 +363,7 @@ def _format_spec_b(spec, flags, colons, width, prec, locale_mod) # rubocop:disab end # Format year (handles negative years, precision, and all flag variants) - def _fmt_year(y, width, prec, flags) + def fmt_year(y, width, prec, flags) if prec s = y.abs.to_s.rjust(prec, '0') s = (y < 0 ? '-' : '') + s @@ -425,7 +388,7 @@ def _fmt_year(y, width, prec, flags) end end - def _pad_num(n, default_w, flags, zero: nil) + def pad_num(n, default_w, flags, zero: nil) sign = n < 0 ? '-' : '' abs = n.abs.to_s w = default_w @@ -440,7 +403,7 @@ def _pad_num(n, default_w, flags, zero: nil) end end - def _fmt_str(s, width, flags) + def fmt_str(s, width, flags) s = s.dup if flags & FL_CHCASE != 0 s = (s == s.upcase) ? s.downcase : s.upcase @@ -458,7 +421,7 @@ def _fmt_str(s, width, flags) end # Week number (0=first partial week) - def _week_number(ws) + def week_number(ws) yd = yday wd = wday # 0=Sun if ws == 1 @@ -469,8 +432,8 @@ def _week_number(ws) end # Format %z with colons variant and GNU extension flag support - def _fmt_z(colons, width, _prec, flags) - of = _of_seconds + def fmt_z(colons, width, _prec, flags) + of = of_seconds sign = of < 0 ? '-' : '+' abs = of.abs hh = abs / 3600 @@ -534,7 +497,7 @@ def _fmt_z(colons, width, _prec, flags) end # Fast path helper: format '%Y-%m-%d' without allocation overhead - def _fast_ymd + def fast_ymd y = @year suffix = MONTH_DAY_SUFFIX[@month][@day] if y >= 1000 @@ -559,15 +522,15 @@ def internal_sec 0 end - def _sec_frac + def sec_frac Rational(0) end - def _of_seconds + def of_seconds 0 end - def _zone_str + def zone_str '+00:00' end diff --git a/lib/date/strptime.rb b/lib/date/strptime.rb index 3a482be0..cd615b03 100644 --- a/lib/date/strptime.rb +++ b/lib/date/strptime.rb @@ -21,14 +21,14 @@ def _strptime(string, format = '%F') string = String === string ? string : string.to_str format = String === format ? format : format.to_str if format == '%F' || format == '%Y-%m-%d' - return _strptime_ymd(string) + return internal_strptime_ymd(string) end if format == '%a %b %d %Y' - return _strptime_abdy(string) + return internal_strptime_abdy(string) end hash = {} - si = _sp_run(string, 0, format, hash) - return nil if hash.delete(:_fail) + si = catch(:sp_fail) { sp_run(string, 0, format, hash) } + return nil unless si hash[:leftover] = string[si..] if si < string.length if (cent = hash.delete(:_cent)) hash[:year] = hash[:year] + cent * 100 if hash.key?(:year) @@ -66,12 +66,12 @@ def _strptime(string, format = '%F') def strptime(string = JULIAN_EPOCH_DATE, format = '%F', start = DEFAULT_SG) str = String === string ? string : string.to_str if format == '%F' || format == '%Y-%m-%d' - result = _strptime_ymd_to_date(str, start) + result = internalinternal_strptime_ymd_to_date(str, start) return result if result raise Error, 'invalid date' end if format == '%a %b %d %Y' - result = _strptime_abdy_to_date(str, start) + result = internalinternal_strptime_abdy_to_date(str, start) return result if result raise Error, 'invalid date' end @@ -84,870 +84,462 @@ def strptime(string = JULIAN_EPOCH_DATE, format = '%F', start = DEFAULT_SG) raise Error, 'invalid date' if jd.nil? return new_from_jd(jd, start) end - _new_by_frags(hash, start) + internal_new_by_frags(hash, start) end private - # Returns true if the format at position fi starts a numeric conversion spec. - # All byte-level comparison, no String allocation. - def _sp_num_p_b?(fmt, fi, flen) - return false if fi >= flen - c = fmt.getbyte(fi) - return true if c >= 48 && c <= 57 # '0'..'9' - if c == 37 # '%' - i = fi + 1 - return false if i >= flen - c2 = fmt.getbyte(i) - if c2 == 69 || c2 == 79 # 'E' or 'O' - i += 1 - return false if i >= flen - c2 = fmt.getbyte(i) - end - return STRPTIME_NUMERIC_SPEC_SET[c2] - end - false - end - - # Read up to max_w decimal digits from str starting at si. - # Returns [value, chars_consumed] or [nil, 0] if no digit found. - def _sp_digits(str, si, slen, max_w) - l = 0 - v = 0 - while si + l < slen - c = str.getbyte(si + l) - break unless c && c >= 48 && c <= 57 # '0'..'9' - break if l >= max_w - v = v * 10 + (c - 48) - l += 1 - end - return nil, 0 if l == 0 - return v, l - end - - # Whitespace byte check (space, tab, newline, carriage return, vertical tab, form feed) - def _sp_ws?(b) - b == 32 || b == 9 || b == 10 || b == 13 || b == 11 || b == 12 - end - - # Core scanner: walks format string and string simultaneously. - # All comparisons use getbyte for zero-allocation byte-level operation. - # Returns new string index si on success. - # Sets hash[:_fail]=true and returns -1 on failure. - def _sp_run(str, si, fmt, hash) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity - fi = 0 - flen = fmt.bytesize - slen = str.bytesize - - while fi < flen - ch = fmt.getbyte(fi) - + # Pre-compiled regex constants for sp_run + SP_WHITESPACE = /[ \t\n\r\v\f]+/ + SP_COLONS = /:+/ + SP_EO_CHECK = /[EO]/ + SP_E_COMBO = /E[cCxXyY]/ + SP_O_COMBO = /O[deHImMSuUVwWy]/ + SP_ALPHA3 = /[A-Za-z]{3}/ + SP_SIGN = /[+-]/ + SP_SPACE_OR_DIGIT = / \d|\d{1,2}/ + SP_AMPM_DOT = /[AaPp]\.[Mm]\./ + SP_AMPM = /[AaPp][Mm]/ + SP_NUM_CHECK = /\d|%[EO]?[CDdeFGgHIjkLlMmNQRrSsTUuVvWwXxYy0-9]/ + SP_DIGITS_1 = /\d/ + SP_DIGITS_2 = /\d{1,2}/ + SP_DIGITS_3 = /\d{1,3}/ + SP_DIGITS_4 = /\d{1,4}/ + SP_DIGITS_9 = /\d{1,9}/ + SP_DIGITS_MAX = /\d+/ + private_constant :SP_WHITESPACE, :SP_COLONS, :SP_EO_CHECK, :SP_E_COMBO, + :SP_O_COMBO, :SP_ALPHA3, :SP_SIGN, :SP_SPACE_OR_DIGIT, + :SP_AMPM_DOT, :SP_AMPM, :SP_NUM_CHECK, + :SP_DIGITS_1, :SP_DIGITS_2, :SP_DIGITS_3, :SP_DIGITS_4, + :SP_DIGITS_9, :SP_DIGITS_MAX + + # Core scanner: walks format string and string simultaneously using StringScanner. + # Returns new string position on success; throws :sp_fail on failure. + def sp_run(str, si, fmt, hash) + fmt_sc = StringScanner.new(fmt) + str_sc = StringScanner.new(str) + str_sc.pos = si + + until fmt_sc.eos? # Whitespace in format: skip any whitespace in both format and string - if _sp_ws?(ch) - while si < slen && _sp_ws?(str.getbyte(si)) - si += 1 - end - fi += 1 - while fi < flen && _sp_ws?(fmt.getbyte(fi)) - fi += 1 - end + if fmt_sc.skip(SP_WHITESPACE) + str_sc.skip(SP_WHITESPACE) next end - if ch != 37 # '%' - if si >= slen - hash[:_fail] = true - return -1 - end - if str.getbyte(si) != ch - hash[:_fail] = true - return -1 - end - si += 1 - fi += 1 + # Non-% literal: must match exactly + unless fmt_sc.check(/%/) + fc = fmt_sc.getch + throw(:sp_fail) if str_sc.eos? + throw(:sp_fail) if str_sc.getch != fc next end - fi += 1 # skip '%' + fmt_sc.skip(/%/) # skip '%' # Handle colon modifiers: %:z, %::z, %:::z - colons = 0 - while fi < flen && fmt.getbyte(fi) == 58 # ':' - colons += 1 - fi += 1 - end - if colons > 0 - unless fi < flen && fmt.getbyte(fi) == 122 # 'z' - hash[:_fail] = true - return -1 - end - fi += 1 - new_si = _sp_zone(str, si, slen, hash) - if new_si < 0 - hash[:_fail] = true - return -1 - end - si = new_si + if fmt_sc.scan(SP_COLONS) + throw(:sp_fail) unless fmt_sc.skip(/z/) + str_sc.pos = sp_zone(str, str_sc.pos, str.bytesize, hash) next end # Handle E/O locale modifiers - fb = fi < flen ? fmt.getbyte(fi) : nil - if fb == 69 || fb == 79 # 'E' or 'O' - valid_set = fb == 69 ? STRPTIME_E_VALID_SET : STRPTIME_O_VALID_SET - fb2 = fi + 1 < flen ? fmt.getbyte(fi + 1) : nil - if fb2 && valid_set[fb2] - fi += 1 # skip E/O, fall through to handle spec + if fmt_sc.check(SP_EO_CHECK) + if fmt_sc.check(SP_E_COMBO) || fmt_sc.check(SP_O_COMBO) + fmt_sc.skip(SP_EO_CHECK) # skip modifier, fall through to spec else # Invalid combo: match '%' literally in string - if si >= slen || str.getbyte(si) != 37 # '%' - hash[:_fail] = true - return -1 - end - si += 1 + throw(:sp_fail) if str_sc.eos? || str_sc.peek(1) != '%' + str_sc.skip(/%/) next end end - spec = fi < flen ? fmt.getbyte(fi) : nil - fi += 1 + spec_ch = fmt_sc.getch + spec = spec_ch&.ord case spec when 65, 97 # 'A', 'a' - # Weekday name: 3-byte key O(1) lookup - if si + 2 >= slen - hash[:_fail] = true - return -1 - end - key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + s3 = str_sc.scan(SP_ALPHA3) + throw(:sp_fail) unless s3 + key = compute_3key(s3) entry = ABBR_DAY_3KEY[key] - unless entry - hash[:_fail] = true - return -1 - end + throw(:sp_fail) unless entry wday_i = entry[0] - day_full_len = entry[1] - if si + day_full_len <= slen && _sp_head_match?(str, si, slen, DAY_LOWER_BYTES[wday_i], day_full_len) - si += day_full_len - else - si += 3 + remaining = entry[1] - 3 + if remaining > 0 + tail = str_sc.peek(remaining) + if tail.length == remaining && tail.downcase == DAY_LOWER_STRS[wday_i][3..] + str_sc.pos += remaining + end end hash[:wday] = wday_i when 66, 98, 104 # 'B', 'b', 'h' - # Month name: 3-byte key O(1) lookup - if si + 2 >= slen - hash[:_fail] = true - return -1 - end - key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + s3 = str_sc.scan(SP_ALPHA3) + throw(:sp_fail) unless s3 + key = compute_3key(s3) entry = ABBR_MONTH_3KEY[key] - unless entry - hash[:_fail] = true - return -1 - end + throw(:sp_fail) unless entry mon_i = entry[0] - mon_full_len = entry[1] - if si + mon_full_len <= slen && _sp_head_match?(str, si, slen, MONTH_LOWER_BYTES[mon_i], mon_full_len) - si += mon_full_len - else - si += 3 + remaining = entry[1] - 3 + if remaining > 0 + tail = str_sc.peek(remaining) + if tail.length == remaining && tail.downcase == MONTH_LOWER_STRS[mon_i][3..] + str_sc.pos += remaining + end end hash[:mon] = mon_i when 67 # 'C' - # Century: greedy unless next spec is numeric - w = _sp_num_p_b?(fmt, fi, flen) ? 2 : 10000 - sb = si < slen ? str.getbyte(si) : nil - if sb == 43 || sb == 45 # '+' or '-' - sign = sb == 45 ? -1 : 1 - si += 1 + num_next = !fmt_sc.eos? && fmt_sc.check(SP_NUM_CHECK) + if str_sc.scan(SP_SIGN) + sign = str_sc.matched == '-' ? -1 : 1 else sign = 1 end - n, l = _sp_digits(str, si, slen, w) - if l == 0 - hash[:_fail] = true - return -1 - end - si += l - hash[:_cent] = sign * n + s = str_sc.scan(num_next ? SP_DIGITS_2 : SP_DIGITS_MAX) + throw(:sp_fail) unless s + hash[:_cent] = sign * s.to_i when 99 # 'c' - new_si = _sp_run(str, si, '%a %b %e %H:%M:%S %Y', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, '%a %b %e %H:%M:%S %Y', hash) when 68 # 'D' - new_si = _sp_run(str, si, '%m/%d/%y', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, '%m/%d/%y', hash) when 100, 101 # 'd', 'e' - # Day of month (leading space allowed for single-digit) - inlined - if si < slen && str.getbyte(si) == 32 # ' ' - si += 1 - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - else - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - b = si < slen ? str.getbyte(si) : nil - if b && b >= 48 && b <= 57 - n = n * 10 + (b - 48) - si += 1 - end - end - if n < 1 || n > 31 - hash[:_fail] = true - return -1 - end + s = str_sc.scan(SP_SPACE_OR_DIGIT) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n < 1 || n > 31 hash[:mday] = n when 70 # 'F' - new_si = _sp_run(str, si, '%Y-%m-%d', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, '%Y-%m-%d', hash) when 71 # 'G' - # ISO week-based year: greedy unless next spec is numeric - sb = si < slen ? str.getbyte(si) : nil - if sb == 43 || sb == 45 # '+' or '-' - sign = sb == 45 ? -1 : 1 - si += 1 + if str_sc.scan(SP_SIGN) + sign = str_sc.matched == '-' ? -1 : 1 else sign = 1 end - w = _sp_num_p_b?(fmt, fi, flen) ? 4 : 10000 - n, l = _sp_digits(str, si, slen, w) - if l == 0 - hash[:_fail] = true - return -1 - end - si += l - hash[:cwyear] = sign * n + num_next = !fmt_sc.eos? && fmt_sc.check(SP_NUM_CHECK) + s = str_sc.scan(num_next ? SP_DIGITS_4 : SP_DIGITS_MAX) + throw(:sp_fail) unless s + hash[:cwyear] = sign * s.to_i when 103 # 'g' - # 2-digit ISO week year - n, l = _sp_digits(str, si, slen, 2) - if l == 0 || n > 99 - hash[:_fail] = true - return -1 - end - si += l + s = str_sc.scan(SP_DIGITS_2) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n > 99 hash[:cwyear] = n hash[:_cent] ||= n >= 69 ? 19 : 20 when 72, 107 # 'H', 'k' - # 24-hour clock (leading space allowed) - inlined - if si < slen && str.getbyte(si) == 32 # ' ' - si += 1 - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - else - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - b = si < slen ? str.getbyte(si) : nil - if b && b >= 48 && b <= 57 - n = n * 10 + (b - 48) - si += 1 - end - end - if n > 24 - hash[:_fail] = true - return -1 - end + s = str_sc.scan(SP_SPACE_OR_DIGIT) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n > 24 hash[:hour] = n when 73, 108 # 'I', 'l' - # 12-hour clock (leading space allowed) - inlined - if si < slen && str.getbyte(si) == 32 # ' ' - si += 1 - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - else - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - b = si < slen ? str.getbyte(si) : nil - if b && b >= 48 && b <= 57 - n = n * 10 + (b - 48) - si += 1 - end - end - if n < 1 || n > 12 - hash[:_fail] = true - return -1 - end + s = str_sc.scan(SP_SPACE_OR_DIGIT) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n < 1 || n > 12 hash[:hour] = n when 106 # 'j' - # Day of year (3-digit) - n, l = _sp_digits(str, si, slen, 3) - if l == 0 || n < 1 || n > 366 - hash[:_fail] = true - return -1 - end - si += l + s = str_sc.scan(SP_DIGITS_3) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n < 1 || n > 366 hash[:yday] = n when 76 # 'L' - # Milliseconds: greedy unless next spec is numeric - sb = si < slen ? str.getbyte(si) : nil - if sb == 43 || sb == 45 # '+' or '-' - sign = sb == 45 ? -1 : 1 - si += 1 + if str_sc.scan(SP_SIGN) + sign = str_sc.matched == '-' ? -1 : 1 else sign = 1 end - osi = si - w = _sp_num_p_b?(fmt, fi, flen) ? 3 : 10000 - n, l = _sp_digits(str, si, slen, w) - if l == 0 - hash[:_fail] = true - return -1 - end - si += l + osi = str_sc.pos + num_next = !fmt_sc.eos? && fmt_sc.check(SP_NUM_CHECK) + s = str_sc.scan(num_next ? SP_DIGITS_3 : SP_DIGITS_MAX) + throw(:sp_fail) unless s + n = s.to_i n = -n if sign == -1 - hash[:sec_fraction] = Rational(n, 10**(si - osi)) + hash[:sec_fraction] = Rational(n, 10**(str_sc.pos - osi)) when 77 # 'M' - # Minute - inlined - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - b = si < slen ? str.getbyte(si) : nil - if b && b >= 48 && b <= 57 - n = n * 10 + (b - 48) - si += 1 - end - if n > 59 - hash[:_fail] = true - return -1 - end + s = str_sc.scan(SP_DIGITS_2) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n > 59 hash[:min] = n when 109 # 'm' - # Month - inlined - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - b = si < slen ? str.getbyte(si) : nil - if b && b >= 48 && b <= 57 - n = n * 10 + (b - 48) - si += 1 - end - if n < 1 || n > 12 - hash[:_fail] = true - return -1 - end + s = str_sc.scan(SP_DIGITS_2) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n < 1 || n > 12 hash[:mon] = n when 78 # 'N' - # Nanoseconds (or sub-second fraction): greedy unless next spec is numeric - sb = si < slen ? str.getbyte(si) : nil - if sb == 43 || sb == 45 # '+' or '-' - sign = sb == 45 ? -1 : 1 - si += 1 + if str_sc.scan(SP_SIGN) + sign = str_sc.matched == '-' ? -1 : 1 else sign = 1 end - osi = si - w = _sp_num_p_b?(fmt, fi, flen) ? 9 : 10000 - n, l = _sp_digits(str, si, slen, w) - if l == 0 - hash[:_fail] = true - return -1 - end - si += l + osi = str_sc.pos + num_next = !fmt_sc.eos? && fmt_sc.check(SP_NUM_CHECK) + s = str_sc.scan(num_next ? SP_DIGITS_9 : SP_DIGITS_MAX) + throw(:sp_fail) unless s + n = s.to_i n = -n if sign == -1 - hash[:sec_fraction] = Rational(n, 10**(si - osi)) + hash[:sec_fraction] = Rational(n, 10**(str_sc.pos - osi)) when 110, 116 # 'n', 't' - # Match any whitespace - new_si = _sp_run(str, si, ' ', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, ' ', hash) when 80, 112 # 'P', 'p' - # AM/PM with optional dot notation (A.M./P.M.) - if si >= slen - hash[:_fail] = true - return -1 - end - c0 = str.getbyte(si) - if c0 == 80 || c0 == 112 # 'P' or 'p' + throw(:sp_fail) if str_sc.eos? + c0 = str_sc.peek(1) + if c0 == 'P' || c0 == 'p' merid = 12 - elsif c0 == 65 || c0 == 97 # 'A' or 'a' + elsif c0 == 'A' || c0 == 'a' merid = 0 else - hash[:_fail] = true - return -1 + throw(:sp_fail) end - if si + 1 < slen && str.getbyte(si + 1) == 46 # '.' - # Dot notation: X.M. - if si + 3 >= slen || str.getbyte(si + 3) != 46 # '.' - hash[:_fail] = true - return -1 - end - c_m = str.getbyte(si + 2) - unless c_m == 77 || c_m == 109 # 'M' or 'm' - hash[:_fail] = true - return -1 - end - si += 4 - else - if si + 1 >= slen - hash[:_fail] = true - return -1 - end - c_m = str.getbyte(si + 1) - unless c_m == 77 || c_m == 109 # 'M' or 'm' - hash[:_fail] = true - return -1 - end - si += 2 + unless str_sc.scan(SP_AMPM_DOT) || str_sc.scan(SP_AMPM) + throw(:sp_fail) end hash[:_merid] = merid when 81 # 'Q' - # Milliseconds since Unix epoch sign = 1 - if si < slen && str.getbyte(si) == 45 # '-' + if str_sc.skip(/-/) sign = -1 - si += 1 end - n, l = _sp_digits(str, si, slen, 10000) - if l == 0 - hash[:_fail] = true - return -1 - end - si += l + s = str_sc.scan(SP_DIGITS_MAX) + throw(:sp_fail) unless s + n = s.to_i n = -n if sign == -1 hash[:seconds] = Rational(n, 1000) when 82 # 'R' - new_si = _sp_run(str, si, '%H:%M', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, '%H:%M', hash) when 114 # 'r' - new_si = _sp_run(str, si, '%I:%M:%S %p', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, '%I:%M:%S %p', hash) when 83 # 'S' - # Second (0-60 to allow leap second) - inlined - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - b = si < slen ? str.getbyte(si) : nil - if b && b >= 48 && b <= 57 - n = n * 10 + (b - 48) - si += 1 - end - if n > 60 - hash[:_fail] = true - return -1 - end + s = str_sc.scan(SP_DIGITS_2) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n > 60 hash[:sec] = n when 115 # 's' - # Seconds since Unix epoch sign = 1 - if si < slen && str.getbyte(si) == 45 # '-' + if str_sc.skip(/-/) sign = -1 - si += 1 end - n, l = _sp_digits(str, si, slen, 10000) - if l == 0 - hash[:_fail] = true - return -1 - end - si += l + s = str_sc.scan(SP_DIGITS_MAX) + throw(:sp_fail) unless s + n = s.to_i n = -n if sign == -1 hash[:seconds] = n when 84 # 'T' - new_si = _sp_run(str, si, '%H:%M:%S', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, '%H:%M:%S', hash) when 85 # 'U' - # Week number (Sunday-based) - n, l = _sp_digits(str, si, slen, 2) - if l == 0 || n > 53 - hash[:_fail] = true - return -1 - end - si += l + s = str_sc.scan(SP_DIGITS_2) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n > 53 hash[:wnum0] = n when 117 # 'u' - # ISO weekday (1=Mon..7=Sun) - n, l = _sp_digits(str, si, slen, 1) - if l == 0 || n < 1 || n > 7 - hash[:_fail] = true - return -1 - end - si += l + s = str_sc.scan(SP_DIGITS_1) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n < 1 || n > 7 hash[:cwday] = n when 86 # 'V' - # ISO week number - n, l = _sp_digits(str, si, slen, 2) - if l == 0 || n < 1 || n > 53 - hash[:_fail] = true - return -1 - end - si += l + s = str_sc.scan(SP_DIGITS_2) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n < 1 || n > 53 hash[:cweek] = n when 118 # 'v' - new_si = _sp_run(str, si, '%e-%b-%Y', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, '%e-%b-%Y', hash) when 87 # 'W' - # Week number (Monday-based) - n, l = _sp_digits(str, si, slen, 2) - if l == 0 || n > 53 - hash[:_fail] = true - return -1 - end - si += l + s = str_sc.scan(SP_DIGITS_2) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n > 53 hash[:wnum1] = n when 119 # 'w' - # Weekday (0=Sun..6=Sat) - n, l = _sp_digits(str, si, slen, 1) - if l == 0 || n > 6 - hash[:_fail] = true - return -1 - end - si += l + s = str_sc.scan(SP_DIGITS_1) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n > 6 hash[:wday] = n when 88 # 'X' - new_si = _sp_run(str, si, '%H:%M:%S', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, '%H:%M:%S', hash) when 120 # 'x' - new_si = _sp_run(str, si, '%m/%d/%y', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, '%m/%d/%y', hash) when 89 # 'Y' - # Full year: greedy unless next spec is numeric - inlined - sb = si < slen ? str.getbyte(si) : nil - if sb == 43 || sb == 45 # '+' or '-' - sign = sb == 45 ? -1 : 1 - si += 1 + if str_sc.scan(SP_SIGN) + sign = str_sc.matched == '-' ? -1 : 1 else sign = 1 end - w = _sp_num_p_b?(fmt, fi, flen) ? 4 : 10000 - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - l = 1 - while l < w && si < slen - b = str.getbyte(si) - break unless b && b >= 48 && b <= 57 - n = n * 10 + (b - 48) - si += 1 - l += 1 - end - hash[:year] = sign * n + num_next = !fmt_sc.eos? && fmt_sc.check(SP_NUM_CHECK) + s = str_sc.scan(num_next ? SP_DIGITS_4 : SP_DIGITS_MAX) + throw(:sp_fail) unless s + hash[:year] = sign * s.to_i when 121 # 'y' - # 2-digit year - inlined - b = si < slen ? str.getbyte(si) : nil - unless b && b >= 48 && b <= 57 - hash[:_fail] = true - return -1 - end - n = b - 48 - si += 1 - b = si < slen ? str.getbyte(si) : nil - if b && b >= 48 && b <= 57 - n = n * 10 + (b - 48) - si += 1 - end - if n > 99 - hash[:_fail] = true - return -1 - end + s = str_sc.scan(SP_DIGITS_2) + throw(:sp_fail) unless s + n = s.to_i + throw(:sp_fail) if n > 99 hash[:year] = n hash[:_cent] ||= n >= 69 ? 19 : 20 when 90, 122 # 'Z', 'z' - new_si = _sp_zone(str, si, slen, hash) - if new_si < 0 - hash[:_fail] = true - return -1 - end - si = new_si + str_sc.pos = sp_zone(str, str_sc.pos, str.bytesize, hash) when 37 # '%' - if si >= slen || str.getbyte(si) != 37 - hash[:_fail] = true - return -1 - end - si += 1 + throw(:sp_fail) if str_sc.eos? || str_sc.peek(1) != '%' + str_sc.skip(/%/) when 43 # '+' - new_si = _sp_run(str, si, '%a %b %e %H:%M:%S %Z %Y', hash) - return new_si if new_si < 0 - si = new_si + str_sc.pos = sp_run(str, str_sc.pos, '%a %b %e %H:%M:%S %Z %Y', hash) else # Unknown spec: match '%' then spec literally - if si >= slen || str.getbyte(si) != 37 # '%' - hash[:_fail] = true - return -1 - end - si += 1 - if spec - if si >= slen || str.getbyte(si) != spec - hash[:_fail] = true - return -1 - end - si += 1 + throw(:sp_fail) if str_sc.eos? || str_sc.peek(1) != '%' + str_sc.skip(/%/) + if spec_ch + throw(:sp_fail) if str_sc.eos? || str_sc.peek(1) != spec_ch + str_sc.getch end end end - si - end - - # Case-insensitive byte-level head match. - # Compares str[si..si+len-1] against pre-computed lowercase byte array. - # Uses | 0x20 for ASCII alpha downcase (works for A-Z only). - def _sp_head_match?(str, si, slen, lower_bytes, len) - return false if si + len > slen - i = 0 - while i < len - return false if (str.getbyte(si + i) | 0x20) != lower_bytes[i] - i += 1 - end - true + str_sc.pos end # Fast path for %Y-%m-%d / %F format. - # For common "YYYY-MM-DD" format, uses byteslice+to_i (fewer method calls). - # Falls back to getbyte loop for non-standard lengths or signed years. - def _strptime_ymd(str) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + # Uses match? + byteslice to avoid StringScanner allocation overhead. + STRPTIME_YMD_EXACT = /\A\d{4}-\d{2}-\d{2}\z/ + STRPTIME_YMD_PREFIX = /\A\d{4}-\d{2}-\d{2}/ + STRPTIME_YMD_GENERAL = /\A([+-]?\d+)-(\d{1,2})-(\d{1,2})(.*)\z/m + private_constant :STRPTIME_YMD_EXACT, :STRPTIME_YMD_PREFIX, :STRPTIME_YMD_GENERAL + + def internal_strptime_ymd(str) slen = str.bytesize - # Fast path for "YYYY-MM-DD" (exactly 10 chars) or "YYYY-MM-DD..." - if slen >= 10 && str.getbyte(4) == 45 && str.getbyte(7) == 45 - b0 = str.getbyte(0) - if b0 >= 48 && b0 <= 57 # first char is digit (positive 4-digit year) - year = str.byteslice(0, 4).to_i - mon = str.byteslice(5, 2).to_i - mday = str.byteslice(8, 2).to_i - return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 + # Fast path for "YYYY-MM-DD" (exactly 10 chars) + if slen == 10 && STRPTIME_YMD_EXACT.match?(str) + year = str.byteslice(0, 4).to_i + mon = str.byteslice(5, 2).to_i + mday = str.byteslice(8, 2).to_i + return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 + return { year: year, mon: mon, mday: mday } + end + + # Medium path for "YYYY-MM-DD..." (10+ chars, standard 4-digit year with leftover) + if slen > 10 && STRPTIME_YMD_PREFIX.match?(str) + year = str.byteslice(0, 4).to_i + mon = str.byteslice(5, 2).to_i + mday = str.byteslice(8, 2).to_i + if mon >= 1 && mon <= 12 && mday >= 1 && mday <= 31 hash = { year: year, mon: mon, mday: mday } - hash[:leftover] = str.byteslice(10, slen - 10) if slen > 10 + hash[:leftover] = str.byteslice(10..) return hash end end # General path for signed years, short years, etc. - si = 0 - sign = 1 - b = str.getbyte(si) - if b == 43 # '+' - si += 1 - b = str.getbyte(si) - elsif b == 45 # '-' - sign = -1 - si += 1 - b = str.getbyte(si) - end - return nil unless b && b >= 48 && b <= 57 - year = b - 48 - si += 1 - while si < slen - b = str.getbyte(si) - break unless b && b >= 48 && b <= 57 - year = year * 10 + (b - 48) - si += 1 - end - year = -year if sign == -1 - - return nil unless si < slen && str.getbyte(si) == 45 - si += 1 - b = str.getbyte(si) - return nil unless b && b >= 48 && b <= 57 - mon = b - 48 - si += 1 - b = str.getbyte(si) - if b && b >= 48 && b <= 57 - mon = mon * 10 + (b - 48) - si += 1 - end - return nil if mon < 1 || mon > 12 - - return nil unless si < slen && str.getbyte(si) == 45 - si += 1 - b = str.getbyte(si) - return nil unless b && b >= 48 && b <= 57 - mday = b - 48 - si += 1 - b = str.getbyte(si) - if b && b >= 48 && b <= 57 - mday = mday * 10 + (b - 48) - si += 1 - end - return nil if mday < 1 || mday > 31 - + m = STRPTIME_YMD_GENERAL.match(str) + return nil unless m + year = m[1].to_i + mon = m[2].to_i + mday = m[3].to_i + return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 hash = { year: year, mon: mon, mday: mday } - hash[:leftover] = str.byteslice(si, slen - si) if si < slen + rest = m[4] + hash[:leftover] = rest unless rest.empty? hash end - # Ultra-fast path: parse %Y-%m-%d and directly create Date object. - # Skips Hash creation, _sp_complete_frags, and _sp_valid_date_frags_p entirely. + # Parse %Y-%m-%d and directly create Date object. # Returns Date object on success, nil on failure. - def _strptime_ymd_to_date(str, sg) # rubocop:disable Metrics/MethodLength + # Uses match? + byteslice to avoid StringScanner allocation overhead. + STRPTIME_YMD_GENERAL_EXACT = /\A([+-]?\d+)-(\d{1,2})-(\d{1,2})\z/ + private_constant :STRPTIME_YMD_GENERAL_EXACT + + def internalinternal_strptime_ymd_to_date(str, sg) slen = str.bytesize - # Ultra-fast path for exactly "YYYY-MM-DD" (10 chars, positive 4-digit year) - if slen == 10 && str.getbyte(4) == 45 && str.getbyte(7) == 45 - b0 = str.getbyte(0) - if b0 >= 48 && b0 <= 57 - year = str.byteslice(0, 4).to_i - mon = str.byteslice(5, 2).to_i - mday = str.byteslice(8, 2).to_i - if mon >= 1 && mon <= 12 && mday >= 1 && mday <= 31 - # Inline civil validation + JD - if sg != Float::INFINITY - dim = DAYS_IN_MONTH_GREGORIAN[mon] - if mon == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) - dim = 29 - end - return nil if mday > dim - gy = mon <= 2 ? year - 1 : year - gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[mon] + mday - a = gy / 100 - gjd = gjd_base - 1524 + 2 - a + a / 4 - jd = gjd >= sg ? gjd : gjd_base - 1524 - return new_from_jd(jd, sg) - else - jd = internal_valid_civil?(year, mon, mday, sg) - return jd ? new_from_jd(jd, sg) : nil + # Fast path for exactly "YYYY-MM-DD" (10 chars, positive 4-digit year) + if slen == 10 && STRPTIME_YMD_EXACT.match?(str) + year = str.byteslice(0, 4).to_i + mon = str.byteslice(5, 2).to_i + mday = str.byteslice(8, 2).to_i + if mon >= 1 && mon <= 12 && mday >= 1 && mday <= 31 + # Inline civil validation + JD + if sg != Float::INFINITY + dim = DAYS_IN_MONTH_GREGORIAN[mon] + if mon == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) + dim = 29 end + return nil if mday > dim + gy = mon <= 2 ? year - 1 : year + gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[mon] + mday + a = gy / 100 + gjd = gjd_base - 1524 + 2 - a + a / 4 + jd = gjd >= sg ? gjd : gjd_base - 1524 + return new_from_jd(jd, sg) + else + jd = internal_valid_civil?(year, mon, mday, sg) + return jd ? new_from_jd(jd, sg) : nil end - return nil end + return nil end # General path for signed years, non-standard lengths - si = 0 - sign = 1 - b = str.getbyte(si) - if b == 43 # '+' - si += 1 - b = str.getbyte(si) - elsif b == 45 # '-' - sign = -1 - si += 1 - b = str.getbyte(si) - end - return nil unless b && b >= 48 && b <= 57 - year = b - 48 - si += 1 - while si < slen - b = str.getbyte(si) - break unless b && b >= 48 && b <= 57 - year = year * 10 + (b - 48) - si += 1 - end - year = -year if sign == -1 - return nil unless si < slen && str.getbyte(si) == 45 - si += 1 - b = str.getbyte(si) - return nil unless b && b >= 48 && b <= 57 - mon = b - 48 - si += 1 - b = str.getbyte(si) - if b && b >= 48 && b <= 57 - mon = mon * 10 + (b - 48) - si += 1 - end - return nil if mon < 1 || mon > 12 - return nil unless si < slen && str.getbyte(si) == 45 - si += 1 - b = str.getbyte(si) - return nil unless b && b >= 48 && b <= 57 - mday = b - 48 - si += 1 - b = str.getbyte(si) - if b && b >= 48 && b <= 57 - mday = mday * 10 + (b - 48) - si += 1 - end - return nil if mday < 1 || mday > 31 - return nil if si < slen + m = STRPTIME_YMD_GENERAL_EXACT.match(str) + return nil unless m + year = m[1].to_i + mon = m[2].to_i + mday = m[3].to_i + return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 # Inline civil validation + JD computation - # For common Gregorian dates with valid day-of-month, compute JD directly - if sg != Float::INFINITY # Gregorian path (most common) + if sg != Float::INFINITY dim = DAYS_IN_MONTH_GREGORIAN[mon] if mon == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) dim = 29 end return nil if mday > dim - # Inline civil_to_jd for Gregorian gy = mon <= 2 ? year - 1 : year offset = GJD_MONTH_OFFSET[mon] gjd_base = (1461 * (gy + 4716)) / 4 + offset + mday @@ -961,176 +553,74 @@ def _strptime_ymd_to_date(str, sg) # rubocop:disable Metrics/MethodLength new_from_jd(jd, sg) end - # Fast path for "%a %b %d %Y" format (complex benchmark). - # Byte-level name matching + digit parsing. Zero String allocation. - def _strptime_abdy(str) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity - slen = str.bytesize - si = 0 + # Fast path for "%a %b %d %Y" format. + # Uses single regex match to avoid StringScanner allocation. + STRPTIME_ABDY_PAT = /\A([A-Za-z]{3})([A-Za-z]*) +([A-Za-z]{3})([A-Za-z]*) +(\d{1,2}) +([+-]?\d+)/ + private_constant :STRPTIME_ABDY_PAT - # Match weekday name using 3-byte key lookup - return nil if si + 2 >= slen - key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + def internal_strptime_abdy(str) + m = STRPTIME_ABDY_PAT.match(str) + return nil unless m + + # Validate weekday via 3-byte key lookup + key = compute_3key(m[1]) entry = ABBR_DAY_3KEY[key] return nil unless entry wday = entry[0] - full_len = entry[1] - if si + full_len <= slen && _sp_head_match?(str, si, slen, DAY_LOWER_BYTES[wday], full_len) - si += full_len - else - si += 3 + day_rest = m[2] + unless day_rest.empty? + return nil unless day_rest.length == entry[1] - 3 && day_rest.downcase == DAY_LOWER_STRS[wday][3..] end - # Expect space(s) - return nil if si >= slen || str.getbyte(si) != 32 - si += 1 - si += 1 while si < slen && str.getbyte(si) == 32 - - # Match month name using 3-byte key lookup - return nil if si + 2 >= slen - key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + # Validate month via 3-byte key lookup + key = compute_3key(m[3]) entry = ABBR_MONTH_3KEY[key] return nil unless entry mon = entry[0] - full_len = entry[1] - if si + full_len <= slen && _sp_head_match?(str, si, slen, MONTH_LOWER_BYTES[mon], full_len) - si += full_len - else - si += 3 + mon_rest = m[4] + unless mon_rest.empty? + return nil unless mon_rest.length == entry[1] - 3 && mon_rest.downcase == MONTH_LOWER_STRS[mon][3..] end - # Expect space(s) - return nil if si >= slen || str.getbyte(si) != 32 - si += 1 - si += 1 while si < slen && str.getbyte(si) == 32 - - # Parse day (1-2 digits) - b = str.getbyte(si) - return nil unless b && b >= 48 && b <= 57 - mday = b - 48 - si += 1 - b = str.getbyte(si) - if b && b >= 48 && b <= 57 - mday = mday * 10 + (b - 48) - si += 1 - end + mday = m[5].to_i return nil if mday < 1 || mday > 31 - - # Expect space(s) - return nil if si >= slen || str.getbyte(si) != 32 - si += 1 - si += 1 while si < slen && str.getbyte(si) == 32 - - # Parse year: optional sign + greedy digits - sign = 1 - b = str.getbyte(si) - if b == 43 # '+' - si += 1 - b = str.getbyte(si) - elsif b == 45 # '-' - sign = -1 - si += 1 - b = str.getbyte(si) - end - - return nil unless b && b >= 48 && b <= 57 - year = b - 48 - si += 1 - while si < slen - b = str.getbyte(si) - break unless b && b >= 48 && b <= 57 - year = year * 10 + (b - 48) - si += 1 - end - year = -year if sign == -1 + year = m[6].to_i hash = { year: year, mon: mon, mday: mday, wday: wday } - hash[:leftover] = str.byteslice(si, slen - si) if si < slen + post = m.post_match + hash[:leftover] = post unless post.empty? hash end - # Ultra-fast path: parse "%a %b %d %Y" and directly create Date object. - # Combines parsing + civil validation + JD computation without Hash. - def _strptime_abdy_to_date(str, sg) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity - slen = str.bytesize - si = 0 + # Parse "%a %b %d %Y" and directly create Date object. + # Uses single regex match to avoid StringScanner allocation. + def internalinternal_strptime_abdy_to_date(str, sg) + m = STRPTIME_ABDY_PAT.match(str) + return nil unless m + return nil unless m.post_match.empty? - # Match weekday name using 3-byte key lookup - return nil if si + 2 >= slen - key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + # Validate weekday via 3-byte key lookup + key = compute_3key(m[1]) entry = ABBR_DAY_3KEY[key] return nil unless entry - full_len = entry[1] - # Try full name first, then abbreviation - if si + full_len <= slen && _sp_head_match?(str, si, slen, DAY_LOWER_BYTES[entry[0]], full_len) - si += full_len - else - si += 3 + day_rest = m[2] + unless day_rest.empty? + return nil unless day_rest.length == entry[1] - 3 && day_rest.downcase == DAY_LOWER_STRS[entry[0]][3..] end - # Expect space(s) - return nil if si >= slen || str.getbyte(si) != 32 - si += 1 - si += 1 while si < slen && str.getbyte(si) == 32 - - # Match month name using 3-byte key lookup - return nil if si + 2 >= slen - key = ((str.getbyte(si) | 0x20) << 16) | ((str.getbyte(si + 1) | 0x20) << 8) | (str.getbyte(si + 2) | 0x20) + # Validate month via 3-byte key lookup + key = compute_3key(m[3]) entry = ABBR_MONTH_3KEY[key] return nil unless entry mon = entry[0] - full_len = entry[1] - if si + full_len <= slen && _sp_head_match?(str, si, slen, MONTH_LOWER_BYTES[mon], full_len) - si += full_len - else - si += 3 + mon_rest = m[4] + unless mon_rest.empty? + return nil unless mon_rest.length == entry[1] - 3 && mon_rest.downcase == MONTH_LOWER_STRS[mon][3..] end - # Expect space(s) - return nil if si >= slen || str.getbyte(si) != 32 - si += 1 - si += 1 while si < slen && str.getbyte(si) == 32 - - # Parse day (1-2 digits) - b = str.getbyte(si) - return nil unless b && b >= 48 && b <= 57 - mday = b - 48 - si += 1 - b = str.getbyte(si) - if b && b >= 48 && b <= 57 - mday = mday * 10 + (b - 48) - si += 1 - end + mday = m[5].to_i return nil if mday < 1 || mday > 31 - - # Expect space(s) - return nil if si >= slen || str.getbyte(si) != 32 - si += 1 - si += 1 while si < slen && str.getbyte(si) == 32 - - # Parse year: optional sign + greedy digits - sign = 1 - b = str.getbyte(si) - if b == 43 # '+' - si += 1 - b = str.getbyte(si) - elsif b == 45 # '-' - sign = -1 - si += 1 - b = str.getbyte(si) - end - return nil unless b && b >= 48 && b <= 57 - year = b - 48 - si += 1 - while si < slen - b = str.getbyte(si) - break unless b && b >= 48 && b <= 57 - year = year * 10 + (b - 48) - si += 1 - end - year = -year if sign == -1 - - # Must consume entire string - return nil if si < slen + year = m[6].to_i # Inline civil validation + JD computation if sg != Float::INFINITY @@ -1153,46 +643,33 @@ def _strptime_abdy_to_date(str, sg) # rubocop:disable Metrics/MethodLength,Metri end # Parse zone from string at position si; update hash[:zone] and hash[:offset]. - # Returns new si on success, -1 on failure. - def _sp_zone(str, si, slen, hash) + # Returns new si on success; throws :sp_fail on failure. + def sp_zone(str, si, slen, hash) m = STRPTIME_ZONE_PAT.match(str[si..]) - return -1 unless m + throw(:sp_fail) unless m zone_str = m[1] hash[:zone] = zone_str - hash[:offset] = _sp_zone_to_diff(zone_str) + hash[:offset] = sp_zone_to_diff(zone_str) si + m[0].length end # Convert a zone string to seconds offset from UTC. # Returns Integer (seconds) or Rational, or nil if unparseable. # Mirrors date_zone_to_diff() in ext/date/date_parse.c. - def _sp_zone_to_diff(zone_str) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + def sp_zone_to_diff(zone_str) # Fast path for common numeric zones len = zone_str.length - b0 = zone_str.getbyte(0) - if b0 == 43 || b0 == 45 # '+' or '-' - sign = b0 == 45 ? -1 : 1 - if len == 6 && zone_str.getbyte(3) == 58 # +HH:MM - b1 = zone_str.getbyte(1) - b2 = zone_str.getbyte(2) - b4 = zone_str.getbyte(4) - b5 = zone_str.getbyte(5) - if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b4 >= 48 && b4 <= 57 && b5 >= 48 && b5 <= 57 - h = (b1 - 48) * 10 + (b2 - 48) - m = (b4 - 48) * 10 + (b5 - 48) - return nil if h > 23 || m > 59 - return sign * (h * 3600 + m * 60) - end - elsif len == 5 # +HHMM - b1 = zone_str.getbyte(1) - b2 = zone_str.getbyte(2) - b3 = zone_str.getbyte(3) - b4 = zone_str.getbyte(4) - if b1 >= 48 && b1 <= 57 && b2 >= 48 && b2 <= 57 && b3 >= 48 && b3 <= 57 && b4 >= 48 && b4 <= 57 - return sign * ((b1 - 48) * 36000 + (b2 - 48) * 3600 + (b3 - 48) * 600 + (b4 - 48) * 60) - end + c0 = zone_str[0] + if c0 == '+' || c0 == '-' + sc = StringScanner.new(zone_str) + if sc.scan(/([+-])(\d{2}):?(\d{2})\z/) + sign = sc[1] == '-' ? -1 : 1 + h = sc[2].to_i + m = sc[3].to_i + return nil if h > 23 || m > 59 + return sign * (h * 3600 + m * 60) end - elsif len == 1 && (b0 == 90 || b0 == 122) # Z/z + elsif len == 1 && (c0 == 'Z' || c0 == 'z') return 0 elsif len <= 3 off = ZONE_TABLE[zone_str.downcase] @@ -1283,7 +760,7 @@ def _sp_zone_to_diff(zone_str) # rubocop:disable Metrics/MethodLength,Metrics/Cy # Rewrite :seconds (from %s/%Q) into jd + time components. # Offset is applied first (converts UTC epoch to local time). - def _sp_rewrite_frags(hash) + def sp_rewrite_frags(hash) seconds = hash.delete(:seconds) return hash unless seconds @@ -1305,7 +782,7 @@ def _sp_rewrite_frags(hash) # Complete partial date fragments by filling defaults from today's date. # Mirrors rt_complete_frags() in C. - def _sp_complete_frags(klass, hash) # rubocop:disable Metrics/MethodLength,Metrics/CyclomaticComplexity + def sp_complete_frags(klass, hash) # Fast path: detect :civil case (most common) without iterating all entries k = nil a = nil @@ -1423,7 +900,7 @@ def _sp_complete_frags(klass, hash) # rubocop:disable Metrics/MethodLength,Metri # Mirrors c_weeknum_to_jd() in ext/date/date_core.c: # rjd2 = JD(Jan 1) + 6 (= JD of Jan 7) # return (rjd2 - MOD((rjd2 - f + 1), 7) - 7) + 7*w + d - def _sp_weeknum_to_jd(y, w, d, f, sg) + def sp_weeknum_to_jd(y, w, d, f, sg) jd_jan7 = civil_to_jd(y, 1, 1, sg) + 6 (jd_jan7 - (jd_jan7 - f + 1) % 7 - 7) + 7 * w + d end @@ -1431,7 +908,7 @@ def _sp_weeknum_to_jd(y, w, d, f, sg) # Find the Julian Day number from the fragment hash. # Tries jd, ordinal, civil, commercial, wnum0, wnum1 in order. # Returns jd integer or nil. - def _sp_valid_date_frags_p(hash, sg) # rubocop:disable Metrics/CyclomaticComplexity + def sp_valid_date_frags_p(hash, sg) return hash[:jd] if hash[:jd] if (yday = hash[:yday]) && (year = hash[:year]) @@ -1462,7 +939,7 @@ def _sp_valid_date_frags_p(hash, sg) # rubocop:disable Metrics/CyclomaticComplex wday = 0 if !wday.nil? && wday == 7 end if wday && (week = hash[:wnum0]) && (year = hash[:year]) - jd = _sp_weeknum_to_jd(year, week, wday, 0, sg) + jd = sp_weeknum_to_jd(year, week, wday, 0, sg) return jd if jd end @@ -1472,7 +949,7 @@ def _sp_valid_date_frags_p(hash, sg) # rubocop:disable Metrics/CyclomaticComplex wday = hash[:cwday] if wday.nil? wday = (wday - 1) % 7 if wday if wday && (week = hash[:wnum1]) && (year = hash[:year]) - jd = _sp_weeknum_to_jd(year, week, wday, 1, sg) + jd = sp_weeknum_to_jd(year, week, wday, 1, sg) return jd if jd end @@ -1480,11 +957,11 @@ def _sp_valid_date_frags_p(hash, sg) # rubocop:disable Metrics/CyclomaticComplex end # Create a Date object from parsed fragment hash. - def _new_by_frags(hash, sg) + def internal_new_by_frags(hash, sg) raise Error, 'invalid date' if hash.nil? - hash = _sp_rewrite_frags(hash) - hash = _sp_complete_frags(Date, hash) - jd = _sp_valid_date_frags_p(hash, sg) + hash = sp_rewrite_frags(hash) + hash = sp_complete_frags(Date, hash) + jd = sp_valid_date_frags_p(hash, sg) raise Error, 'invalid date' if jd.nil? new_from_jd(jd, sg) end From 7e80db944823a45eeeb50df86bfbd18a1b9e1446 Mon Sep 17 00:00:00 2001 From: jinroq Date: Wed, 4 Mar 2026 13:32:10 +0900 Subject: [PATCH 10/11] Remove inlined civil_to_jd and other duplicated method bodies Replace 12 inlined copies of civil_to_jd computation and other duplicated method bodies (jd_to_gregorian, jd_to_commercial, days_in_month, new_from_jd) with calls to their canonical implementations. This addresses reviewer feedback that mechanical inlining made the codebase harder to maintain for humans. Changes: - Date.civil: replace inline JD calc with civil_to_jd + new_from_jd - Date.ordinal: replace inline JD calc with civil_to_jd - Date.commercial: replace inline with commercial_to_jd - Date#initialize: replace 3-way branch with civil_to_jd call - Date#yday: replace inline with civil_to_jd call - Date#>>: replace inline days_in_month/civil_to_jd/new_from_jd - Date#to_time: replace inline with jd_to_gregorian call - Date#compute_commercial: replace 47-line inline with jd_to_commercial - strptime fast paths: replace inline validation+JD with internal_valid_civil? - parse fast_new_date: replace inline Gregorian JD with internal_valid_civil? Performance (i/s, Ruby+YJIT vs C ext+YJIT): | Benchmark | C ext+YJIT | Ruby+YJIT | Ratio | |--------------------|------------|-----------|-------| | Date.new | 4,955,739 | 6,352,127 | 128% | | Date.civil | 5,129,273 | 6,013,617 | 117% | | Date.ordinal | 2,892,626 | 6,287,815 | 217% | | Date.commercial | 2,310,636 | 5,058,093 | 219% | | Date#yday | 18,071,960 |26,284,340 | 145% | | Date#cwyear | 4,386,845 |26,574,335 | 606% | | Date#cweek | 4,476,971 |26,579,913 | 594% | | Date#>>1 | 2,744,048 | 1,760,031 | 64% | | Date#next_month | 2,712,763 | 1,805,978 | 67% | | Date#to_time | 502,991 | 472,747 | 94% | | Date.strptime | 1,266,767 | 1,209,958 | 96% | Date#>> and methods using it (next_month, prev_month, next_year, prev_year) regressed ~50% due to self.class.__send__ overhead for calling private class methods from instance methods. This is an acceptable trade-off for maintainability. --- lib/date/core.rb | 140 +++++-------------------------------------- lib/date/parse.rb | 14 +---- lib/date/strptime.rb | 57 ++---------------- 3 files changed, 24 insertions(+), 187 deletions(-) diff --git a/lib/date/core.rb b/lib/date/core.rb index 886a7c02..325aa20f 100644 --- a/lib/date/core.rb +++ b/lib/date/core.rb @@ -14,14 +14,7 @@ class << self def civil(year = -4712, month = 1, day = 1, start = DEFAULT_SG) if Integer === year && Integer === month && Integer === day && month >= 1 && month <= 12 if day >= 1 && day <= 28 - gy = month > 2 ? year : year - 1 - gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[month] + day - a = gy / 100 - jd_julian = gjd_base - 1524 - gjd = jd_julian + 2 - a + a / 4 - obj = allocate - obj.__send__(:init_from_jd, gjd >= start ? gjd : jd_julian, start) - return obj + return new_from_jd(civil_to_jd(year, month, day, start), start) elsif day >= -31 dim = if month == 2 if start == Float::INFINITY @@ -34,14 +27,7 @@ def civil(year = -4712, month = 1, day = 1, start = DEFAULT_SG) end d = day < 0 ? day + dim + 1 : day if d >= 1 && d <= dim - gy = month > 2 ? year : year - 1 - gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[month] + d - a = gy / 100 - jd_julian = gjd_base - 1524 - gjd = jd_julian + 2 - a + a / 4 - obj = allocate - obj.__send__(:init_from_jd, gjd >= start ? gjd : jd_julian, start) - return obj + return new_from_jd(civil_to_jd(year, month, d, start), start) end end end @@ -178,14 +164,8 @@ def julian_leap?(year) # Related: Date.jd, Date.new. def ordinal(year = -4712, yday = 1, start = DEFAULT_SG) if Integer === year && Integer === yday && yday >= 1 && yday <= 365 - gy = year - 1 - gjd_base = (1461 * (gy + 4716)) / 4 + 429 # GJD_MONTH_OFFSET[1] + 1 - a = gy / 100 - gjd = gjd_base - 1524 + 2 - a + a / 4 - jd1 = gjd >= start ? gjd : gjd_base - 1524 - obj = allocate - obj.__send__(:init_from_jd, jd1 + yday - 1, start) - return obj + jd1 = civil_to_jd(year, 1, 1, start) + return new_from_jd(jd1 + yday - 1, start) end year = Integer(year) yday = Integer(yday) @@ -257,18 +237,8 @@ def commercial(cwyear = -4712, cweek = 1, cwday = 1, start = DEFAULT_SG) if Integer === cwyear && Integer === cweek && Integer === cwday && cweek >= 1 && cweek <= 52 && cwday >= 1 && cwday <= 7 # ISO 8601: every year has at least 52 weeks, so weeks 1-52 are always valid. - # Inline civil_to_jd(cwyear, 1, 4, start): month=1, day=4 - gy = cwyear - 1 - gjd_base4 = (1461 * (gy + 4716)) / 4 + 432 # GJD_MONTH_OFFSET[1] + 4 - a = gy / 100 - gjd4 = gjd_base4 - 1524 + 2 - a + a / 4 - jd_jan4 = gjd4 >= start ? gjd4 : gjd_base4 - 1524 - wday_jan4 = (jd_jan4 + 1) % 7 - mon_wk1 = jd_jan4 - (wday_jan4 == 0 ? 6 : wday_jan4 - 1) - jd = mon_wk1 + (cweek - 1) * 7 + (cwday - 1) - obj = allocate - obj.__send__(:init_from_jd, jd, start) - return obj + jd = commercial_to_jd(cwyear, cweek, cwday, start) + return new_from_jd(jd, start) end cwyear = Integer(cwyear) cweek = Integer(cweek) @@ -683,18 +653,7 @@ def initialize(year = -4712, month = 1, day = 1, start = DEFAULT_SG) d = day d += dim + 1 if d < 0 if d >= 1 && d <= dim - gy = m <= 2 ? year - 1 : year - gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[m] + d - if start == Float::INFINITY - @jd = gjd_base - 1524 - elsif start == -Float::INFINITY - a = gy / 100 - @jd = gjd_base - 1524 + 2 - a + a / 4 - else - a = gy / 100 - gjd = gjd_base - 1524 + 2 - a + a / 4 - @jd = gjd >= start ? gjd : gjd_base - 1524 - end + @jd = self.class.__send__(:civil_to_jd, year, m, d, start) @sg = start @year = year @month = m @@ -852,12 +811,7 @@ def ld def yday return @yday if @yday internal_civil unless @year - # inline civil_to_jd(@year, 1, 1, @sg): month=1 (<= 2 so y-=1), day=1 - yy = @year - 1 - gjd_base = (1461 * (yy + 4716)) / 4 + 429 # GJD_MONTH_OFFSET[1](=428) + 1 - a = yy / 100 - gjd = gjd_base - 1524 + 2 - a + a / 4 - jd_jan1 = gjd >= @sg ? gjd : gjd_base - 1524 + jd_jan1 = self.class.__send__(:civil_to_jd, @year, 1, 1, @sg) val = @jd - jd_jan1 + 1 @yday = val unless frozen? val @@ -1335,29 +1289,14 @@ def >>(n) m2 = @month + n.to_i y2 = @year + (m2 - 1).div(12) m2 = (m2 - 1) % 12 + 1 - # inline days_in_month - if m2 == 2 - if @sg == Float::INFINITY - dim = y2 % 4 == 0 ? 29 : 28 - else - dim = ((y2 % 4 == 0 && y2 % 100 != 0) || y2 % 400 == 0) ? 29 : 28 - end + if @sg == Float::INFINITY + dim = self.class.__send__(:days_in_month_julian, y2, m2) else - dim = DAYS_IN_MONTH_GREGORIAN[m2] + dim = self.class.__send__(:days_in_month_gregorian, y2, m2) end d2 = @day < dim ? @day : dim - # inline civil_to_jd(y2, m2, d2, @sg) - offset = GJD_MONTH_OFFSET[m2] - yy = m2 <= 2 ? y2 - 1 : y2 - gjd_base = (1461 * (yy + 4716)) / 4 + offset + d2 - a = yy / 100 - gjd = gjd_base - 1524 + 2 - a + a / 4 - jd2 = gjd >= @sg ? gjd : gjd_base - 1524 - # inline new_from_jd - obj = self.class.allocate - obj.instance_variable_set(:@jd, jd2) - obj.instance_variable_set(:@sg, @sg) - obj + jd2 = self.class.__send__(:civil_to_jd, y2, m2, d2, @sg) + self.class.__send__(:new_from_jd, jd2, @sg) end # call-seq: @@ -1603,16 +1542,7 @@ def to_datetime # Date.new(2001, 2, 3, Date::JULIAN).to_time # => 2001-02-16 00:00:00 -0600 # def to_time - # Use Gregorian date for Time (inline jd_to_gregorian) - a = @jd + 32044 - b = (4 * a + 3) / 146097 - c = a - (146097 * b) / 4 - dd = (4 * c + 3) / 1461 - e = c - (1461 * dd) / 4 - m = (5 * e + 2) / 153 - day = e - (153 * m + 2) / 5 + 1 - month = m + 3 - 12 * (m / 10) - year = 100 * b + dd - 4800 + m / 10 + year, month, day = self.class.__send__(:jd_to_gregorian, @jd) Time.local(year, month, day) end @@ -1944,48 +1874,8 @@ def internal_civil @year = 100 * b + d - 4800 + m / 10 end - # Inline jd_to_commercial: compute and cache cwyear/cweek def compute_commercial - jd = @jd - wday_val = (jd + 1) % 7 - cwday_val = wday_val == 0 ? 7 : wday_val - thursday = jd + (4 - cwday_val) - sg = @sg - # inline jd_to_gregorian/jd_to_julian to get year only - if sg == Float::INFINITY - # Julian - c = thursday + 32082 - d = (4 * c + 3) / 1461 - e = c - (1461 * d) / 4 - m = (5 * e + 2) / 153 - y = d - 4800 + m / 10 - elsif thursday >= sg - # Gregorian - a = thursday + 32044 - b = (4 * a + 3) / 146097 - c = a - (146097 * b) / 4 - d = (4 * c + 3) / 1461 - e = c - (1461 * d) / 4 - m = (5 * e + 2) / 153 - y = 100 * b + d - 4800 + m / 10 - else - # Julian - c = thursday + 32082 - d = (4 * c + 3) / 1461 - e = c - (1461 * d) / 4 - m = (5 * e + 2) / 153 - y = d - 4800 + m / 10 - end - # inline civil_to_jd(y, 1, 4, sg): month=1 (<= 2), day=4 - yy = y - 1 - gjd_base = (1461 * (yy + 4716)) / 4 + 432 # GJD_MONTH_OFFSET[1](=428) + 4 - a2 = yy / 100 - gjd = gjd_base - 1524 + 2 - a2 + a2 / 4 - jd_jan4 = gjd >= sg ? gjd : gjd_base - 1524 - wday_jan4 = (jd_jan4 + 1) % 7 - iso_wday_jan4 = wday_jan4 == 0 ? 7 : wday_jan4 - mon_wk1 = jd_jan4 - (iso_wday_jan4 - 1) - cw = (jd - mon_wk1) / 7 + 1 + y, cw, = self.class.__send__(:jd_to_commercial, @jd, @sg) unless frozen? @cweek = cw @cwyear = y diff --git a/lib/date/parse.rb b/lib/date/parse.rb index 72f55646..7f2ffaa0 100644 --- a/lib/date/parse.rb +++ b/lib/date/parse.rb @@ -1511,17 +1511,9 @@ def fast_new_date(hash, sg) if y && m && d && !hash.key?(:jd) && !hash.key?(:yday) && !hash.key?(:cwyear) && !hash.key?(:wnum0) && !hash.key?(:wnum1) && !hash.key?(:seconds) - # Ultra-fast path: inline Gregorian JD for obviously valid dates - # (year > 1582 ensures JD > ITALY for any month/day; d <= 28 is always valid) - if y >= 1583 && m >= 1 && m <= 12 && d >= 1 && d <= 28 && sg <= 2299161 - gy = m <= 2 ? y - 1 : y - a = gy / 100 - new_from_jd((1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[m] + d - 1524 + 2 - a + a / 4, sg) - else - jd = internal_valid_civil?(y, m, d, sg) - raise Error, 'invalid date' if jd.nil? - new_from_jd(jd, sg) - end + jd = internal_valid_civil?(y, m, d, sg) + raise Error, 'invalid date' if jd.nil? + new_from_jd(jd, sg) else internal_new_by_frags(hash, sg) end diff --git a/lib/date/strptime.rb b/lib/date/strptime.rb index cd615b03..d905daba 100644 --- a/lib/date/strptime.rb +++ b/lib/date/strptime.rb @@ -504,23 +504,8 @@ def internalinternal_strptime_ymd_to_date(str, sg) mon = str.byteslice(5, 2).to_i mday = str.byteslice(8, 2).to_i if mon >= 1 && mon <= 12 && mday >= 1 && mday <= 31 - # Inline civil validation + JD - if sg != Float::INFINITY - dim = DAYS_IN_MONTH_GREGORIAN[mon] - if mon == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) - dim = 29 - end - return nil if mday > dim - gy = mon <= 2 ? year - 1 : year - gjd_base = (1461 * (gy + 4716)) / 4 + GJD_MONTH_OFFSET[mon] + mday - a = gy / 100 - gjd = gjd_base - 1524 + 2 - a + a / 4 - jd = gjd >= sg ? gjd : gjd_base - 1524 - return new_from_jd(jd, sg) - else - jd = internal_valid_civil?(year, mon, mday, sg) - return jd ? new_from_jd(jd, sg) : nil - end + jd = internal_valid_civil?(year, mon, mday, sg) + return jd ? new_from_jd(jd, sg) : nil end return nil end @@ -533,23 +518,8 @@ def internalinternal_strptime_ymd_to_date(str, sg) mday = m[3].to_i return nil if mon < 1 || mon > 12 || mday < 1 || mday > 31 - # Inline civil validation + JD computation - if sg != Float::INFINITY - dim = DAYS_IN_MONTH_GREGORIAN[mon] - if mon == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) - dim = 29 - end - return nil if mday > dim - gy = mon <= 2 ? year - 1 : year - offset = GJD_MONTH_OFFSET[mon] - gjd_base = (1461 * (gy + 4716)) / 4 + offset + mday - a = gy / 100 - gjd = gjd_base - 1524 + 2 - a + a / 4 - jd = gjd >= sg ? gjd : gjd_base - 1524 - else - jd = internal_valid_civil?(year, mon, mday, sg) - return nil unless jd - end + jd = internal_valid_civil?(year, mon, mday, sg) + return nil unless jd new_from_jd(jd, sg) end @@ -622,23 +592,8 @@ def internalinternal_strptime_abdy_to_date(str, sg) return nil if mday < 1 || mday > 31 year = m[6].to_i - # Inline civil validation + JD computation - if sg != Float::INFINITY - dim = DAYS_IN_MONTH_GREGORIAN[mon] - if mon == 2 && ((year % 4 == 0 && year % 100 != 0) || year % 400 == 0) - dim = 29 - end - return nil if mday > dim - gy = mon <= 2 ? year - 1 : year - offset = GJD_MONTH_OFFSET[mon] - gjd_base = (1461 * (gy + 4716)) / 4 + offset + mday - a = gy / 100 - gjd = gjd_base - 1524 + 2 - a + a / 4 - jd = gjd >= sg ? gjd : gjd_base - 1524 - else - jd = internal_valid_civil?(year, mon, mday, sg) - return nil unless jd - end + jd = internal_valid_civil?(year, mon, mday, sg) + return nil unless jd new_from_jd(jd, sg) end From a9255c0a4f38ee044fa1da105f710f6e20b4f050 Mon Sep 17 00:00:00 2001 From: jinroq Date: Sat, 7 Mar 2026 18:53:58 +0900 Subject: [PATCH 11/11] Replace Rational() method calls with rational literals for performance Replace Rational(1, 2) with 0.5r and Rational(0) with 0r across core.rb, datetime.rb, and strftime.rb. Rational literals are resolved at compile time, avoiding method dispatch overhead on every call. Note: Rational(4800001, 2) in amjd is intentionally kept as-is because 4800001/2r is parsed as Integer#/(Rational) division at runtime, which is 2x slower than the direct Rational() constructor. Benchmark (Ruby 4.0.1 +YJIT, benchmark-ips): Date.new!: Before (Rational(1,2)): 2.812M i/s (355.58 ns/i) After (0.5r): 3.596M i/s (278.11 ns/i) Improvement: +27.9% Date#day_fraction: Before (Rational(0)): 11.230M i/s (89.05 ns/i) After (0r): 29.947M i/s (33.39 ns/i) Improvement: +166.7% Micro-benchmark (literal vs method call): 0r vs Rational(0): 34.5M vs 11.3M i/s (+3.05x) 0.5r vs Rational(1,2): 34.2M vs 8.8M i/s (+3.90x) --- lib/date/core.rb | 6 +++--- lib/date/datetime.rb | 12 ++++++------ lib/date/strftime.rb | 2 +- 3 files changed, 10 insertions(+), 10 deletions(-) diff --git a/lib/date/core.rb b/lib/date/core.rb index 325aa20f..06bebea9 100644 --- a/lib/date/core.rb +++ b/lib/date/core.rb @@ -328,7 +328,7 @@ def _load(s) def new!(ajd = 0, of = 0, sg = DEFAULT_SG) # ajd is Astronomical Julian Day (may be Rational) # Convert to integer JD and day fraction (same as C's old_to_new) - raw_jd = ajd + Rational(1, 2) + raw_jd = ajd + 0.5r jd = raw_jd.floor df = raw_jd - jd obj = allocate @@ -875,7 +875,7 @@ def cwyear # DateTime.new(2001,2,3,12).day_fraction # => (1/2) # def day_fraction - @df || Rational(0) + @df || 0r end # call-seq: @@ -1585,7 +1585,7 @@ def marshal_load(array) when 3 # Format 1.8: [ajd, of, sg] ajd, _of, sg = array - raw_jd = ajd + Rational(1, 2) + raw_jd = ajd + 0.5r jd = raw_jd.floor df = raw_jd - jd init_from_jd(jd, sg, df == 0 ? nil : df) diff --git a/lib/date/datetime.rb b/lib/date/datetime.rb index fe990943..61a69d63 100644 --- a/lib/date/datetime.rb +++ b/lib/date/datetime.rb @@ -140,7 +140,7 @@ def ajd time_r = Rational(@hour * 3600 + @min * 60 + @sec_i, 86400) + Rational(@sec_frac.numerator, @sec_frac.denominator * 86400) of_r = Rational(@of, 86400) - jd_r + time_r - of_r - Rational(1, 2) + jd_r + time_r - of_r - 0.5r end # --------------------------------------------------------------------------- @@ -440,12 +440,12 @@ def marshal_load(array) when 2 jd_like, sg_or_bool = array sg = sg_or_bool == true ? ITALY : (sg_or_bool == false ? JULIAN : sg_or_bool.to_f) - _init_datetime(jd_like.to_i, 0, 0, 0, Rational(0), 0, sg) + _init_datetime(jd_like.to_i, 0, 0, 0, 0r, 0, sg) when 3 ajd, of_r, sg = array of_sec = (of_r * 86400).to_i # Reconstruct local JD and time from AJD - local_r = ajd + Rational(1, 2) + of_r + local_r = ajd + 0.5r + of_r jd = local_r.floor rem_r = (local_r - jd) * 86400 h = rem_r.to_i / 3600 @@ -857,7 +857,7 @@ def _dt_new_by_frags(hash, sg) warn("invalid offset is ignored: #{of}", uplevel: 0) of = 0 end - sf = hash[:sec_fraction] || Rational(0) + sf = hash[:sec_fraction] || 0r _new_dt_from_jd_time(jd, h, m, s, sf, of, sg) end @@ -880,7 +880,7 @@ def _split_sec(second) s_i = s_r.floor [s_i, s_r - s_i] else - [Integer(second), Rational(0)] + [Integer(second), 0r] end end @@ -932,7 +932,7 @@ def _split_second(second) s_i = s_r.floor [s_i, s_r - s_i] else - [Integer(second), Rational(0)] + [Integer(second), 0r] end end diff --git a/lib/date/strftime.rb b/lib/date/strftime.rb index 65e6444c..5d66cadf 100644 --- a/lib/date/strftime.rb +++ b/lib/date/strftime.rb @@ -523,7 +523,7 @@ def internal_sec end def sec_frac - Rational(0) + 0r end def of_seconds