sord 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5de7160886a2e2fd6df02d245102315d772029a951075d885a88ac253ed1ea0a
-  data.tar.gz: a14f5c19796cfd9033111c76ef144541a3dd9304d1421341fcb3fb9e9f1e65f3
+  metadata.gz: 2ea0cd169aa8fb78913ee6547177fcf31665bd776846f29652f3a1c156caf856
+  data.tar.gz: 9ac77d33766f851ffdaac0c3fe34e238a432e57ea8d4518ff1e095382ac9dc4a
 SHA512:
-  metadata.gz: 3ec7636f302c059c5a1fe826cfa077c786410b1d3378783feac63ce77a7600df516fc1f1794f869996d0aa64f13de2a42eceda806d7378efece157c0254a58a6
-  data.tar.gz: 208a0d864121ca13eeeb2c5713cd98768e4710dc9cf2bdacb9fd13471e97e2dc580f9b31530dee847b4de8e9d62072f1a1cef640c4f768f4537754058ad253c3
+  metadata.gz: 9ae4e4cfba74c8bfcdb7f91296d18f1aa4ccfd6545d407b8997df4516a181e5b4aa85277bbdef623aed16de060a3479a9c5b7c6b4b34658ae328dd62f9cba929
+  data.tar.gz: cba4988403819d61a068adb45105941951a172d96997258f92848b014e51f657d65dacd7963d27dd1b3803baf3c78cf5a3764593201954c47e4abc4ebe4b9c8c

data/.gitignore

@@ -10,3 +10,4 @@
 # rspec failure tracking
 .rspec_status
 .vscode/
+Gemfile.lock

data/CHANGELOG.md

