rbs 0.20.1 → 1.0.0.pre

data/lib/rbs/parser.y

@@ -99,11 +99,13 @@ rule
       { result = nil }
     | kLT class_name {
         result = Declarations::Class::Super.new(name: val[1].value,
-                                                args: [])
+                                                args: [],
+                                                location: val[1].location)
       }
     | kLT class_name kLBRACKET type_list kRBRACKET {
         result = Declarations::Class::Super.new(name: val[1].value,
-                                                args: val[3])
+                                                args: val[3],
+                                                location: val[1].location + val[4].location)
       }
 
   module_decl:
@@ -839,6 +841,15 @@ rule
     | keyword type {
         result = { val[0].value => val[1] }
       }
+    | identifier_keywords kCOLON type {
+        result = { val[0].value => val[2] }
+      }
+    | tQUOTEDIDENT kCOLON type {
+        result = { val[0].value => val[2] }
+      }
+    | tQUOTEDMETHOD kCOLON type {
+        result = { val[0].value => val[2] }
+      }
 
   keyword_name:
       keyword

data/lib/rbs/prototype/rb.rb

@@ -85,7 +85,7 @@ module RBS
           class_name, super_class, *class_body = node.children
           kls = AST::Declarations::Class.new(
             name: const_to_name(class_name),
-            super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: []),
+            super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: [], location: nil),
             type_params: AST::Declarations::ModuleTypeParams.empty,
             members: [],
             annotations: [],

data/lib/rbs/prototype/rbi.rb

@@ -47,7 +47,7 @@ module RBS
       def push_class(name, super_class, comment:)
         modules.push AST::Declarations::Class.new(
           name: nested_name(name),
-          super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: []),
+          super_class: super_class && AST::Declarations::Class::Super.new(name: const_to_name(super_class), args: [], location: nil),
           type_params: AST::Declarations::ModuleTypeParams.empty,
           members: [],
           annotations: [],

data/lib/rbs/prototype/runtime.rb

@@ -61,11 +61,32 @@ module RBS
         end
       end
 
-      def each_mixin(mixins, *super_mixes)
-        supers = Set.new(super_mixes)
-        mixins.each do |mix|
+      def each_included_module(type_name, mod)
+        supers = Set[]
+
+        mod.included_modules.each do |mix|
+          supers.merge(mix.included_modules)
+        end
+
+        if mod.is_a?(Class)
+          mod.superclass.included_modules.each do |mix|
+            supers << mix
+            supers.merge(mix.included_modules)
+          end
+        end
+
+        mod.included_modules.each do |mix|
           unless supers.include?(mix)
-            yield mix
+            unless const_name(mix)
+              RBS.logger.warn("Skipping anonymous module #{mix} included in #{mod}")
+            else
+              module_name = to_type_name(const_name(mix))
+              if module_name.namespace == type_name.namespace
+                module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
+              end
+
+              yield module_name, mix
+            end
           end
         end
       end
@@ -298,11 +319,11 @@ module RBS
                      location: nil
                    )
                  else
-                   Types::ClassInstance.new(name: to_type_name(value.class.to_s), args: [], location: nil)
+                   Types::ClassInstance.new(name: to_type_name(const_name(value.class)), args: [], location: nil)
                  end
 
           @decls << AST::Declarations::Constant.new(
-            name: "#{mod.to_s}::#{name}",
+            name: "#{const_name(mod)}::#{name}",
             type: type,
             location: nil,
             comment: nil
@@ -311,14 +332,14 @@ module RBS
       end
 
       def generate_class(mod)
-        type_name = to_type_name(mod.name)
+        type_name = to_type_name(const_name(mod))
         super_class = if mod.superclass == ::Object
                         nil
-                      elsif mod.superclass.name.nil?
+                      elsif const_name(mod.superclass).nil?
                         RBS.logger.warn("Skipping anonymous superclass #{mod.superclass} of #{mod}")
                         nil
                       else
-                        AST::Declarations::Class::Super.new(name: to_type_name(mod.superclass.name), args: [])
+                        AST::Declarations::Class::Super.new(name: to_type_name(const_name(mod.superclass)), args: [], location: nil)
                       end
 
         decl = AST::Declarations::Class.new(
@@ -331,17 +352,7 @@ module RBS
           comment: nil
         )
 
-        each_mixin(mod.included_modules, *mod.superclass.included_modules, *mod.included_modules.flat_map(&:included_modules)) do |included_module|
-          unless included_module.name
-            RBS.logger.warn("Skipping anonymous module #{included_module} included in #{mod}")
-            next
-          end
-
-          module_name = to_type_name(included_module.name)
-          if module_name.namespace == type_name.namespace
-            module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
-          end
-
+        each_included_module(type_name, mod) do |module_name, _|
           decl.members << AST::Members::Include.new(
             name: module_name,
             args: [],
@@ -351,6 +362,16 @@ module RBS
           )
         end
 
+        each_included_module(type_name, mod.singleton_class) do |module_name, _|
+          decl.members << AST::Members::Extend.new(
+            name: module_name,
+            args: [],
+            location: nil,
+            comment: nil,
+            annotations: []
+          )
+        end
+
         generate_methods(mod, type_name, decl.members)
 
         @decls << decl
@@ -378,18 +399,7 @@ module RBS
           comment: nil
         )
 
