sord 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b9a2d105021ccde04330fef38f0a2d3fb270fbd3d2e2c43a258c3bc3f6e0b9f1
+  data.tar.gz: 7d4ff5718684cfd2505595c77ef0bbc6e7f79c6981b0210f28912a66cb6725eb
+SHA512:
+  metadata.gz: 8681c3b8c07c397f2f454f0e71546ba33ead6b66efdee7c98ecb57ccfea4908a9fe7f03c43d206d46409d4cf7bcdf3116dbb89b628feaf23bfdb52d9f2168c6a
+  data.tar.gz: 552beb2ce3b13800f16687967a3d6bc80b6ab7398f54c16e998612241a37b7bb4a6f490e25d17fa427960ccaecd3a4c0964ac224728dc3e13eb8abc0bb6de970

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at aaronc20000@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in sord.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,45 @@
+PATH
+  remote: .
+  specs:
+    sord (0.1.0)
+      colorize
+      sorbet-runtime
+      yard
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    colorize (0.8.1)
+    diff-lcs (1.3)
+    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)
+    sorbet (0.4.4254)
+      sorbet-static (= 0.4.4254)
+    sorbet-runtime (0.4.4254)
+    sorbet-static (0.4.4254-x86_64-linux)
+    yard (0.9.19)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 2.0)
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  sorbet
+  sord!
+
+BUNDLED WITH
+   2.0.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Aaron Christiansen
+
+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.

data/README.md

@@ -0,0 +1,47 @@
+# Sord
+
+## Overview
+
+Sord is a **So**rbet and YA**RD** crossover. It can automatically generate
+Sorbet type signatures files by looking at the types specified in YARD 
+documentation comments.
+
+If your project is already YARD documented, then this can generate most of the
+Sorbet signatures you need!
+
+Sord has the following features:
+  - Automatically generates signatures for modules, classes and methods
+  - Support for multiple parameter or return types (`T.any`)
+  - Gracefully handles missing YARD types (`T.untyped`)
+  - Can infer setter parameter type from the corresponding getter's return type
+  - Recognises mixins (`include` and `extend`)
+  - Support for single-argument generic types such as `Array` (no hashes yet)
+
+## Usage
+
+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):
+
+```
+sord defs.rbi
+```
+
+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.
+
+## Example
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/sord. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Sord project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/sord/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/exe/sord

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'sord'
+
+Sord::RbiGenerator.new.run($*[0])

data/lib/sord/logging.rb

@@ -0,0 +1,47 @@
+require 'colorize'
+
+module Sord
+  module Logging
+    @@hooks = []
+
+    def self.generic(kind, header, msg, item)
+      if item
+        puts "#{header} (#{item.path.light_white}) #{msg}"
+      else
+        puts "#{header} #{msg}"
+      end
+
+      invoke_hooks(kind, msg, item)
+    end
+
+    def self.warn(msg, item=nil)
+      generic(:warn, '[WARN ]'.yellow, msg, item)
+    end
+
+    def self.error(msg, item=nil)
+      generic(:error, '[ERROR]'.red, msg, item)
+    end
+
+    def self.infer(msg, item=nil)
+      generic(:infer, '[INFER]'.light_blue, msg, item)
+    end
+
+    def self.omit(msg, item=nil)
+      generic(:omit, '[OMIT ]'.magenta, msg, item)
+    end
+
+    def self.done(msg, item=nil)
+      generic(:done, '[DONE ]'.green, msg, item)
+    end
+
+    def self.invoke_hooks(type, msg, item)
+      @@hooks.each do |hook|
+        hook.(type, msg, item) rescue nil
+      end
+    end
+
+    def self.add_hook(&blk)
+      @@hooks << blk
+    end
+  end
+end

data/lib/sord/rbi_generator.rb

