acute 1.0.0

data/lib/acute/calendar.rb

@@ -0,0 +1,91 @@
+# Proleptic Gregorian dates as day numbers (days since 1970-01-01), after Howard Hinnant's algorithms.
+module Acute
+  # @api private
+  module Calendar
+    MONTH_DAYS = [0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31].freeze
+
+    def self.days_from_civil(y, m, d)
+      y -= 1 if m <= 2
+      era = y / 400
+      yoe = y - era * 400
+      doy = (153 * (m > 2 ? m - 3 : m + 9) + 2) / 5 + d - 1
+      doe = yoe * 365 + yoe / 4 - yoe / 100 + doy
+      era * 146_097 + doe - 719_468
+    end
+
+    # The day number of January 1st of year y
+    def self.year_start(y)
+      y -= 1
+      365 * y + y / 4 - y / 100 + y / 400 - 719_162
+    end
+
+    # The year whose January 1st is day d, or nil when d is no January 1st. The guess counts average years
+    # to the year's middle, which is exact for every January 1st.
+    def self.year_if_first(d)
+      y = (d + 719_344) * 400 / 146_097
+      y + 1 if 365 * y + y / 4 - y / 100 + y / 400 - 719_162 == d
+    end
+
+    # The year holding day d. The guess counts average years from year 1 and is the year or the one before.
+    def self.year_of(d)
+      y = (d + 719_162) * 400 / 146_097 + 1
+      365 * y + y / 4 - y / 100 + y / 400 - 719_162 <= d ? y + 1 : y
+    end
+
+    # D17: the day n (not 0) Mondays to Fridays after day d, or before it when n is negative. A weekend counts from the
+    # Friday before it going forward, and the Monday after it going back.
+    def self.add_weekdays(d, n)
+      m = (d + 3) % 7 # Monday 0 to Sunday 6
+      if n > 0
+        d -= m - 4 if m > 4
+        r = n % 5
+        d + n / 5 * 7 + r + ((m > 4 ? 4 : m) + r > 4 ? 2 : 0)
+      else
+        n = -n
+        d += 7 - m if m > 4
+        r = n % 5
+        d - n / 5 * 7 - r - ((m > 4 ? 0 : m) < r ? 2 : 0)
+      end
+    end
+
+    # Packed as y * 10000 + m * 100 + d, so the hot path allocates no Array
+    def self.civil_from_days(z)
+      z += 719_468
+      era = z / 146_097
+      doe = z - era * 146_097
+      yoe = (doe - doe / 1460 + doe / 36_524 - doe / 146_096) / 365
+      y = yoe + era * 400
+      doy = doe - (365 * yoe + yoe / 4 - yoe / 100)
+      mp = (5 * doy + 2) / 153
+      d = doy - (153 * mp + 2) / 5 + 1
+      m = mp < 10 ? mp + 3 : mp - 9
+      y += 1 if m <= 2
+      y * 10_000 + m * 100 + d
+    end
+
+    def self.leap?(y) = (y % 4 == 0 && y % 100 != 0) || y % 400 == 0
+
+    def self.days_in_month(y, m) = m == 2 && leap?(y) ? 29 : MONTH_DAYS[m]
+
+    # 0 = Sunday
+    def self.weekday(days) = (days + 4) % 7
+
+    # The Monday that starts ISO week 1 of year y: the week holding January 4th
+    def self.iso_week_one(y)
+      jan4 = days_from_civil(y, 1, 4)
+      jan4 - (jan4 + 3) % 7
+    end
+
+    # The day number of Western Easter Sunday, by the anonymous Gregorian algorithm (Meeus, Jones, Butcher)
+    def self.easter(y)
+      a = y % 19
+      b = y / 100
+      c = y % 100
+      h = (19 * a + b - b / 4 - (b - (b + 8) / 25 + 1) / 3 + 15) % 30
+      l = (32 + 2 * (b % 4) + 2 * (c / 4) - h - c % 4) % 7
+      m = (a + 11 * h + 22 * l) / 451
+      n = h + l - 7 * m + 114
+      days_from_civil(y, n / 31, n % 31 + 1)
+    end
+  end
+end