-        each_mixin(mod.included_modules, *mod.included_modules.flat_map(&:included_modules), namespace: type_name.namespace) do |included_module|
-          included_module_name = const_name(included_module)
-          unless included_module_name
-            RBS.logger.warn("Skipping anonymous module #{included_module} included in #{mod}")
-            next
-          end
-
-          module_name = to_type_name(included_module_name)
-          if module_name.namespace == type_name.namespace
-            module_name = TypeName.new(name: module_name.name, namespace: Namespace.empty)
-          end
-
+        each_included_module(type_name, mod) do |module_name, _|
           decl.members << AST::Members::Include.new(
             name: module_name,
             args: [],
@@ -399,6 +409,16 @@ module RBS
           )
         end
 
+        each_included_module(type_name, mod.singleton_class) do |module_name, _|
+          decl.members << AST::Members::Extend.new(
+            name: module_name,
+            args: [],
+            location: nil,
+            comment: nil,
+            annotations: []
+          )
+        end
+
         generate_methods(mod, type_name, decl.members)
 
         @decls << decl

data/lib/rbs/substitution.rb

@@ -3,6 +3,10 @@ module RBS
     attr_reader :mapping
     attr_accessor :instance_type
 
+    def empty?
+      mapping.empty? && instance_type.nil?
+    end
+
     def initialize()
       @mapping = {}
     end

data/lib/rbs/test.rb

@@ -100,6 +100,8 @@ end
 
 unless ::Proc.instance_methods.include?(:ruby2_keywords)
   class Proc
-    def ruby2_keywords; end
+    def ruby2_keywords
+      self
+    end
   end
 end

data/lib/rbs/test/hook.rb

@@ -67,12 +67,19 @@ module RBS
         end
       end
 
-      def self.hook_method_source(prefix, method_name, key, random:)
+      def self.hook_method_source(prefix, method_name, key, random:, params:)
         with_name, without_name = alias_names(method_name, random)
         full_method_name = "#{prefix}#{method_name}"
 
+        param_source = params.take_while {|param| param[0] == :req }.map(&:last) + ["*rest_args_#{random}"]
+
+        RBS.logger.debug {
+          "Generating method definition: def #{with_name}(#{param_source.join(", ")}, &block) ..."
+        }
+
         [__LINE__ + 1, <<RUBY]
-def #{with_name}(*args, &block)
+def #{with_name}(#{param_source.join(", ")}, &block)
+  args = [#{param_source.join(", ")}]
   ::RBS.logger.debug { "#{full_method_name} with arguments: [" + args.map(&:inspect).join(", ") + "]" }
 
   begin
@@ -81,13 +88,18 @@ def #{with_name}(*args, &block)
 
     if block_given?
       receiver = self
+      block_receives_block = block.parameters.last&.yield_self {|type, _| type == :block }
 
-      wrapped_block = proc do |*block_args|
+      wrapped_block = proc do |*block_args, &block2|
         return_from_block = false
 
         begin
           block_result = if receiver.equal?(self)
-                           yield(*block_args)
+                           if block_receives_block
+                             block.call(*block_args, &block2)
+                           else
+                             yield(*block_args)
+                           end
                          else
                            instance_exec(*block_args, &block)
                          end
@@ -166,7 +178,8 @@ RUBY
 
       def self.hook_instance_method(klass, method, key:)
         random = SecureRandom.hex(4)
-        line, source = hook_method_source("#{klass}#", method, key, random: random)
+        params = klass.instance_method(method).parameters
+        line, source = hook_method_source("#{klass}#", method, key, random: random, params: params)
 
         klass.module_eval(source, __FILE__, line)
         setup_alias_method_chain klass, method, random: random
@@ -174,7 +187,8 @@ RUBY
 
       def self.hook_singleton_method(klass, method, key:)
         random = SecureRandom.hex(4)
-        line, source = hook_method_source("#{klass}.",method, key, random: random)
+        params = klass.method(method).parameters
+        line, source = hook_method_source("#{klass}.",method, key, random: random, params: params)
 
         klass.singleton_class.module_eval(source, __FILE__, line)
         setup_alias_method_chain klass.singleton_class, method, random: random

data/lib/rbs/validator.rb

@@ -18,8 +18,9 @@ module RBS
     def validate_type(type, context:)
       case type
       when Types::ClassInstance, Types::Interface
+        # @type var type: Types::ClassInstance | Types::Interface
         if type.name.namespace.relative?
-          type = absolute_type(type, context: context) do |type|
+          type = _ = absolute_type(type, context: context) do |_|
             NoTypeFoundError.check!(type.name.absolute!, env: env, location: type.location)
           end
         end
@@ -43,7 +44,8 @@ module RBS
         )
 
       when Types::Alias, Types::ClassSingleton
