sord 0.7.1 → 0.8.0

data/lib/sord/resolver.rb

@@ -0,0 +1,82 @@
+require 'stringio'
+
+module Sord
+  module Resolver
+    # @return [void]
+    def self.prepare
+      # Construct a hash of class names to full paths
+      @@names_to_paths ||= YARD::Registry.all(:class)
+        .group_by(&:name)
+        .map { |k, v| [k.to_s, v.map(&:path)] }
+        .to_h
+        .merge(builtin_classes.map { |x| [x, [x]] }.to_h) do |k, a, b|
+          a | b
+        end
+    end
+
+    # @return [void]
+    def self.clear
+      @@names_to_paths = nil
+    end
+
+    # @param [String] name
+    # @return [Array<String>]
+    def self.paths_for(name)
+      prepare
+      (@@names_to_paths[name.split('::').last] || [])
+        .select { |x| x.end_with?(name) }
+    end
+
+    # @param [String] name
+    # @return [String, nil]
+    def self.path_for(name)
+      paths_for(name).one? ? paths_for(name).first : nil
+    end
+
+    # @return [Array<String>]
+    def self.builtin_classes
+      # This prints some deprecation warnings, so suppress them
+      prev_stderr = $stderr
+      $stderr = StringIO.new
+
+      Object.constants
+        .select { |x| Object.const_get(x).is_a?(Class) }
+        .map(&:to_s)
+    ensure
+      $stderr = prev_stderr
+    end
+
+    # @param [String] name
+    # @param [Object] item
+    # @return [Boolean]
+    def self.resolvable?(name, item)
+      name_parts = name.split('::')
+
+      current_context = item
+      current_context = current_context.parent \
+        until current_context.is_a?(YARD::CodeObjects::NamespaceObject)
+
+      matching_paths = []
+
+      loop do
+        # Try to find that class in this context
+        path_followed_context = current_context
+        name_parts.each do |name_part|
+          path_followed_context = path_followed_context&.child(
+            name: name_part, type: [:class, :method, :module]
+          )
+        end
+
+        # Return true if we found the constant we're looking for here
+        matching_paths |= [path_followed_context.path] if path_followed_context
+
+        # Move up one context
+        break if current_context.root?
+        current_context = current_context.parent
+      end
+
+      return (builtin_classes.include?(name) && matching_paths.empty?) ||
+        (matching_paths.one? && !builtin_classes.include?(name))
+    end
+  end
+end

data/lib/sord/type_converter.rb

@@ -1,5 +1,6 @@
 require 'yaml'
 require 'sord/logging'
+require 'sord/resolver'
 
 module Sord
   # Contains methods to convert YARD types to Sorbet types.
@@ -21,14 +22,22 @@ module Sord
     # Match duck types which require the object implement one or more methods,
     # like '#foo', '#foo & #bar', '#foo&#bar&#baz', and '#foo&#bar&#baz&#foo_bar'.
     DUCK_TYPE_REGEX =
-      /^\##{SIMPLE_TYPE_REGEX}(?:( ?\& ?\#)*[a-zA-Z_][a-zA-Z_0-9]*)*$/
+      /^\#[a-zA-Z_][\w]*(?:[a-zA-Z_][\w=]*)*(?:( ?\& ?\#)*[a-zA-Z_][\w=]*)*$/
     
     # A regular expression which matches ordered lists in the format of
     # either "Array(String, Symbol)" or "(String, Symbol)".
     ORDERED_LIST_REGEX = /^(?:Array|)\((.*)\s*\)$/
 
+    # A regular expression which matches the shorthand Hash syntax, 
+    # "{String => Symbol}".
+    SHORTHAND_HASH_SYNTAX = /^{\s*(.*)\s*}$/
+
+    # A regular expression which matches the shorthand Array syntax, 
+    # "<String>".
+    SHORTHAND_ARRAY_SYNTAX = /^<\s*(.*)\s*>$/
+
     # An array of built-in generic types supported by Sorbet.
-    SORBET_SUPPORTED_GENERIC_TYPES = %w{Array Set Enumerable Enumerator Range Hash}
+    SORBET_SUPPORTED_GENERIC_TYPES = %w{Array Set Enumerable Enumerator Range Hash Class}
     SORBET_SINGLE_ARG_GENERIC_TYPES = %w{Array Set Enumerable Enumerator Range}
 
     # Given a string of YARD type parameters (without angle brackets), splits