data/lib/acute/chronic.rb

@@ -0,0 +1,176 @@
+require_relative "../acute"
+
+# chronic 0.10.2's API on acute's parser, for code written against chronic. It takes chronic's options and
+# returns what chronic returns, but the answers follow acute's rules (D46).
+module Chronic
+  VERSION = "0.10.2".freeze
+
+  class << self
+    attr_accessor :time_class, :debug
+
+    def parse(text, options = {}) = Parser.new(options).parse(text)
+  end
+  self.time_class = ::Time
+  self.debug = false
+
+  class Span < Range
+    def width = (self.end - self.begin).to_i
+
+    def +(other) = Span.new(self.begin + other, self.end + other)
+
+    def -(other) = self + -other
+
+    def to_s = "(#{self.begin}..#{self.end})"
+  end
+
+  class Parser
+    DEFAULT_OPTIONS = Ractor.make_shareable({
+      context: :future, now: nil, hours24: nil, week_start: nil, guess: true, ambiguous_time_range: 6,
+      endian_precedence: %i[middle little], ambiguous_year_future_bias: 50
+    })
+
+    Reading = Struct.new(:begin, :end, :point, :span, :frac)
+    Notes = Struct.new(:dst)
+    NUMERIC_DATE = %r{(?<!\d)(\d{1,2})(?:[/\-.]|\s+)(\d{1,2})(?!\d)}
+
+    attr_accessor :now
+    attr_reader :options
+
+    def initialize(options = {})
+      @options = DEFAULT_OPTIONS.merge(options)
+      @endian = options[:endian_precedence]
+      @now = @options[:now] || Chronic.time_class.now
+    end
+
+    def parse(text)
+      zone = Acute::Zone.for(zone_name)
+      result = read(text.to_s, zone) or return
+      reading = choose(result, text.to_s, zone)
+      out = guess_reading(reading, zone, @options[:guess])
+      Range === out ? Span.new(at(out.begin), at(out.end)) : at(out)
+    end
+
+    def guess(span, mode = :middle)
+      return span unless mode
+      return span.end if mode == :end
+      return span.begin unless span.width > 1 && (mode == true || mode == :middle)
+      # the middle on the wall clock, so a day with a DST change still guesses 12:00 (D46)
+      shift = span.begin.utc_offset - span.end.utc_offset
+      late = span.begin + (span.width + shift) / 2
+      late.utc_offset == span.end.utc_offset ? late : span.begin + (span.width - shift) / 2
+    end
+
+    private
+
+    # Chronic skips words it doesn't know, as acute does with strict: false: text with such words gives the
+    # first time mentioned in it; text acute knows every word of and still refuses ("5th tuesday in february")
+    # stays nil (D46)
+    def read(text, zone)
+      Acute.parse(text, now: @now, zone: zone.name, context: @options[:context] == :past ? :past : :future,
+                        week_start: @options[:week_start], strict: false,
+                        year_bias: @options[:ambiguous_year_future_bias])
+    end
+
+    # Chronic's options for ambiguous text pick among acute's readings; acute's order stands where they don't
+    def choose(result, text, zone)
+      codes = result.assumptions.map(&:code)
+      clock = nil
+      all = ([result] + result.alternatives).map do |r|
+        # D47: chronic guesses inside every span but a clock time someone said ("4pm", "at 5:30"), so "next
+        # hour", one grain long and an instant to acute, is guessed too
+        long = !r.span? && r.end - r.begin > 1
+        clock = said_clock?(result.matched) if long && clock.nil?
+        span = r.span? || (long && !clock)
+        Reading.new(r.begin&.to_i, r.end&.to_i, r.time.to_i, span, r.time.subsec)
+      end
+      if codes.include?(:bare_hour_window)
+        # :none sets no window: the next (or in the past, latest) occurrence of the hour on either half of the day
+        all = if @options[:ambiguous_time_range] == :none
+                sign = @options[:context] == :past ? -1 : 1
+                all.sort_by { _1.begin.to_i * sign }
+              else
+                prefer(all) { |r| hour_window.include?(wall(r.point, zone) / 3600 % 24) }
+              end
+      end
+      # only when given: without it the locale decides, as D10 says
+      if @endian && codes.include?(:numeric_date_order) && (m = NUMERIC_DATE.match(text))
+        a, b = m[1].to_i, m[2].to_i
+        Array(@endian).reverse_each do |endian|
+          all = prefer(all) do |r|
+            _, month, day = civil(r.point, zone)
+            endian == :little ? [day, month] == [a, b] : [month, day] == [a, b]
+          end
+        end
+      end
+      all.first
+    end
+
+    def said_clock?(text) = clock_in?(Acute::Grammar.parse(Acute::Lexer.lex(text)))
+
+    def clock_in?(node)
+      case node
+      when Acute::Grammar::Clock then true
+      when Struct, Array then node.each.any? { clock_in?(_1) }
+      else false
+      end
+    end
+
+    def prefer(all)
+      hits = all.select { yield _1 }
+      hits.empty? ? all : hits + (all - hits)
+    end
+
+    # The hours an hour written without am/pm may mean: chronic's window from ambiguous_time_range, or the
+    # hour as written under hours24
+    def hour_window
+      range = @options[:ambiguous_time_range]
+      start = @options[:hours24] == true || range == :none ? 1 : Integer(range)
+      start...(start + 12)
+    end
+
+    # Epochs, or a Range of them when guess is false, which in chronic always returns a Span; an instant keeps
+    # its written fraction of a second (D47)
+    def guess_reading(r, zone, mode)
+      return (r.begin && r.begin + r.frac)..(r.end && r.end + r.frac) unless mode || (r.begin.nil? && r.end.nil?)
+      return r.point + r.frac unless r.span && r.begin && r.end
+      return r.end if mode == :end
+      return r.begin unless mode == true || mode == :middle
+      mid = (wall(r.begin, zone) + wall(r.end, zone)) / 2
+      zone.local_to_utc(mid, Notes.new)
+    end
+
+    def wall(epoch, zone) = epoch + zone.offset_at(epoch)
+
+    def civil(epoch, zone)
+      ymd = Acute::Calendar.civil_from_days(wall(epoch, zone).div(86_400))
+      [ymd / 10_000, ymd / 100 % 100, ymd % 100]
+    end
+
+    # Chronic builds times in time_class: Time's local zone, or a zone like Time.zone
+    def zone_name
+      klass = Chronic.time_class
+      return klass.tzinfo if klass.respond_to?(:tzinfo)
+      return Acute::Context::SYSTEM_ZONE unless Ractor.current == Ractor.main # the cache is the main Ractor's
+      tz = ENV["TZ"]
+      cached = Parser.system_zone
+      return cached[1] if cached && cached[0] == tz
+      Parser.system_zone = [tz, Acute::Context.system_zone]
+      Parser.system_zone[1]
+    end
+
+    def at(epoch)
+      return if epoch.nil?
+      klass = Chronic.time_class
+      return klass.at(epoch) if klass.respond_to?(:tzinfo)
+      time = Time.at(epoch)
+      if klass == ::Date then time.to_date
+      elsif klass == ::DateTime then time.to_datetime
+      else time
+      end
+    end
+
+    class << self
+      attr_accessor :system_zone
+    end
+  end
+end