-        type = absolute_type(type, context: context) { type.name.absolute! }
+        # @type var type: Types::Alias | Types::ClassSingleton
+        type = _ = absolute_type(type, context: context) { type.name.absolute! }
         NoTypeFoundError.check!(type.name, env: env, location: type.location)
       end
 

data/lib/rbs/variance_calculator.rb

@@ -86,7 +86,11 @@ module RBS
     end
 
     def in_inherit(name:, args:, variables:)
-      type = Types::ClassInstance.new(name: name, args: args, location: nil)
+      type = if name.class?
+               Types::ClassInstance.new(name: name, args: args, location: nil)
+             else
+               Types::Interface.new(name: name, args: args, location: nil)
+             end
 
       Result.new(variables: variables).tap do |result|
         type(type, result: result, context: :covariant)

data/lib/rbs/version.rb

@@ -1,3 +1,3 @@
 module RBS
-  VERSION = "0.20.1"
+  VERSION = "1.0.0.pre"
 end

data/sig/definition.rbs

@@ -65,10 +65,15 @@ module RBS
       type t = Instance | Singleton
 
       class Instance
+        type source = :super | nil
+                    | AST::Members::Include | AST::Members::Extend | AST::Members::Prepend
+                    | AST::Declarations::Module::Self
+
         attr_reader name: TypeName
         attr_reader args: Array[Types::t]
+        attr_reader source: source
 
-        def initialize: (name: TypeName, args: Array[Types::t]) -> void
+        def initialize: (name: TypeName, args: Array[Types::t], source: source) -> void
       end
 
       class Singleton

data/sig/errors.rbs

@@ -0,0 +1,20 @@
+module RBS
+  interface _Kinded
+    def kind: () -> (:instance | :singleton)
+  end
+
+  module MethodNameHelper : _Kinded
+    def method_name_string: () -> String
+  end
+
+  class InvalidTypeApplicationError < StandardError
+    attr_reader type_name: TypeName
+    attr_reader args: Array[Types::t]
+    attr_reader params: Array[Symbol]
+    attr_reader location: Location?
+
+    def initialize: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location?) -> void
+
+    def self.check!: (type_name: TypeName, args: Array[Types::t], params: Array[Symbol], location: Location?) -> void
+  end
+end

data/sig/type_name_resolver.rbs

@@ -1,10 +1,12 @@
 module RBS
   class TypeNameResolver
+    type context = Array[Namespace]
+
     class Query
       attr_reader type_name: TypeName
       attr_reader context: Array[Namespace]
 
-      def initialize: (type_name: TypeName, context: Array[Namespace]) -> void
+      def initialize: (type_name: TypeName, context: context) -> void
     end
 
     attr_reader all_names: Set[TypeName]
@@ -15,7 +17,7 @@ module RBS
 
     def add_names: (Array[TypeName]) -> self
 
-    def resolve: (TypeName, context: Array[Namespace]) -> TypeName?
+    def resolve: (TypeName, context: context) -> TypeName?
 
     def has_name?: (TypeName) -> TypeName?
 

data/sig/validator.rbs

@@ -0,0 +1,12 @@
+module RBS
+  class Validator
+    attr_reader env: Environment
+    attr_reader resolver: TypeNameResolver
+
+    def initialize: (env: Environment, resolver: TypeNameResolver) -> void
+
+    def absolute_type: (Types::t, context: TypeNameResolver::context) { (Types::t) -> TypeName } -> Types::t
+
+    def validate_type: (Types::t, context: TypeNameResolver::context) -> void
+  end
+end