@@ -85,7 +94,11 @@ module Sord
     # @param [YARD::CodeObjects::Base] item The CodeObject which the YARD type
     #   is associated with. This is used for logging and can be nil, but this
     #   will lead to less informative log messages.
-    def self.yard_to_sorbet(yard, item=nil)
+    # @param [Integer] indent_level 
+    # @param [Boolean] replace_errors_with_untyped If true, T.untyped is used
+    #   instead of SORD_ERROR_ constants for unknown types.
+    # @return [String]
+    def self.yard_to_sorbet(yard, item = nil, indent_level = 0, replace_errors_with_untyped = false)
       case yard
       when nil # Type not specified
         "T.untyped"
@@ -98,7 +111,7 @@ module Sord
         # selection of any of the types
         types = yard
           .reject { |x| x == 'nil' }
-          .map { |x| yard_to_sorbet(x, item) }
+          .map { |x| yard_to_sorbet(x, item, indent_level, replace_errors_with_untyped) }
           .uniq
         result = types.length == 1 ? types.first : "T.any(#{types.join(', ')})"
         result = "T.nilable(#{result})" if yard.include?('nil')
@@ -106,11 +119,26 @@ module Sord
       when /^#{SIMPLE_TYPE_REGEX}$/
         # If this doesn't begin with an uppercase letter, warn
         if /^[_a-z]/ === yard
-          Logging.warn("#{yard} is probably not a type, but using anyway", item)
+          Logging.warn("#{yard} is probably not a type, but using anyway", item, indent_level)
+        end
+
+        # Check if whatever has been specified is actually resolvable; if not,
+        # do some inference to replace it
+        if item && !Resolver.resolvable?(yard, item)
+          if Resolver.path_for(yard)
+            new_path = Resolver.path_for(yard)
+            Logging.infer("#{yard} was resolved to #{new_path}", item, indent_level) \
+              unless yard == new_path
+            new_path
+          else
+            Logging.warn("#{yard} wasn't able to be resolved to a constant in this project", item, indent_level)
+            yard
+          end
+        else
+          yard
         end
-        yard
       when DUCK_TYPE_REGEX
-        Logging.duck("#{yard} looks like a duck type, replacing with T.untyped", item)
+        Logging.duck("#{yard} looks like a duck type, replacing with T.untyped", item, indent_level)
         'T.untyped'
       when /^#{GENERIC_TYPE_REGEX}$/
         generic_type = $1
@@ -118,31 +146,45 @@ module Sord
 
         if SORBET_SUPPORTED_GENERIC_TYPES.include?(generic_type)
           parameters = split_type_parameters(type_parameters)
-            .map { |x| yard_to_sorbet(x, item) }
+            .map { |x| yard_to_sorbet(x, item, indent_level, replace_errors_with_untyped) }
           if SORBET_SINGLE_ARG_GENERIC_TYPES.include?(generic_type) && parameters.length > 1
             "T::#{generic_type}[T.any(#{parameters.join(', ')})]"
+          elsif generic_type == 'Class' && parameters.length == 1
+            "T.class_of(#{parameters.first})"
           else
             "T::#{generic_type}[#{parameters.join(', ')}]"
           end
         else
-          Logging.warn("unsupported generic type #{generic_type.inspect} in #{yard.inspect}", item)
-          "SORD_ERROR_#{generic_type.gsub(/[^0-9A-Za-z_]/i, '')}"
+          Logging.warn("unsupported generic type #{generic_type.inspect} in #{yard.inspect}", item, indent_level)
+          replace_errors_with_untyped ? "T.untyped" : "SORD_ERROR_#{generic_type.gsub(/[^0-9A-Za-z_]/i, '')}"
         end
       # Converts ordered lists like Array(Symbol, String) or (Symbol, String)
       # into Sorbet Tuples like [Symbol, String].
       when ORDERED_LIST_REGEX
         type_parameters = $1
         parameters = split_type_parameters(type_parameters)
-          .map { |x| yard_to_sorbet(x, item) }
+          .map { |x| yard_to_sorbet(x, item, indent_level, replace_errors_with_untyped) }
         "[#{parameters.join(', ')}]"
