class Date

def acts_like_date?
  true
end

def advance: ((years | Integer | days | Integer | hours | Integer) options) -> Date

def advance(options)
  d = self
  d = d >> options[:years] * 12 if options[:years]
  d = d >> options[:months] if options[:months]
  d = d + options[:weeks] * 7 if options[:weeks]
  d = d + options[:days] if options[:days]
  d
end

def ago(seconds)
  in_time_zone.since(-seconds)
end

def as_json(options = nil) # :nodoc:
  if ActiveSupport::JSON::Encoding.use_standard_json_time_format
    strftime("%Y-%m-%d")
  else
    strftime("%Y/%m/%d")
  end
end

def beginning_of_day
  in_time_zone
end

def beginning_of_week
  ::ActiveSupport::IsolatedExecutionState[:beginning_of_week] || beginning_of_week_default || :monday
end

def beginning_of_week=(week_start)
  ::ActiveSupport::IsolatedExecutionState[:beginning_of_week] = find_beginning_of_week!(week_start)
end

def blank?
  false
end

def change(options)
  ::Date.new(
    options.fetch(:year, year),
    options.fetch(:month, month),
    options.fetch(:day, day)
  )
end

def compare_with_coercion(other)
  if other.is_a?(Time)
    to_datetime <=> other
  else
    compare_without_coercion(other)
  end
end

def current
  ::Time.zone ? ::Time.zone.today : ::Date.today
end

def end_of_day
  in_time_zone.end_of_day
end

def find_beginning_of_week!(week_start)
  raise ArgumentError, "Invalid beginning of week: #{week_start}" unless ::Date::DAYS_INTO_WEEK.key?(week_start)
  week_start
end

def middle_of_day
  in_time_zone.middle_of_day
end

def minus_with_duration(other) # :nodoc:
  if ActiveSupport::Duration === other
    plus_with_duration(-other)
  else
    minus_without_duration(other)
  end
end

def plus_with_duration: (Integer other) -> Date

def plus_with_duration(other) # :nodoc:
  if ActiveSupport::Duration === other
    other.since(self)
  else
    plus_without_duration(other)
  end
end

def readable_inspect
  strftime("%a, %d %b %Y")
end

def since(seconds)
  in_time_zone.since(seconds)
end

def to_fs(format = :default)
  if formatter = DATE_FORMATS[format]
    if formatter.respond_to?(:call)
      formatter.call(self).to_s
    else
      strftime(formatter)
    end
  else
    to_default_s
  end
end

def to_s(format = NOT_SET) # :nodoc:
  if formatter = DATE_FORMATS[format]
    ActiveSupport::Deprecation.warn(
      "Date#to_s(#{format.inspect}) is deprecated. Please use Date#to_fs(#{format.inspect}) instead."
    )
    if formatter.respond_to?(:call)
      formatter.call(self).to_s
    else
      strftime(formatter)
    end
  elsif format == NOT_SET
    if formatter = DATE_FORMATS[:default]
      ActiveSupport::Deprecation.warn(
        "Using a :default format for Date#to_s is deprecated. Please use Date#to_fs instead."
      )
      if formatter.respond_to?(:call)
        formatter.call(self).to_s
      else
        strftime(formatter)
      end
    else
      to_default_s
    end
  else
    ActiveSupport::Deprecation.warn(
      "Date#to_s(#{format.inspect}) is deprecated. Please use Date#to_fs(#{format.inspect}) instead."
    )
    to_default_s
  end
end

def to_time(form = :local)
  raise ArgumentError, "Expected :local or :utc, got #{form.inspect}." unless [:local, :utc].include?(form)
  ::Time.public_send(form, year, month, day)
end

def tomorrow
  ::Date.current.tomorrow
end

def xmlschema
  in_time_zone.xmlschema
end

def yesterday
  ::Date.current.yesterday
end