@@ -0,0 +1,92 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [0.7.0]
+### Added
+- A warning message is now shown if the YARD registry has no objects. (#31)
+- Integer, Float and Symbol literals are now supported as types. (#26)
+- Add support for multi-method YARD duck types. (#38)
+- Namespaces are now indented properly. (#41)
+- Individual method and namespace counts are now shown, rather than just an overall object count. (#36)
+
+### Changed
+- Paths to log message items are now bold rather than white, so that they can be seen on white terminals. (#28)
+- Alias methods are now ignored. (#34)
+- Remove Gemfile.lock. (#33)
+- YARD is executed when Sord is executed. To disable this behaviour, use `--no-regenerate`. (#31)
+
+### Fixed
+- Resolved crash when a @return tag gave no type. (#35)
+
+## [0.6.0] - 2019-06-23
+### Added
+- Namespaces are now nested inside each other in the RBI file, fixing many constant scoping issues. (#25)
+
+### Changed
+- Move unfinished tasks from README to GitHub issues.
+
+### Fixed
+- Fix typo of 'duck' as 'ducl' (#24)
+
+## [0.5.0] - 2019-06-23
+### Added
+- Hash rocket syntax for hash types is now supported. (#18)
+- Arrays with multiple element types are handled correctly. (#21)
+
+### Fixed
+- Move a dependency from Gemfile to Gemspec for consistency. (#19)
+- Fix bug where splat-args (`*a`) were always called `args` in signatures. (#20)
+
+## [0.4.1] - 2019-06-22
+### Fixed
+- The changelog for this version is the same as 0.4.0, but resolving an issue where some changes were not published correctly to RubyGems.
+
+## [0.4.0] - 2019-06-22 [YANKED]
+### Added
+- Commander is now used for the CLI, which enables a `--help` switch.
+- Add a `--no-comments` switch for disabling comments in the RBI file.
+
+### Changed
+- Sord now exits as early as possible if no filename is specified. (#17)
+
+### Fixed
+- Remove & in block parameter names in signatures, fixing a syntax error in RBIs. (#16)
+
+## [0.3.0] - 2019-06-22
+### Added
+- `self` now resolves to a type in signatures.
+- `true` and `false` are now converted to `T::Boolean` in signatures.
+- If a `T.any` contains `nil`, it now instead wraps that part of the signature in a `T.nilable` instead.
+- Add GitHub issue templates.
+
+### Changed
+- `.vscode` is now git-ignored.
+- Method definitions now have a semicolon before the end for consistency with Sorbet's RBIs. (#6)
+- `params` is now omitted from signatures if a method has no parameters. (#4)
+
+### Fixed
+- Fix kwargs in signatures by removing the duplicate colon from their identifier. (#12)
+- Fix kwargs in definitions by not inserting an equal-to symbol for their defaults. (#11)
+
+## [0.2.1] - 2019-06-22
+### Fixed
+- Fix exception on launch due to forgetting to initialise a class variable. (#1)
+
+## [0.2.0] - 2019-06-22
+### Added
+- Add RSpec tests.
+- Add the Logging class with prettier output.
+- Generic types can now take more than one type parameter.
+- Add documentation for all classes.
+- Add a README.
+- Add Sorbet directory and typing mode comments (`srb init`).
+
+### Changed
+- Sord now requires a command-line argument to save the RBI to.
+
+## [0.1.0] 2019-06-21
+### Added
+- First release.
+

data/README.md

@@ -21,10 +21,12 @@ Sord has the following features:
 
 Install Sord with `gem install sord`.
 
+**NOTE**: You need to run `yard` before you generate the `.rbi` file or
+Sord won't have any information to work with.
+
 Sord is a command line tool. To use it, open a terminal in the root directory
-of your project, and run `yard` to generate a YARD registry if you haven't
-already. Then, invoke `sord`, passing a path of where you'd like to save your
-RBI to (this file will be overwritten):
+of your project and invoke `sord`, passing a path where you'd like to save your
+`.rbi` (this file will be overwritten):
 
 ```
 sord defs.rbi
@@ -34,6 +36,13 @@ Sord will print information about what it's inferred as it runs. It is best to
 fix any issues in the YARD documentation, as any edits made to the resulting
 RBI file will be replaced if you re-run Sord.
 
+### Flags
+
+Sord also takes some flags to alter the generated `.rbi` file:
+
+  - `--no-comments`: Generates the `.rbi` file without any comments about
+    warnings/inferences/errors.
+
 ## Example
 
 Say we have this file, called `test.rb`:
@@ -78,24 +87,24 @@ files! Note the `.rbi` file extension.) In doing this, Sord prints:
 The `test.rbi` file then contains a complete RBI file for `test.rb`:
 
 ```ruby
-# typed: true
+# typed: strong
 module Example
-end
-class Example::Person 
+class Person
   sig { params(name: String, age: Integer).returns(Example::Person) }
-  def initialize(name, age) end
-  sig { params().returns(String) }
-  def name() end
+  def initialize(name, age); end
+  sig { returns(String) }
+  def name(); end
   # sord infer - inferred type of parameter "value" as String using getter's return type
   sig { params(value: String).returns(String) }
-  def name=(value) end
-  sig { params().returns(Integer) }
-  def age() end
+  def name=(value); end
+  sig { returns(Integer) }
+  def age(); end
   # sord infer - inferred type of parameter "value" as Integer using getter's return type
   sig { params(value: Integer).returns(Integer) }
-  def age=(value) end
+  def age=(value); end
   sig { params(possible_names: T::Array[String], possible_ages: T::Array[Integer]).returns(Example::Person) }
-  def self.construct_randomly(possible_names, possible_ages) end
+  def self.construct_randomly(possible_names, possible_ages); end
+end
 end
 ```
 

data/exe/sord

@@ -10,16 +10,27 @@ default_command :gen
 command :gen do |c|
   c.syntax = 'sord gen <output-file> [options]'
   c.description = 'Generates an RBI file from this directory\'s YARD docs'
-  c.option '--[no-]comments', 'Disables informational/warning comments in the RBI file'
+  c.option '--[no-]comments', 'Controls informational/warning comments in the RBI file'
+  c.option '--[no-]regenerate', 'Controls whether YARD is executed before Sord runs'
 
   c.action do |args, options|
-    options.default comments: true
+    options.default comments: true, regenerate: true
 
     if args.length != 1
       Sord::Logging.error('Must specify filename')
       exit 1
     end
 
+    begin
+      Sord::Logging.info('Running YARD...')
+      `yard`
+    rescue Errno::ENOENT
+      Sord::Logging.error('The YARD tool could not be found on your PATH.')
+      Sord::Logging.error('You may need to run \'gem install yard\'.')
+      Sord::Logging.error('If documentation has already been generated, pass --no-regenerate to Sord.')
+      exit 1
+    end
+
     Sord::RbiGenerator.new(options).run(args.first)
   end
 end

data/lib/sord/logging.rb

@@ -7,6 +7,11 @@ module Sord
     # The callables should take three parameters: (kind, msg, item).
     @@hooks = []
 
+    # @return [Array<Proc>] The hooks registered on the logger.
+    def self.hooks
+      @@hooks
+    end
+
     # Whether log messages should be printed or not.
     @@silent = false
     
@@ -33,14 +38,15 @@ module Sord
     # @param [YARD::CodeObjects::Base] item The CodeObject which this log 
     #  is associated with, if any. This is shown before the log message if it is
     #  specified.
-    def self.generic(kind, header, msg, item)
+    # @param [Integer] indent_level The level at which to indent the code.
+    def self.generic(kind, header, msg, item, indent_level = 0)
       if item
-        puts "#{header} (#{item.path.light_white}) #{msg}" unless silent?
+        puts "#{header} (#{item.path.bold}) #{msg}" unless silent?
       else
         puts "#{header} #{msg}" unless silent?
       end
 
-      invoke_hooks(kind, msg, item)
+      invoke_hooks(kind, msg, item, indent_level)
     end
 
     # Print a warning message. This should be used for things which require the
@@ -49,8 +55,20 @@ module Sord
     # @param [YARD::CodeObjects::Base] item The CodeObject which this log 
     #  is associated with, if any. This is shown before the log message if it is
     #  specified.
-    def self.warn(msg, item=nil)
-      generic(:warn, '[WARN ]'.yellow, msg, item)
+    # @param [Integer] indent_level The level at which to indent the code.
+    def self.warn(msg, item = nil, indent_level = 0)
+      generic(:warn, '[WARN ]'.yellow, msg, item, indent_level)
+    end
+
+    # Print an info message. This should be used for generic informational
+    # messages which the user doesn't need to act on.
+    # @param [String] msg The log message to write.
+    # @param [YARD::CodeObjects::Base] item The CodeObject which this log 
+    #  is associated with, if any. This is shown before the log message if it is
+    #  specified.
+    # @param [Integer] indent_level The level at which to indent the code.
+    def self.info(msg, item = nil, indent_level = 0)
+      generic(:info, '[INFO ]', msg, item, indent_level)
     end
 
     # Print a duck-typing message. This should be used when the YARD 
@@ -60,8 +78,9 @@ module Sord
     # @param [YARD::CodeObjects::Base] item The CodeObject which this log 
     #  is associated with, if any. This is shown before the log message if it is
     #  specified.
-    def self.duck(msg, item=nil)
-      generic(:duck, '[DUCK ]'.cyan, msg, item)
+    # @param [Integer] indent_level The level at which to indent the code.
+    def self.duck(msg, item = nil, indent_level = 0)
+      generic(:duck, '[DUCK ]'.cyan, msg, item, indent_level)
     end
 
     # Print an error message. This should be used for things which require the
@@ -70,8 +89,9 @@ module Sord
     # @param [YARD::CodeObjects::Base] item The CodeObject which this log 
     #  is associated with, if any. This is shown before the log message if it is
     #  specified.
-    def self.error(msg, item=nil)
-      generic(:error, '[ERROR]'.red, msg, item)
+    # @param [Integer] indent_level The level at which to indent the code.
+    def self.error(msg, item = nil, indent_level = 0)
+      generic(:error, '[ERROR]'.red, msg, item, indent_level)
     end
 
     # Print an infer message. This should be used when the user should be told
@@ -81,8 +101,9 @@ module Sord
     # @param [YARD::CodeObjects::Base] item The CodeObject which this log 
     #  is associated with, if any. This is shown before the log message if it is
     #  specified.
-    def self.infer(msg, item=nil)
-      generic(:infer, '[INFER]'.light_blue, msg, item)
+    # @param [Integer] indent_level The level at which to indent the code.
+    def self.infer(msg, item = nil, indent_level = 0)
+      generic(:infer, '[INFER]'.light_blue, msg, item, indent_level)
     end
 
     # Print an omit message. This should be used as a special type of warning
@@ -92,8 +113,9 @@ module Sord
     # @param [YARD::CodeObjects::Base] item The CodeObject which this log 
     #  is associated with, if any. This is shown before the log message if it is
     #  specified.
-    def self.omit(msg, item=nil)
-      generic(:omit, '[OMIT ]'.magenta, msg, item)
+    # @param [Integer] indent_level The level at which to indent the code.
+    def self.omit(msg, item = nil, indent_level = 0)
+      generic(:omit, '[OMIT ]'.magenta, msg, item, indent_level)
     end
 
     # Print a done message. This should be used when a process completes
@@ -101,7 +123,8 @@ module Sord
     # @param [YARD::CodeObjects::Base] item The CodeObject which this log 
     #  is associated with, if any. This is shown before the log message if it is
     #  specified.
-    def self.done(msg, item=nil)
+    # @param [Integer] indent_level The level at which to indent the code.
+    def self.done(msg, item = nil, indent_level = 0)
       generic(:done, '[DONE ]'.green, msg, item)
     end
 
@@ -111,9 +134,10 @@ module Sord
     # @param [YARD::CodeObjects::Base] item The CodeObject which this log 
     #  is associated with, if any. This is shown before the log message if it is
     #  specified.
-    def self.invoke_hooks(kind, msg, item)
+    # @param [Integer] indent_level The level at which to indent the code.
+    def self.invoke_hooks(kind, msg, item, indent_level = 0)
       @@hooks.each do |hook|
-        hook.(kind, msg, item) rescue nil
+        hook.(kind, msg, item, indent_level) rescue nil
       end
     end
 
@@ -123,6 +147,7 @@ module Sord
     # @yieldparam [YARD::CodeObjects::Base] item The CodeObject which this log 
     #  is associated with, if any. This is shown before the log message if it is
     #  specified.
+    # @yieldparam [Integer] indent_level The level at which to indent the code.
     # @yieldreturn [void]
     def self.add_hook(&blk)
       @@hooks << blk

data/lib/sord/rbi_generator.rb

@@ -12,52 +12,81 @@ module Sord
     
     # @return [Integer] The number of objects this generator has processed so 
     #   far.
-    attr_reader :object_count
+    def object_count
+      @namespace_count + @method_count
+    end
+
+    # @return [Array<Array(String, YARD::CodeObjects::Base, Integer)>] The 
+    #   errors encountered by by the generator. Each element is of the form
+    #   [message, item, line].
+    attr_reader :warnings
 
     # Create a new RBI generator.
     # @param [Hash] options
     # @return [RbiGenerator]
     def initialize(options)
       @rbi_contents = ['# typed: strong']
-      @object_count = 0
+      @namespace_count = 0
+      @method_count = 0
+      @warnings = []
 
       # Hook the logger so that messages are added as comments to the RBI file
-      Logging.add_hook do |type, msg, item|
-        rbi_contents << "  # sord #{type} - #{msg}"
+      Logging.add_hook do |type, msg, item, indent_level = 0|
+        rbi_contents << "#{'  ' * (indent_level + 1)}# sord #{type} - #{msg}"
       end if options.comments
+
+      # Hook the logger so that warnings are collected
+      Logging.add_hook do |type, msg, item, indent_level = 0|
+        warnings << [msg, item, rbi_contents.length] \
+          if type == :warn
+      end
     end
 
-    # Increment the object counter.
+    # Increment the namespace counter.
     # @return [void]
-    def count_object
-      @object_count += 1
+    def count_namespace
+      @namespace_count += 1
+    end
+
+    # Increment the method counter.
+    # @return [void]
+    def count_method
+      @method_count += 1
     end
 
     # Given a YARD CodeObject, add lines defining its mixins (that is, extends
     # and includes) to the current RBI file.
     # @param [YARD::CodeObjects::Base] item
+    # @param [Integer] indent_level
     # @return [void]
-    def add_mixins(item)
+    def add_mixins(item, indent_level)
       extends = item.instance_mixins
       includes = item.class_mixins
 
       extends.each do |this_extend|
-        rbi_contents << "  extend #{this_extend.path}"
+        rbi_contents << "#{'  ' * (indent_level + 1)}extend #{this_extend.path}"
       end
       includes.each do |this_include|
-        rbi_contents << "  include #{this_include.path}"
+        rbi_contents << "#{'  ' * (indent_level + 1)}include #{this_include.path}"
       end
     end
 
     # Given a YARD NamespaceObject, add lines defining its methods and their
     # signatures to the current RBI file.
     # @param [YARD::CodeObjects::NamespaceObject] item
+    # @param [Integer] indent_level
     # @return [void]
-    def add_methods(item)
+    def add_methods(item, indent_level)
       # TODO: block documentation
 
       item.meths.each do |meth|
-        count_object
+        count_method
+
+        # If the method is an alias, skip it so we don't define it as a
+        # separate method. Sorbet will handle it automatically.
+        if meth.is_alias?
+          next
+        end
 
         parameter_list = meth.parameters.map do |name, default|
           # Handle these three main cases:
@@ -95,19 +124,19 @@ module Sord
             getter = item.meths.find { |m| m.path == getter_path }
 
             unless getter
-              Logging.omit("no YARD type given for #{name.inspect}, using T.untyped", meth)
+              Logging.omit("no YARD type given for #{name.inspect}, using T.untyped", meth, indent_level)
               next "#{name}: T.untyped"
             end
 
             inferred_type = TypeConverter.yard_to_sorbet(
               getter.tags('return').flat_map(&:types), meth)
             
-            Logging.infer("inferred type of parameter #{name.inspect} as #{inferred_type} using getter's return type", meth)
+            Logging.infer("inferred type of parameter #{name.inspect} as #{inferred_type} using getter's return type", meth, indent_level)
             # Get rid of : on keyword arguments.
             name = name.chop if name.end_with?(':')
             "#{name}: #{inferred_type}"
           else
-            Logging.omit("no YARD type given for #{name.inspect}, using T.untyped", meth)
+            Logging.omit("no YARD type given for #{name.inspect}, using T.untyped", meth, indent_level)
             # Get rid of : on keyword arguments.
             name = name.chop if name.end_with?(':')
             "#{name}: T.untyped"
@@ -117,7 +146,7 @@ module Sord
         return_tags = meth.tags('return')
         returns = if return_tags.length == 0
           "void"
-        elsif return_tags.length == 1 && return_tags.first.types.first.downcase == "void"
+        elsif return_tags.length == 1 && return_tags&.first&.types&.first&.downcase == "void"
           "void"
         else
           "returns(#{TypeConverter.yard_to_sorbet(meth.tag('return').types, meth)})"
@@ -125,31 +154,32 @@ module Sord
 
         prefix = meth.scope == :class ? 'self.' : ''
 
-        sig = sig_params_list.empty? ? "  sig { #{returns} }" : "  sig { params(#{sig_params_list}).#{returns} }"
+        sig = sig_params_list.empty? ? "#{'  ' * (indent_level + 1)}sig { #{returns} }" : "#{'  ' * (indent_level + 1)}sig { params(#{sig_params_list}).#{returns} }"
         rbi_contents << sig
 
-        rbi_contents << "  def #{prefix}#{meth.name}(#{parameter_list}); end"
+        rbi_contents << "#{'  ' * (indent_level + 1)}def #{prefix}#{meth.name}(#{parameter_list}); end"
       end
     end
 
     # Given a YARD NamespaceObject, add lines defining its mixins, methods
     # and children to the RBI file.
     # @param [YARD::CodeObjects::NamespaceObject] item
-    def add_namespace(item)
-      count_object
+    # @param [Integer] indent_level
+    def add_namespace(item, indent_level = 0)
+      count_namespace
 
       if item.type == :class && item.superclass.to_s != "Object"
-        rbi_contents << "class #{item.name} < #{item.superclass.path}" 
+        rbi_contents << "#{'  ' * indent_level}class #{item.name} < #{item.superclass.path}" 
       else
-        rbi_contents << "#{item.type} #{item.name}"
+        rbi_contents << "#{'  ' * indent_level}#{item.type} #{item.name}"
       end
-      add_mixins(item)
-      add_methods(item)
+      add_mixins(item, indent_level)
+      add_methods(item, indent_level)
 
       item.children.select { |x| [:class, :module].include?(x.type) }
-        .each { |child| add_namespace(child) }
+        .each { |child| add_namespace(child, indent_level + 1) }
 
-      rbi_contents << "end"
+      rbi_contents << "#{'  ' * indent_level}end"
     end
 
     # Generates the RBI file and writes it to the given file path.
@@ -171,11 +201,29 @@ module Sord
       # Write the file
       File.write(filename, rbi_contents.join(?\n))
 
-      Logging.done("Processed #{object_count} objects")
+      if object_count.zero?
+        Logging.warn("No objects processed.")
+        Logging.warn("Have you definitely generated the YARD documentation for this project?")
+        Logging.warn("Run `yard` to generate docs.")
+      end
+
+      Logging.done("Processed #{object_count} objects (#{@namespace_count} namespaces and #{@method_count} methods)")
+
+      Logging.hooks.clear
+
+      unless warnings.empty?
+        Logging.warn("There were #{warnings.length} important warnings in the RBI file, listed below.")
+        Logging.warn("The types which caused them have been replaced with SORD_ERROR_ constants.")
+        Logging.warn("Please edit the file near the line numbers given to fix these errors.")
+        Logging.warn("Alternatively, edit your YARD documentation so that your types are valid and re-run Sord.")
+        warnings.each do |(msg, item, line)|
+          puts "        #{"Line #{line} |".light_black} (#{item.path.bold}) #{msg}"
+        end
+      end
     rescue
       Logging.error($!)
       $@.each do |line|
-        puts "         #{line}".light_white
+        puts "         #{line}"
       end
     end
   end

data/lib/sord/type_converter.rb

@@ -1,3 +1,4 @@
+require 'yaml'
 require 'sord/logging'
 
 module Sord
@@ -7,14 +8,24 @@ module Sord
     # "Foo", "Foo::Bar", and "::Foo::Bar" are all matches, whereas "Foo.Bar"
     # or "Foo#bar" are not.
     SIMPLE_TYPE_REGEX =
-      /(?:\:\:)?[a-zA-Z_][a-zA-Z_0-9]*(?:\:\:[a-zA-Z_][a-zA-Z_0-9]*)*/
+      /(?:\:\:)?[a-zA-Z_][\w]*(?:\:\:[a-zA-Z_][\w]*)*/
 
     # A regular expression which matches a Ruby namespace immediately followed
-    # by another Ruby namespace in angle brackets. This is the format usually
-    # used in YARD to model generic types, such as "Array<String>",
-    # "Hash<String, Symbol>", "Hash{String => Symbol}", etc.
+    # by another Ruby namespace in angle brackets or curly braces.
+    # This is the format usually used in YARD to model generic
+    # types, such as "Array<String>", "Hash<String, Symbol>",
+    # "Hash{String => Symbol}", etc.
     GENERIC_TYPE_REGEX =
       /(#{SIMPLE_TYPE_REGEX})\s*[<{]\s*(.*)\s*[>}]/
+    
+    # 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 regular expression which matches ordered lists in the format of
+    # either "Array(String, Symbol)" or "(String, Symbol)".
+    ORDERED_LIST_REGEX = /^(?:Array|)\((.*)\s*\)$/
 
     # An array of built-in generic types supported by Sorbet.
     SORBET_SUPPORTED_GENERIC_TYPES = %w{Array Set Enumerable Enumerator Range Hash}
@@ -33,11 +44,11 @@ module Sord
       while character_pointer < params.length
         should_buffer = true
 
-        current_bracketing_level += 1 if ['<', '{'].include?(params[character_pointer])
+        current_bracketing_level += 1 if ['<', '{', '('].include?(params[character_pointer])
         # Decrease bracketing level by 1 when encountering `>` or `}`, unless
         # the previous character is `=` (to prevent hash rockets from causing
         # nesting problems).
-        current_bracketing_level -= 1 if ['>', '}'].include?(params[character_pointer]) && params[character_pointer - 1] != '='
+        current_bracketing_level -= 1 if ['>', '}', ')'].include?(params[character_pointer]) && params[character_pointer - 1] != '='
 
         # Handle commas as separators.
         # e.g. Hash<Symbol, String>
@@ -98,7 +109,7 @@ module Sord
           Logging.warn("#{yard} is probably not a type, but using anyway", item)
         end
         yard
-      when /^\##{SIMPLE_TYPE_REGEX}$/
+      when DUCK_TYPE_REGEX
         Logging.duck("#{yard} looks like a duck type, replacing with T.untyped", item)
         'T.untyped'
       when /^#{GENERIC_TYPE_REGEX}$/
@@ -117,7 +128,19 @@ module Sord
           Logging.warn("unsupported generic type #{generic_type.inspect} in #{yard.inspect}", item)
           "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) }
+        "[#{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, '')}"
       end

data/lib/sord/version.rb

@@ -1,4 +1,4 @@
 # typed: strong
 module Sord
-  VERSION = "0.6.0"
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sord
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Aaron Christiansen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-23 00:00:00.000000000 Z
+date: 2019-06-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -148,9 +148,9 @@ files:
 - ".github/ISSUE_TEMPLATE/feature-request.md"
 - ".gitignore"
 - ".rspec"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile

data/Gemfile.lock

@@ -1,57 +0,0 @@
-PATH
-  remote: .
-  specs:
-    sord (0.4.1)
-      colorize
-      commander (~> 4.4)
-      sorbet-runtime
-      yard
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    colorize (0.8.1)
-    commander (4.4.7)
-      highline (~> 2.0.0)
-    diff-lcs (1.3)
-    docile (1.3.2)
-    highline (2.0.2)
-    json (2.2.0)
-    rake (10.5.0)
-    rspec (3.8.0)
-      rspec-core (~> 3.8.0)
-      rspec-expectations (~> 3.8.0)
-      rspec-mocks (~> 3.8.0)
-    rspec-core (3.8.1)
-      rspec-support (~> 3.8.0)
-    rspec-expectations (3.8.4)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-mocks (3.8.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.8.0)
-    rspec-support (3.8.2)
-    simplecov (0.16.1)
-      docile (~> 1.1)
-      json (>= 1.8, < 3)
-      simplecov-html (~> 0.10.0)
-    simplecov-html (0.10.2)
-    sorbet (0.4.4254)
-      sorbet-static (= 0.4.4254)
-    sorbet-runtime (0.4.4294)
-    sorbet-static (0.4.4254-x86_64-linux)
-    yard (0.9.19)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bundler (~> 2.0)
-  rake (~> 10.0)
-  rspec (~> 3.0)
-  simplecov
-  sorbet
-  sord!
-
-BUNDLED WITH
-   2.0.1