+      when SHORTHAND_HASH_SYNTAX
+        type_parameters = $1
+        parameters = split_type_parameters(type_parameters)
+          .map { |x| yard_to_sorbet(x, item, indent_level, replace_errors_with_untyped) }
+        "T::Hash<#{parameters.join(', ')}>"
+      when SHORTHAND_ARRAY_SYNTAX
+        type_parameters = $1
+        parameters = split_type_parameters(type_parameters)
+          .map { |x| yard_to_sorbet(x, item, indent_level, replace_errors_with_untyped) }
+        parameters.one? \
+          ? "T::Array<#{parameters.first}>"
+          : "T::Array<T.any(#{parameters.join(', ')})>"
       else
         # Check for literals
         from_yaml = YAML.load(yard) rescue nil
         return from_yaml.class.to_s \
           if [Symbol, Float, Integer].include?(from_yaml.class)
 
-        Logging.warn("#{yard.inspect} does not appear to be a type", item)
-        "SORD_ERROR_#{yard.gsub(/[^0-9A-Za-z_]/i, '')}"
+        Logging.warn("#{yard.inspect} does not appear to be a type", item, indent_level)
+        replace_errors_with_untyped ? "T.untyped" : "SORD_ERROR_#{yard.gsub(/[^0-9A-Za-z_]/i, '')}"
       end
     end
   end

data/lib/sord/version.rb

@@ -1,4 +1,4 @@
 # typed: strong
 module Sord
-  VERSION = '0.7.1'
+  VERSION = '0.8.0'
 end

data/rbi/sord.rbi