data/stdlib/logger/0/log_device.rbs

@@ -1,7 +1,6 @@
 class Logger
   class LogDevice
-    # TODO: Write type signature for MonitorMixin
-    # include MonitorMixin
+    include MonitorMixin
 
     include Period
 

data/stdlib/time/0/time.rbs

@@ -0,0 +1,327 @@
+class Time
+  interface _TimeLike
+    def year: () -> Integer
+    def mon: () -> Integer
+    def day: () -> Integer
+  end
+
+  #
+  # Return the number of seconds the specified time zone differs
+  # from UTC.
+  #
+  # Numeric time zones that include minutes, such as
+  # <code>-10:00</code> or <code>+1330</code> will work, as will
+  # simpler hour-only time zones like <code>-10</code> or
+  # <code>+13</code>.
+  #
+  # Textual time zones listed in ZoneOffset are also supported.
+  #
+  # If the time zone does not match any of the above, +zone_offset+
+  # will check if the local time zone (both with and without
+  # potential Daylight Saving \Time changes being in effect) matches
+  # +zone+. Specifying a value for +year+ will change the year used
+  # to find the local time zone.
+  #
+  # If +zone_offset+ is unable to determine the offset, nil will be
+  # returned.
+  #
+  #     require 'time'
+  #
+  #     Time.zone_offset("EST") #=> -18000
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.zone_offset: (String zone, ?Integer year) -> Integer
+
+  #
+  # Takes a string representation of a Time and attempts to parse it
+  # using a heuristic.
+  #
+  #     require 'time'
+  #
+  #     Time.parse("2010-10-31") #=> 2010-10-31 00:00:00 -0500
+  #
+  # Any missing pieces of the date are inferred based on the current date.
+  #
+  #     require 'time'
+  #
+  #     # assuming the current date is "2011-10-31"
+  #     Time.parse("12:00") #=> 2011-10-31 12:00:00 -0500
+  #
+  # We can change the date used to infer our missing elements by passing a second
+  # object that responds to #mon, #day and #year, such as Date, Time or DateTime.
+  # We can also use our own object.
+  #
+  #     require 'time'
+  #
+  #     class MyDate
+  #       attr_reader :mon, :day, :year
+  #
+  #       def initialize(mon, day, year)
+  #         @mon, @day, @year = mon, day, year
+  #       end
+  #     end
+  #
+  #     d  = Date.parse("2010-10-28")
+  #     t  = Time.parse("2010-10-29")
+  #     dt = DateTime.parse("2010-10-30")
+  #     md = MyDate.new(10,31,2010)
+  #
+  #     Time.parse("12:00", d)  #=> 2010-10-28 12:00:00 -0500
+  #     Time.parse("12:00", t)  #=> 2010-10-29 12:00:00 -0500
+  #     Time.parse("12:00", dt) #=> 2010-10-30 12:00:00 -0500
+  #     Time.parse("12:00", md) #=> 2010-10-31 12:00:00 -0500
+  #
+  # If a block is given, the year described in +date+ is converted
+  # by the block.  This is specifically designed for handling two
+  # digit years. For example, if you wanted to treat all two digit
+  # years prior to 70 as the year 2000+ you could write this:
+  #
+  #     require 'time'
+  #
+  #     Time.parse("01-10-31") {|year| year + (year < 70 ? 2000 : 1900)}
+  #     #=> 2001-10-31 00:00:00 -0500
+  #     Time.parse("70-10-31") {|year| year + (year < 70 ? 2000 : 1900)}
+  #     #=> 1970-10-31 00:00:00 -0500
+  #
+  # If the upper components of the given time are broken or missing, they are
+  # supplied with those of +now+.  For the lower components, the minimum
+  # values (1 or 0) are assumed if broken or missing.  For example:
+  #
+  #     require 'time'
+  #
+  #     # Suppose it is "Thu Nov 29 14:33:20 2001" now and
+  #     # your time zone is EST which is GMT-5.
+  #     now = Time.parse("Thu Nov 29 14:33:20 2001")
+  #     Time.parse("16:30", now)     #=> 2001-11-29 16:30:00 -0500
+  #     Time.parse("7/23", now)      #=> 2001-07-23 00:00:00 -0500
+  #     Time.parse("Aug 31", now)    #=> 2001-08-31 00:00:00 -0500
+  #     Time.parse("Aug 2000", now)  #=> 2000-08-01 00:00:00 -0500
+  #
+  # Since there are numerous conflicts among locally defined time zone
+  # abbreviations all over the world, this method is not intended to
+  # understand all of them.  For example, the abbreviation "CST" is
+  # used variously as:
+  #
+  #     -06:00 in America/Chicago,
+  #     -05:00 in America/Havana,
+  #     +08:00 in Asia/Harbin,
+  #     +09:30 in Australia/Darwin,
+  #     +10:30 in Australia/Adelaide,
+  #     etc.
+  #
+  # Based on this fact, this method only understands the time zone
+  # abbreviations described in RFC 822 and the system time zone, in the
+  # order named. (i.e. a definition in RFC 822 overrides the system
+  # time zone definition.)  The system time zone is taken from
+  # <tt>Time.local(year, 1, 1).zone</tt> and
+  # <tt>Time.local(year, 7, 1).zone</tt>.
+  # If the extracted time zone abbreviation does not match any of them,
+  # it is ignored and the given time is regarded as a local time.
+  #
+  # ArgumentError is raised if Date._parse cannot extract information from
+  # +date+ or if the Time class cannot represent specified date.
+  #
+  # This method can be used as a fail-safe for other parsing methods as:
+  #
+  #   Time.rfc2822(date) rescue Time.parse(date)
+  #   Time.httpdate(date) rescue Time.parse(date)
+  #   Time.xmlschema(date) rescue Time.parse(date)
+  #
+  # A failure of Time.parse should be checked, though.
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.parse: (String date, ?_TimeLike now) ?{ (Integer) -> Integer } -> Time
+
+  #
+  # Works similar to +parse+ except that instead of using a
+  # heuristic to detect the format of the input string, you provide
+  # a second argument that describes the format of the string.
+  #
+  # If a block is given, the year described in +date+ is converted by the
+  # block.  For example:
+  #
+  #   Time.strptime(...) {|y| y < 100 ? (y >= 69 ? y + 1900 : y + 2000) : y}
+  #
+  # Below is a list of the formatting options:
+  #
+  # %a :: The abbreviated weekday name ("Sun")
+  # %A :: The  full  weekday  name ("Sunday")
+  # %b :: The abbreviated month name ("Jan")
+  # %B :: The  full  month  name ("January")
+  # %c :: The preferred local date and time representation
+  # %C :: Century (20 in 2009)
+  # %d :: Day of the month (01..31)
+  # %D :: Date (%m/%d/%y)
+  # %e :: Day of the month, blank-padded ( 1..31)
+  # %F :: Equivalent to %Y-%m-%d (the ISO 8601 date format)
+  # %g :: The last two digits of the commercial year
+  # %G :: The week-based year according to ISO-8601 (week 1 starts on Monday
+  #       and includes January 4)
+  # %h :: Equivalent to %b
+  # %H :: Hour of the day, 24-hour clock (00..23)
+  # %I :: Hour of the day, 12-hour clock (01..12)
+  # %j :: Day of the year (001..366)
+  # %k :: hour, 24-hour clock, blank-padded ( 0..23)
+  # %l :: hour, 12-hour clock, blank-padded ( 0..12)
+  # %L :: Millisecond of the second (000..999)
+  # %m :: Month of the year (01..12)
+  # %M :: Minute of the hour (00..59)
+  # %n :: Newline (\n)
+  # %N :: Fractional seconds digits
+  # %p :: Meridian indicator ("AM" or "PM")
+  # %P :: Meridian indicator ("am" or "pm")
+  # %r :: time, 12-hour (same as %I:%M:%S %p)
+  # %R :: time, 24-hour (%H:%M)
+  # %s :: Number of seconds since 1970-01-01 00:00:00 UTC.
+  # %S :: Second of the minute (00..60)
+  # %t :: Tab character (\t)
+  # %T :: time, 24-hour (%H:%M:%S)
+  # %u :: Day of the week as a decimal, Monday being 1. (1..7)
+  # %U :: Week number of the current year, starting with the first Sunday as
+  #       the first day of the first week (00..53)
+  # %v :: VMS date (%e-%b-%Y)
+  # %V :: Week number of year according to ISO 8601 (01..53)
+  # %W :: Week  number  of the current year, starting with the first Monday
+  #       as the first day of the first week (00..53)
+  # %w :: Day of the week (Sunday is 0, 0..6)
+  # %x :: Preferred representation for the date alone, no time
+  # %X :: Preferred representation for the time alone, no date
+  # %y :: Year without a century (00..99)
+  # %Y :: Year which may include century, if provided
+  # %z :: Time zone as  hour offset from UTC (e.g. +0900)
+  # %Z :: Time zone name
+  # %% :: Literal "%" character
+  # %+ :: date(1) (%a %b %e %H:%M:%S %Z %Y)
+  #
+  #     require 'time'
+  #
+  #     Time.strptime("2000-10-31", "%Y-%m-%d") #=> 2000-10-31 00:00:00 -0500
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.strptime: (String date, String format, ?_TimeLike now) ?{ (Integer) -> Integer } -> Time
+
+  #
+  # Parses +date+ as date-time defined by RFC 2822 and converts it to a Time
+  # object.  The format is identical to the date format defined by RFC 822 and
+  # updated by RFC 1123.
+  #
+  # ArgumentError is raised if +date+ is not compliant with RFC 2822
+  # or if the Time class cannot represent specified date.
+  #
+  # See #rfc2822 for more information on this format.
+  #
+  #     require 'time'
+  #
+  #     Time.rfc2822("Wed, 05 Oct 2011 22:26:12 -0400")
+  #     #=> 2010-10-05 22:26:12 -0400
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.rfc2822: (String date) -> Time
+
+  alias self.rfc822 self.rfc2822
+
+  #
+  # Parses +date+ as an HTTP-date defined by RFC 2616 and converts it to a
+  # Time object.
+  #
+  # ArgumentError is raised if +date+ is not compliant with RFC 2616 or if
+  # the Time class cannot represent specified date.
+  #
+  # See #httpdate for more information on this format.
+  #
+  #     require 'time'
+  #
+  #     Time.httpdate("Thu, 06 Oct 2011 02:26:12 GMT")
+  #     #=> 2011-10-06 02:26:12 UTC
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.httpdate: (String date) -> Time
+
+  #
+  # Parses +date+ as a dateTime defined by the XML Schema and converts it to
+  # a Time object.  The format is a restricted version of the format defined
+  # by ISO 8601.
+  #
+  # ArgumentError is raised if +date+ is not compliant with the format or if
+  # the Time class cannot represent specified date.
+  #
+  # See #xmlschema for more information on this format.
+  #
+  #     require 'time'
+  #
+  #     Time.xmlschema("2011-10-05T22:26:12-04:00")
+  #     #=> 2011-10-05 22:26:12-04:00
+  #
+  # You must require 'time' to use this method.
+  #
+  def self.xmlschema: (String date) -> Time
+
+  alias self.iso8601 self.xmlschema
+
+  #
+  # Returns a string which represents the time as date-time defined by RFC 2822:
+  #
+  #   day-of-week, DD month-name CCYY hh:mm:ss zone
+  #
+  # where zone is [+-]hhmm.
+  #
+  # If +self+ is a UTC time, -0000 is used as zone.
+  #
+  #     require 'time'
+  #
+  #     t = Time.now
+  #     t.rfc2822  # => "Wed, 05 Oct 2011 22:26:12 -0400"
+  #
+  # You must require 'time' to use this method.
+  #
+  def rfc2822: () -> String
+
+  alias rfc822 rfc2822
+
+  #
+  # Returns a string which represents the time as RFC 1123 date of HTTP-date
+  # defined by RFC 2616:
+  #
+  #   day-of-week, DD month-name CCYY hh:mm:ss GMT
+  #
+  # Note that the result is always UTC (GMT).
+  #
+  #     require 'time'
+  #
+  #     t = Time.now
+  #     t.httpdate # => "Thu, 06 Oct 2011 02:26:12 GMT"
+  #
+  # You must require 'time' to use this method.
+  #
+  def httpdate: () -> String
+
+  #
+  # Returns a string which represents the time as a dateTime defined by XML
+  # Schema:
+  #
+  #   CCYY-MM-DDThh:mm:ssTZD
+  #   CCYY-MM-DDThh:mm:ss.sssTZD
+  #
+  # where TZD is Z or [+-]hh:mm.
+  #
+  # If self is a UTC time, Z is used as TZD.  [+-]hh:mm is used otherwise.
+  #
+  # +fractional_digits+ specifies a number of digits to use for fractional
+  # seconds.  Its default value is 0.
+  #
+  #     require 'time'
+  #
+  #     t = Time.now
+  #     t.iso8601  # => "2011-10-05T22:26:12-04:00"
+  #
+  # You must require 'time' to use this method.
+  #
+  def xmlschema: (?Integer fraction_digits) -> String
+
+  alias iso8601 xmlschema
+end