data/lib/acute/chronic_duration.rb

@@ -0,0 +1,321 @@
+require "strscan"
+require_relative "../acute"
+
+# chronic_duration's API, 0.10.6 and GitLab's 0.12.0 fork, on acute. Its tokeniser, number words and fixed unit
+# lengths are kept, so answers match the gems. Where the gem would skip words and acute reads the whole text as
+# a duration ("half an hour", "1 fortnight"), acute's reading wins, at the same fixed lengths (D46).
+module ChronicDuration
+  extend self
+
+  class DurationParseError < StandardError
+  end
+
+  VERSION = "0.12.0".freeze
+  FULL_WEEKS_PER_MONTH = 4
+  YEAR = 31_557_600
+  UNITS = Ractor.make_shareable(%w[seconds minutes hours days weeks months years])
+  CHRONO_UNITS = Ractor.make_shareable(UNITS - ["weeks"])
+  JOIN_WORDS = Ractor.make_shareable(%w[and with plus])
+  FLOAT = /[0-9]*\.?[0-9]+/
+  # "4:13:02" wherever it stands (D46). GitLab's 0.12 read it only as the whole text, so "2 days, 4:13:02" lost
+  # its 4:13; upstream split the whole text at colons, so "Duration: 2 hours" gained a minute.
+  CHRONO = /(?<![\d:.])\d+(?:\s*:\s*\d+){1,5}(?:\.\d*)?(?![\d:])/
+  MAPPINGS = Ractor.make_shareable({
+    "seconds" => "seconds", "second" => "seconds", "secs" => "seconds", "sec" => "seconds", "s" => "seconds",
+    "minutes" => "minutes", "minute" => "minutes", "mins" => "minutes", "min" => "minutes", "m" => "minutes",
+    "hours" => "hours", "hour" => "hours", "hrs" => "hours", "hr" => "hours", "h" => "hours",
+    "days" => "days", "day" => "days", "dy" => "days", "d" => "days",
+    "weeks" => "weeks", "week" => "weeks", "wks" => "weeks", "wk" => "weeks", "w" => "weeks",
+    "months" => "months", "mo" => "months", "mos" => "months", "month" => "months",
+    "years" => "years", "year" => "years", "yrs" => "years", "yr" => "years", "y" => "years"
+  })
+  DIVIDERS = Ractor.make_shareable({
+    micro: { years: "y", months: "mo", weeks: "w", days: "d", hours: "h", minutes: "m", seconds: "s" },
+    short: { years: "y", months: "mo", weeks: "w", days: "d", hours: "h", minutes: "m", seconds: "s" },
+    default: { years: " yr", months: " mo", weeks: " wk", days: " day", hours: " hr", minutes: " min", seconds: " sec",
+               pluralize: true },
+    long: { years: " year", months: " month", weeks: " week", days: " day", hours: " hour", minutes: " minute",
+            seconds: " second", pluralize: true },
+    chrono: { years: ":", months: ":", weeks: ":", days: ":", hours: ":", minutes: ":", seconds: ":", keep_zero: true }
+  })
+
+  class << self
+    attr_accessor :hours_per_day
+    attr_reader :days_per_month, :raise_exceptions
+    attr_writer :days_per_week
+
+    def raise_exceptions=(value)
+      @raise_exceptions = !!value
+    end
+
+    # upstream sets the week's days; GitLab derives them from the month's. Whichever was set last counts (D46).
+    def days_per_week = @days_per_week || days_per_month / FULL_WEEKS_PER_MONTH
+
+    def days_per_month=(value)
+      @days_per_month = value
+      @days_per_week = nil
+    end
+  end
+  self.raise_exceptions = false
+  self.hours_per_day = 24
+  self.days_per_month = 30
+
+  def parse(string, opts = {})
+    # T3: past the 512 bytes acute reads, before the rewrites rather than after them
+    if string.bytesize > Acute::MAX_LENGTH
+      raise DurationParseError, "The string is longer than #{Acute::MAX_LENGTH} bytes." if ChronicDuration.raise_exceptions
+      return
+    end
+    words, skipped = clean(string)
+    result = acute_seconds(string, opts) unless skipped.empty?
+    if result.nil?
+      if !skipped.empty? && ChronicDuration.raise_exceptions
+        raise DurationParseError, "An invalid word #{skipped[0].inspect} was used in the string to be parsed."
+      end
+      result = calculate_from_words(words, opts)
+    end
+    !opts[:keep_zero] && result == 0 ? nil : result
+  end
+
+  def output(seconds, opts = {})
+    int = seconds.to_i
+    seconds = int if seconds - int == 0
+    style = opts[:format] || :default
+    hours_per_day, days_per_month, days_per_week = settings(opts)
+    years = months = weeks = days = hours = minutes = 0
+    decimal_places = seconds.to_s.split(".").last.length if seconds.is_a?(Float)
+
+    day = hours_per_day * 3600
+    month = days_per_month * day
+    if seconds >= YEAR && seconds % YEAR < seconds % month
+      years = seconds / YEAR
+      months = seconds % YEAR / month
+      days = seconds % YEAR % month / day
+      hours = seconds % YEAR % month % day / 3600
+      minutes = seconds % YEAR % month % day % 3600 / 60
+      seconds = seconds % YEAR % month % day % 3600 % 60
+    elsif seconds >= 60
+      minutes = (seconds / 60).to_i
+      seconds %= 60
+      if minutes >= 60
+        hours = (minutes / 60).to_i
+        minutes = (minutes % 60).to_i
+        if !opts[:limit_to_hours] && hours >= hours_per_day
+          days = (hours / hours_per_day).to_i
+          hours = (hours % hours_per_day).to_i
+          if opts[:weeks]
+            if days >= days_per_week
+              weeks = (days / days_per_week).to_i
+              days = (days % days_per_week).to_i
+              if weeks >= FULL_WEEKS_PER_MONTH
+                months = (weeks / FULL_WEEKS_PER_MONTH).to_i
+                weeks = (weeks % FULL_WEEKS_PER_MONTH).to_i
+              end
+            end
+          elsif days >= days_per_month
+            months = (days / days_per_month).to_i
+            days = (days % days_per_month).to_i
+          end
+        end
+      end
+    end
+
+    dividers = DIVIDERS[style]
+    joiner = %i[micro chrono].include?(style) ? "" : opts.fetch(:joiner, " ")
+    counts = { years: years, months: months, weeks: weeks, days: days, hours: hours, minutes: minutes, seconds: seconds }
+    # the gem's compact! returned nil when no unit was dropped, so weeks: true with every unit shown raised (D46)
+    result = counts.filter_map do |unit, num|
+      next if unit == :weeks && !opts[:weeks]
+      num = format("%.#{decimal_places}f", num) if num.is_a?(Float) && unit == :seconds
+      keep_zero = dividers[:keep_zero] || (opts[:keep_zero] if unit == :seconds)
+      humanize_time_unit(num, dividers[unit], dividers[:pluralize], keep_zero)
+    end
+    result = result[0...opts[:units]] if opts[:units]
+    result = result.join(joiner)
+    result = chrono(result, decimal_places) if style == :chrono
+    result.empty? ? nil : result
+  end
+
+  private
+
+  def humanize_time_unit(number, unit, pluralize, keep_zero)
+    return if number == 0 && !keep_zero
+    res = "#{number}#{unit}"
+    res << "s" if number != 1 && pluralize
+    res
+  end
+
+  # Pad each part to two digits, then drop leading zero parts, a leading zero and the trailing colon
+  def chrono(str, decimal_places)
+    str.split(":").map { |n| n.include?(".") ? format("%04.#{decimal_places}f", n) : format("%02d", n) }
+       .join(":").gsub(/^(00:)+/, "").gsub(/^0/, "").gsub(/:$/, "")
+  end
+
+  # Per-call options over the module's settings; GitLab's per-call days_per_month also sets the week
+  def settings(opts)
+    hours_per_day = opts[:hours_per_day] || ChronicDuration.hours_per_day
+    days_per_month = opts[:days_per_month] || ChronicDuration.days_per_month
+    days_per_week = opts[:days_per_week] ||
+                    (opts[:days_per_month] ? days_per_month / FULL_WEEKS_PER_MONTH : ChronicDuration.days_per_week)
+    [hours_per_day, days_per_month, days_per_week]
+  end
+
+  def lengths(opts)
+    hours_per_day, days_per_month, days_per_week = settings(opts)
+    day = 3600 * hours_per_day
+    { "years" => YEAR, "months" => day * days_per_month, "weeks" => day * days_per_week, "days" => day,
+      "hours" => 3600, "minutes" => 60, "seconds" => 1 }
+  end
+
+  def calculate_from_words(string, opts)
+    seconds = lengths(opts)
+    words = string.split
+    words.each_with_index.sum do |v, k|
+      v.match?(FLOAT) ? convert_to_number(v) * seconds.fetch(words[k + 1] || opts[:default_unit] || "seconds", 0) : 0
+    end
+  end
+
+  # acute's reading of the whole text, each unit said at the gem's fixed lengths, so "2.5 weeks" of 5-day weeks
+  # is 12.5 days. A business day has no such length, so the gem's answer stands. A fraction anywhere makes a
+  # Float, as the gem's own decimals do.
+  def acute_seconds(string, opts)
+    tokens = Acute::Lexer.lex(string)
+    return if Acute::Failure === tokens
+    units = Acute::Grammar.duration(tokens)
+    return if Acute::Failure === units
+    parts = units.map { |u| [*Acute::Duration::UNIT_PART.fetch(u.unit), u.count] }
+    return if parts.any? { |part, *| part == :business_days }
+    seconds = lengths(opts)
+    total = parts.sum { |part, k, count| count * k * seconds.fetch(part.to_s) }
+    parts.all? { |*, count| count.to_r.denominator == 1 } ? total.to_i : total.to_f
+  end
+
+  def cleanup(string) = clean(string)[0]
+
+  def clean(string)
+    res = filter_by_type(Numerizer.numerize(string.downcase))
+    res = res.gsub(FLOAT) { " #{_1} " }.squeeze(" ").strip
+    filter_through_white_list(res)
+  end
+
+  def convert_to_number(string) = string.to_f % 1 > 0 ? string.to_f : string.to_i
+
+  # "3:41:59" is 3 hours 41 minutes 59 seconds
+  def filter_by_type(string)
+    string.gsub(CHRONO) do |chrono|
+      chrono.delete(" ").split(":").reverse.each_with_index.map { |v, k| "#{v} #{CHRONO_UNITS[k]}" }.reverse.join(" ")
+    end
+  end
+
+  # The units named, with numbers kept and other words skipped; the skipped words come back too
+  def filter_through_white_list(string)
+    res = []
+    skipped = []
+    string.split.each do |word|
+      next res << word.strip if word.match?(FLOAT)
+      stripped = word.strip.delete_prefix(",").delete_suffix(",")
+      if MAPPINGS.key?(stripped) then res << MAPPINGS[stripped]
+      elsif !JOIN_WORDS.include?(stripped) then skipped << word
+      end
+    end
+    # "day" or "minute 30sec": a unit first counts one
+    res.unshift(1) if !res.empty? && MAPPINGS[res[0]]
+    [res.join(" "), skipped]
+  end
+
+  # numerizer 0.2.0, which both gems use for number words
+  module Numerizer
+    DIRECT_NUMS = [
+      ["eleven", "11"], ["twelve", "12"], ["thirteen", "13"], ["fourteen", "14"], ["fifteen", "15"], ["sixteen", "16"],
+      ["seventeen", "17"], ["eighteen", "18"], ["nineteen", "19"], ["ninteen", "19"], ["zero", "0"], ["ten", "10"],
+      ['\ba[\b^$]', "1"]
+    ].freeze
+    SINGLE_NUMS = [
+      ["one", 1], ["two", 2], ["three", 3], ["four", 4], ["five", 5], ["six", 6], ["seven", 7],
+      ["eight", 8], ["nine", 9]
+    ].freeze
+    TEN_PREFIXES = [
+      ["twenty", 20], ["thirty", 30], ["forty", 40], ["fourty", 40], ["fifty", 50], ["sixty", 60],
+      ["seventy", 70], ["eighty", 80], ["ninety", 90]
+    ].freeze
+    BIG_PREFIXES = [
+      ["hundred", 100], ["thousand", 1000], ["million", 1_000_000], ["billion", 1_000_000_000],
+      ["trillion", 1_000_000_000_000]
+    ].freeze
+    FRACTIONS = [
+      ["half", 2], ["third(s)?", 3], ["fourth(s)?", 4], ["quarter(s)?", 4], ["fifth(s)?", 5],
+      ["sixth(s)?", 6], ["seventh(s)?", 7], ["eighth(s)?", 8], ["nineth(s)?", 9]
+    ].freeze
+    SINGLE_ORDINALS = [
+      ["first", 1], ["third", 3], ["fourth", 4], ["fifth", 5], ["sixth", 6], ["seventh", 7],
+      ["eighth", 8], ["ninth", 9]
+    ].freeze
+    DIRECT_ORDINALS = [
+      ["tenth", "10"], ["eleventh", "11"], ["twelfth", "12"], ["thirteenth", "13"], ["fourteenth", "14"],
+      ["fifteenth", "15"], ["sixteenth", "16"], ["seventeenth", "17"], ["eighteenth", "18"], ["nineteenth", "19"],
+      ["twentieth", "20"], ["thirtieth", "30"], ["fourtieth", "40"], ["fiftieth", "50"], ["sixtieth", "60"],
+      ["seventieth", "70"], ["eightieth", "80"], ["ninetieth", "90"]
+    ].freeze
+    # The inner pairs too, so a Ractor can read them
+    [DIRECT_NUMS, SINGLE_NUMS, TEN_PREFIXES, BIG_PREFIXES, FRACTIONS, SINGLE_ORDINALS, DIRECT_ORDINALS].each { Ractor.make_shareable(_1) }
+
+    module_function
+
+    def numerize(string)
+      string = string.dup
+      string.gsub!(/ +|([^\d])-([^\d])/, '\1 \2')
+      (DIRECT_NUMS + SINGLE_NUMS).each do |word, n|
+        string.gsub!(/(^|\W)#{word}(?=$|\W)/i, "\\1<num>#{n}")
+      end
+      TEN_PREFIXES.each do |tp, t|
+        SINGLE_NUMS.each { |dn, d| string.gsub!(/(^|\W)#{tp}#{dn}(?=$|\W)/i, "\\1<num>#{t + d}") }
+        SINGLE_ORDINALS.each { |dn, d| string.gsub!(/(^|\W)#{tp}(\s)?#{dn}(?=$|\W)/i, "\\1<num>#{t + d}#{dn[-2, 2]}") }
+        string.gsub!(/(^|\W)#{tp}(?=$|\W)/i, "\\1<num>#{t}")
+      end
+      FRACTIONS.each do |word, d|
+        string.gsub!(/a #{word}(?=$|\W)/i, "<num>1/#{d}")
+        string.gsub!(/\s#{word}(?=$|\W)/i, "/#{d}")
+      end
+      (DIRECT_ORDINALS + SINGLE_ORDINALS).each do |word, n|
+        string.gsub!(/(^|\W)#{word}(?=$|\W)/i, "\\1<num>#{n}#{word[-2, 2]}")
+      end
+      # a fraction after a number adds to it
+      string.gsub!(%r{(\d+)(?: | and |-)+(<num>|\s)*(\d+)\s*/\s*(\d+)}i) { ($1.to_f + ($3.to_f / $4.to_f)).to_s }
+      BIG_PREFIXES.each do |word, n|
+        string.gsub!(/(?:<num>)?(\d*) *#{word}/i) { $1.empty? ? n.to_s : "<num>#{n * $1.to_i}" }
+        andition(string)
+      end
+      andition(string)
+      string.gsub("<num>", "")
+    end
+
+    # "<num>20 <num>4" is 24, and "<num>100 and <num>5" 105
+    def andition(string)
+      sc = StringScanner.new(string)
+      while sc.scan_until(/<num>(\d+)( | and )<num>(\d+)(?=[^\w]|$)/i)
+        next unless sc[2].include?("and") || sc[1].size > sc[3].size
+        string[(sc.pos - sc.matched_size)..(sc.pos - 1)] = "<num>#{sc[1].to_i + sc[3].to_i}"
+        sc.reset
+      end
+    end
+  end
+  private_constant :Numerizer
+end
+
+# Ported from chronic_duration 0.10.6 and gitlab_chronic_duration 0.12.0, and from numerizer 0.2.0:
+#
+# Copyright (c) Henry Poydar (chronic_duration); Copyright (c) 2008 Tom Preston-Werner (numerizer)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
+# documentation files (the "Software"), to deal in the Software without restriction, including without limitation
+# the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all copies or substantial portions of
+# the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+# THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.