@@ -0,0 +1,165 @@
+# typed: strong
+module Sord
+  module Logging
+    sig { returns(T::Array[Proc]) }
+    def self.hooks(); end
+
+    sig { returns(T::Boolean) }
+    def self.silent?(); end
+
+    sig { params(value: T::Boolean).void }
+    def self.silent=(value); end
+
+    sig { params(value: T::Array[Symbol]).void }
+    def self.enabled_types=(value); end
+
+    sig { returns(T::Array[Symbol]) }
+    def self.enabled_types(); end
+
+    sig { params(value: T::Array[Symbol]).void }
+    def self.valid_types?(value); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig do
+      params(
+        kind: Symbol,
+        header: String,
+        msg: String,
+        item: YARD::CodeObjects::Base,
+        indent_level: Integer
+      ).void
+    end
+    def self.generic(kind, header, msg, item, indent_level = 0); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
+    def self.warn(msg, item = nil, indent_level = 0); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
+    def self.info(msg, item = nil, indent_level = 0); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
+    def self.duck(msg, item = nil, indent_level = 0); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
+    def self.error(msg, item = nil, indent_level = 0); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
+    def self.infer(msg, item = nil, indent_level = 0); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
+    def self.omit(msg, item = nil, indent_level = 0); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig { params(msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void }
+    def self.done(msg, item = nil, indent_level = 0); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig do
+      params(
+        kind: Symbol,
+        msg: String,
+        item: YARD::CodeObjects::Base,
+        indent_level: Integer
+      ).void
+    end
+    def self.invoke_hooks(kind, msg, item, indent_level = 0); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig { params(blk: T.proc.params(kind: Symbol, msg: String, item: YARD::CodeObjects::Base, indent_level: Integer).void).void }
+    def self.add_hook(&blk); end
+  end
+
+  module Resolver
+    sig { void }
+    def self.prepare(); end
+
+    sig { void }
+    def self.clear(); end
+
+    sig { params(name: String).returns(T::Array[String]) }
+    def self.paths_for(name); end
+
+    sig { params(name: String).returns(T.nilable(String)) }
+    def self.path_for(name); end
+
+    sig { returns(T::Array[String]) }
+    def self.builtin_classes(); end
+
+    sig { params(name: String, item: Object).returns(T::Boolean) }
+    def self.resolvable?(name, item); end
+  end
+
+  class RbiGenerator
+    sig { returns(T::Array[String]) }
+    def rbi_contents(); end
+
+    sig { returns(Integer) }
+    def object_count(); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig { returns(T::Array[[String, YARD::CodeObjects::Base, Integer]]) }
+    def warnings(); end
+
+    sig { returns(T::Boolean) }
+    def next_item_is_first_in_namespace(); end
+
+    # sord infer - inferred type of parameter "value" as T::Boolean using getter's return type
+    sig { params(value: T::Boolean).returns(T::Boolean) }
+    def next_item_is_first_in_namespace=(value); end
+
+    sig { params(options: Hash).void }
+    def initialize(options); end
+
+    sig { void }
+    def count_namespace(); end
+
+    sig { void }
+    def count_method(); end
+
+    sig { void }
+    def add_blank(); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig { params(item: YARD::CodeObjects::Base, indent_level: Integer).returns(Integer) }
+    def add_mixins(item, indent_level); end
+
+    sig { params(params: T::Array[String], returns: String, indent_level: Integer).void }
+    def add_signature(params, returns, indent_level); end
+
+    # sord warn - YARD::CodeObjects::NamespaceObject wasn't able to be resolved to a constant in this project
+    sig { params(item: YARD::CodeObjects::NamespaceObject, indent_level: Integer).void }
+    def add_methods(item, indent_level); end
+
+    # sord warn - YARD::CodeObjects::NamespaceObject wasn't able to be resolved to a constant in this project
+    sig { params(item: YARD::CodeObjects::NamespaceObject, indent_level: Integer).void }
+    def add_namespace(item, indent_level = 0); end
+
+    sig { returns(String) }
+    def generate(); end
+
+    sig { params(filename: T.nilable(String)).void }
+    def run(filename); end
+  end
+
+  module TypeConverter
+    sig { params(params: String).returns(T::Array[String]) }
+    def self.split_type_parameters(params); end
+
+    # sord warn - YARD::CodeObjects::Base wasn't able to be resolved to a constant in this project
+    sig do
+      params(
+        yard: T.any(T::Boolean, Array, String),
+        item: YARD::CodeObjects::Base,
+        indent_level: Integer,
+        replace_errors_with_untyped: T::Boolean
+      ).returns(String)
+    end
+    def self.yard_to_sorbet(yard, item = nil, indent_level = 0, replace_errors_with_untyped = false); end
+  end
+end

data/sorbet/config

@@ -1,2 +0,0 @@
---dir
-.

data/sorbet/rbi/gems/colorize.rbi

@@ -0,0 +1,81 @@
+# This file is autogenerated. Do not edit it by hand. Regenerate it with:
+#   srb rbi gems
+
+# typed: true
+#
+# If you would like to make changes to this file, great! Please create the gem's shim here:
+#
+#   https://github.com/sorbet/sorbet-typed/new/master?filename=lib/colorize/all/colorize.rbi
+#
+# colorize-0.8.1
+module Colorize
+end
+module Colorize::ClassMethods
+  def color_codes; end
+  def color_matrix(_ = nil); end
+  def color_methods; end
+  def color_samples; end
+  def colors; end
+  def disable_colorization(value = nil); end
+  def disable_colorization=(value); end
+  def mode_codes; end
+  def modes; end
+  def modes_methods; end
+end
+module Colorize::InstanceMethods
+  def background_color(color); end
+  def color(color); end
+  def color_from_symbol(match, symbol); end
+  def colorize(params); end
+  def colorized?; end
+  def colors_from_hash(match, hash); end
+  def colors_from_params(match, params); end
+  def defaults_colors(match); end
+  def mode(mode); end
+  def require_windows_libs; end
+  def scan_for_colors; end
+  def split_colors(match); end
+  def uncolorize; end
+end
+class String
+  def black; end
+  def blink; end
+  def blue; end
+  def bold; end
+  def cyan; end
+  def green; end
+  def hide; end
+  def italic; end
+  def light_black; end
+  def light_blue; end
+  def light_cyan; end
+  def light_green; end
+  def light_magenta; end
+  def light_red; end
+  def light_white; end
+  def light_yellow; end
+  def magenta; end
+  def on_black; end
+  def on_blue; end
+  def on_cyan; end
+  def on_green; end
+  def on_light_black; end
+  def on_light_blue; end
+  def on_light_cyan; end
+  def on_light_green; end
+  def on_light_magenta; end
+  def on_light_red; end
+  def on_light_white; end
+  def on_light_yellow; end
+  def on_magenta; end
+  def on_red; end
+  def on_white; end
+  def on_yellow; end
+  def red; end
+  def swap; end
+  def underline; end
+  def white; end
+  def yellow; end
+  extend Colorize::ClassMethods
+  include Colorize::InstanceMethods
+end