@@ -0,0 +1,133 @@
+# typed: true
+require 'yard'
+require 'sord/type_converter'
+require 'colorize'
+require 'sord/logging'
+
+module Sord
+  class RbiGenerator
+    attr_reader :rbi_contents, :object_count
+
+    def initialize
+      @rbi_contents = ['# typed: true']
+      @object_count = 0
+
+      Logging.add_hook do |type, msg, item|
+        rbi_contents << "  # sord #{type} - #{msg}"
+      end
+    end
+
+    def count_object
+      @object_count += 1
+    end
+
+    def add_mixins(item)
+      extends = item.instance_mixins
+      includes = item.class_mixins
+
+      extends.each do |this_extend|
+        rbi_contents << "  extend #{this_extend.path}"
+      end
+      includes.each do |this_include|
+        rbi_contents << "  include #{this_include.path}"
+      end
+    end
+
+    def add_methods(item)
+      # TODO: block documentation
+      item.meths.each do |meth|
+        count_object
+
+        parameter_list = meth.parameters.map do |name, default|
+          "#{name}#{default && " = #{default}"}"
+        end.join(", ")
+
+        parameter_names_to_tags = meth.parameters.map do |name, _|
+          [name, meth.tags('param').find { |p| p.name == name }]
+        end.to_h
+
+        # TODO: if it's a _= method, infer from the _ method
+        sig_params_list = parameter_names_to_tags.map do |name, tag|
+          if tag
+            "#{name}: #{TypeConverter.yard_to_sorbet(tag.types, meth)}"
+          elsif name.start_with? '*'
+            # TODO: is there a YARD definition for this?
+            "args: T::Array[T.any]"
+          elsif meth.path.end_with? '='
+            # Look for the matching getter method
+            getter_path = meth.path[0...-1]
+            getter = item.meths.find { |m| m.path == getter_path }
+
+            unless getter
+              Logging.omit("no YARD type given for #{name.inspect}, using T.untyped", meth)
+              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)
+            "#{name}: #{inferred_type}"
+          else
+            Logging.omit("no YARD type given for #{name.inspect}, using T.untyped", meth)
+            "#{name}: T.untyped"
+          end
+        end.join(", ")
+
+        return_tags = meth.tags('return')
+        returns = if return_tags.length == 0
+          "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)})"
+        end
+
+        prefix = meth.scope == :class ? 'self.' : ''
+
+        rbi_contents << "  sig { params(#{sig_params_list}).#{returns} }"
+
+        rbi_contents << "  def #{prefix}#{meth.name}(#{parameter_list}) end"
+      end
+    end
+
+    def run(filename)
+      # Get YARD ready
+      YARD::Registry.load!
+
+      # TODO: constants?
+
+      # Populate the RBI with modules first
+      YARD::Registry.all(:module).each do |item|
+        count_object
+        
+        rbi_contents << "module #{item.path}"
+        add_mixins(item)
+        add_methods(item)
+        rbi_contents << "end"
+      end
+
+      # Now populate with classes
+      YARD::Registry.all(:class).each do |item|
+        count_object
+
+        superclass = (item.superclass if item.superclass.to_s != "Object")
+        rbi_contents << "class #{item.path} #{"< #{superclass}" if superclass}" 
+        add_mixins(item)
+        add_methods(item)        
+        rbi_contents << "end"
+      end
+
+      # Write the file
+      raise "no filename specified" unless filename
+      File.write(filename, rbi_contents.join(?\n))
+
+      Logging.done("Processed #{object_count} objects")
+    rescue
+      Logging.error($!)
+      $@.each do |line|
+        puts "         #{line}".light_white
+      end
+    end
+  end
+end

data/lib/sord/type_converter.rb

@@ -0,0 +1,52 @@
+require 'sord/logging'
+
+module Sord
+  module TypeConverter
+    SIMPLE_TYPE_REGEX =
+      /(?:\:\:)?[a-zA-Z_][a-zA-Z_0-9]*(?:\:\:[a-zA-Z_][a-zA-Z_0-9]*)*/
+
+    # TODO: does not support mulitple type arguments (e.g. Hash<A, B>)
+    GENERIC_TYPE_REGEX =
+      /(#{SIMPLE_TYPE_REGEX})<(#{SIMPLE_TYPE_REGEX})>/
+
+    # TODO: Hash
+    SORBET_SUPPORTED_GENERIC_TYPES = %w{Array Set Enumerable Enumerator Range}
+
+    def self.yard_to_sorbet(yard, item=nil, &blk)
+      case yard
+      when nil
+        "T.untyped"
+      when  "bool", "Bool", "boolean", "Boolean", ["true", "false"], ["false", "true"]
+        "T::Boolean"
+      when Array
+        # If there's only one element, unwrap it, otherwise allow for a
+        # selection of any of the types
+        yard.length == 1 \
+          ? yard_to_sorbet(yard.first, item, &blk)
+          : "T.any(#{yard.map { |x| yard_to_sorbet(x, item, &blk) }.join(', ')})"
+      when /^#{SIMPLE_TYPE_REGEX}$/
+        if /^[_a-z]/ === yard
+          Logging.warn("#{yard} is probably not a type, but using anyway", item)
+        end
+        yard
+      when /^#{GENERIC_TYPE_REGEX}$/
+        generic_type = $1
+        type_parameter = $2
+
+        if SORBET_SUPPORTED_GENERIC_TYPES.include?(generic_type)
+          if /^[_a-z]/ === type_parameter
+            Logging.warn("#{type_parameter} is probably not a type, but using anyway", item)
+          end  
+
+          "T::#{generic_type}[#{yard_to_sorbet(type_parameter, item, &blk)}]"
+        else
+          Logging.warn("unsupported generic type #{generic_type.inspect} in #{yard.inspect}", item)
+          "SORD_ERROR_#{generic_type.gsub(/[^0-9A-Za-z_]/i, '')}"
+        end
+      else
+        Logging.warn("#{yard.inspect} does not appear to be a type", item)
+        "SORD_ERROR_#{yard.gsub(/[^0-9A-Za-z_]/i, '')}"
+      end
+    end
+  end
+end

data/lib/sord/version.rb

@@ -0,0 +1,4 @@
+# typed: strong
+module Sord
+  VERSION = "0.1.0"
+end

data/lib/sord.rb

@@ -0,0 +1,5 @@
+# typed: strong
+require 'sord/version'
+require 'sord/rbi_generator'
+require 'yard'
+require 'sorbet-runtime'

data/sorbet/config

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