gelauto 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: edff254e0369ac872f616b28e6885f92efb5127f0ddd159d477d545015a19f48
+  data.tar.gz: 7645cfbff7c9c2806b8c160ce27aa2f8119f6c56f62362655481e44a26f720d4
+SHA512:
+  metadata.gz: 363f769d6dec4cec5a5390bdd099418b53785af49a61cc85a410bc125a66e5ad047fa403ca8220fa7e56ec060c9216f3ee63eacd83dfc8801a90591afee41b43
+  data.tar.gz: abee9406ff027155948e07b0be22cdfbcbd2b9744f492508cd90380ede41f792df120719a5ef4f143c783b52b9ea59269d412e7b4fa629ca083c7e1d08cd1d1c

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development do
+  gem 'pry-byebug'
+  gem 'rspec'
+  gem 'rake'
+end

data/README.md

@@ -0,0 +1,139 @@
+## gelauto [![Build Status](https://secure.travis-ci.org/camertron/gelauto.png?branch=master)](http://travis-ci.org/camertron/gelauto)
+
+Automatically annotate your code with Sorbet type definitions.
+
+## What is This Thing?
+
+The wonderful folks at Stripe recently released a static type checker for Ruby called [Sorbet](https://github.com/sorbet/sorbet). It works by examining type signatures placed at the beginning of each method. For example:
+
+```ruby
+# typed: true
+
+class Car
+  extend T::Sig
+
+  sig { params(num_wheels: Integer) }
+  def initialize(num_wheels)
+    @num_wheels = num_wheels
+  end
+
+  sig { params(speed: Float).returns(T::Boolean) }
+  def drive(speed)
+    true
+  end
+end
+```
+
+Adding these definitions means you get cool stuff like auto-complete and type checking in your editor. Pretty freaking rad.
+
+### Ok, so what is Gelauto?
+
+Gelauto is an _auto_-matic way (get it?! lol) of adding Sorbet type signatures to your methods. It works by running your code (for example, your test suite). As your code runs, Gelauto keeps track of the actual types of objects that were passed to your methods as well as the types of objects they return. After gathering the info, Gelauto then (optionally) inserts type signatures into your Ruby files.
+
+## Installation
+
+`gem install gelauto`
+
+## Usage
+
+You can run Gelauto either via the command line or by adding it to your bundle.
+
+### Command Line Usage
+
+First, install the gem by running `gem install gelauto`. That will make the `gelauto` executable available on your system.
+
+Gelauto's only subcommand is `run`, which accepts a list of Ruby files to scan for methods and a command to run that will exercise your code. In this example, we're going to be running an [RSpec](https://github.com/rspec/rspec) test suite.
+
+Like most RSpec test suites, let's assume ours is stored in the `spec/` directory (that's the RSpec default too). Let's furthermore assume our code is stored in the `lib` directory. To run the test suite in `spec/` and add type definitions to our files in `lib/`, we might run the following command:
+
+```bash
+gelauto run --annotate $(find . -name '*.rb') -- bundle exec rspec spec/
+```
+
+If you choose to run Gelauto without the `--annotate` flag, Gelauto will print results to standard output in [RBI format](https://sorbet.org/docs/rbi) and not modify any of your Ruby files.
+
+### Gelauto in your Bundle
+
+If you would rather run Gelauto as part of your bundle, add it to your Gemfile like so:
+
+```ruby
+gem 'gelauto'
+```
+
+Gelauto can be invoked from within your code in one of several ways.
+
+#### Gelauto.discover
+
+Wrap code you'd like to run with Gelauto in `Gelauto.discover`:
+
+```ruby
+require 'gelauto'
+
+Gelauto.paths << 'path/to/file/i/want/to/annotate.rb'
+
+Gelauto.discover do
+  call_some_method(with, some, params)
+end
+
+# loop over files and annotate them
+Gelauto.each_absolute_path do |path|
+  Gelauto.annotate_file(path)
+end
+
+# you can also grab a reference to the method cache Gelauto
+# has populated with all the type information it's been able
+# to gather:
+Gelauto.method_index
+```
+
+#### Setup and Teardown
+
+`Gelauto.discover` is just syntactic sugar around two methods that start and stop Gelauto's method tracing functionality:
+
+```ruby
+Gelauto.setup
+
+begin
+  call_some_method(with, some, params)
+ensure
+  Gelauto.teardown
+end
+```
+
+#### RSpec Helper
+
+Gelauto comes with a handy RSpec helper that can do all this for you. Simply add
+
+```ruby
+require 'gelauto/rspec'
+```
+
+to your spec_helper.rb, Rakefile, or wherever RSpec is configured.
+
+## How does it Work?
+
+Gelauto makes use of Ruby's [TracePoint API](https://ruby-doc.org/core-2.6/TracePoint.html). TracePoint effectively allows Gelauto to receive a notification whenever a Ruby method is called and whenever a method returns. That info combined with method location information gathered from parsing your Ruby files ahead of time allows Gelauto to know a) where methods are located, 2) what arguments they take, 3) the types of those arguments, and 4) the type of the return value.
+
+"Doesn't that potentially make my code run slower?" is a question you might ask. Yes. Gelauto adds overhead to literally every Ruby method call, so your code will probably run quite a bit slower. For that reason you probably won't want to enable Gelauto in, for example, a production web application.
+
+## Known Limitations
+
+* Half-baked support for singleton (i.e. static) methods.
+* Gelauto does not annotate Ruby files with `# typed: true` comments or `extend T::Sig`.
+* Gelauto ignores existing type signatures and will simply add another one right above the method.
+
+## Running Tests
+
+`bundle exec rspec` should do the trick :)
+
+## Contributing
+
+Please fork this repo and submit a pull request.
+
+## License
+
+Licensed under the MIT license. See LICENSE for details.
+
+## Authors
+
+* Cameron C. Dutro: http://github.com/camertron

data/Rakefile

@@ -0,0 +1,14 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rubygems/package_task'
+
+require 'gelauto'
+
+Bundler::GemHelper.install_tasks
+
+task default: :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = './spec/**/*_spec.rb'
+end

data/bin/gelauto

@@ -0,0 +1,54 @@
+#! /usr/bin/env ruby
+
+require 'gelauto'
+require 'gli'
+
+module Gelauto
+  module CLI
+    extend GLI::App
+
+    program_desc 'Automatically annotate methods with Sorbet type signatures.'
+
+    version Gelauto::VERSION
+
+    subcommand_option_handling :normal
+    default_command :run
+
+    desc 'Run the given command with Gelauto and optionally annotate files.'
+    command :run do |c|
+      c.desc 'Write discovered type signatures into Ruby files.'
+      c.default_value false
+      c.switch [:a, :annotate]
+
+      c.action do |global_options, options, args|
+        paths, _, cmd = args.chunk_while { |arg1, arg2| arg1 != '--' && arg2 != '--' }.to_a
+        Gelauto.paths += paths
+
+        exe = Gelauto::CLIUtils.which(cmd[0]) || cmd[0]
+        cmd.shift
+
+        old_argv = ARGV.dup
+
+        begin
+          Gelauto.setup
+          ARGV.replace(cmd)
+          load exe
+        ensure
+          Gelauto.teardown
+          ARGV.replace(old_argv)
+
+          if options[:annotate]
+            Gelauto.each_absolute_path do |path|
+              Gelauto.annotate_file(path)
+              Gelauto::Logger.info("Annotated #{path}")
+            end
+          else
+            puts Gelauto::Rbi.new(Gelauto.method_index).to_s
+          end
+        end
+      end
+    end
+  end
+end
+
+exit Gelauto::CLI.run(ARGV)

data/gelauto.gemspec

@@ -0,0 +1,21 @@
+$:.unshift File.join(File.dirname(__FILE__), 'lib')
+require 'gelauto/version'
+
+Gem::Specification.new do |s|
+  s.name     = 'gelauto'
+  s.version  = ::Gelauto::VERSION
+  s.authors  = ['Cameron Dutro']
+  s.email    = ['camertron@gmail.com']
+  s.homepage = 'http://github.com/camertron/gelauto'
+
+  s.description = s.summary = 'Automatically annotate your code with Sorbet type definitions.'
+  s.platform = Gem::Platform::RUBY
+
+  s.add_dependency 'parser', '~> 2.6'
+  s.add_dependency 'gli', '~> 2.0'
+
+  s.executables << 'gelauto'
+
+  s.require_path = 'lib'
+  s.files = Dir['{lib,spec}/**/*', 'Gemfile', 'README.md', 'Rakefile', 'gelauto.gemspec']
+end

data/lib/gelauto/arg_list.rb

@@ -0,0 +1,32 @@
+module Gelauto
+  class ArgList
+    include Enumerable
+
+    attr_reader :args
+
+    def initialize(args = [])
+      @args = args
+    end
+
+    def <<(arg)
+      args << arg
+    end
+
+    def [](idx)
+      args[idx]
+    end
+
+    def empty?
+      args.empty?
+    end
+
+    def each(&block)
+      args.each(&block)
+    end
+
+    def to_sig
+      return '' if args.empty?
+      args.map(&:to_sig).join(', ')
+    end
+  end
+end

data/lib/gelauto/array_type.rb

@@ -0,0 +1,25 @@
+module Gelauto
+  class ArrayType < GenericType
+    def self.introspect(obj)
+      new.tap do |var|
+        obj.each { |elem| var[:elem] << Gelauto.introspect(elem) }
+      end
+    end
+
+    def initialize
+      super(::Array, [:elem])
+    end
+
+    def to_sig
+      if self[:elem].empty?
+        'T::Array'
+      else
+        "T::Array[#{self[:elem].to_sig}]"
+      end
+    end
+
+    def merge!(other)
+      self[:elem].merge!(other[:elem])
+    end
+  end
+end

data/lib/gelauto/boolean_type.rb

@@ -0,0 +1,7 @@
+module Gelauto
+  class BooleanType < Type
+    def to_sig
+      'T::Boolean'
+    end
+  end
+end

data/lib/gelauto/cli_utils.rb

@@ -0,0 +1,18 @@
+module Gelauto
+  module CLIUtils
+    EXTS = (ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']).freeze
+
+    def which(cmd)
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        EXTS.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+      end
+
+      nil
+    end
+
+    extend self
+  end
+end

data/lib/gelauto/generic_type.rb

@@ -0,0 +1,24 @@
+require 'set'
+
+module Gelauto
+  class GenericType
+    attr_reader :ruby_type, :generic_args
+
+    def initialize(ruby_type, generic_arg_names = [])
+      @ruby_type = ruby_type
+      @generic_args = {}
+
+      generic_arg_names.each_with_object({}) do |generic_arg_name, ret|
+        generic_args[generic_arg_name] = TypeSet.new
+      end
+    end
+
+    def [](generic_arg_name)
+      generic_args[generic_arg_name]
+    end
+
+    def to_sig
+      raise NotImplementedError, "please define #{__method__} in derived classes"
+    end
+  end
+end

data/lib/gelauto/hash_type.rb

@@ -0,0 +1,29 @@
+module Gelauto
+  class HashType < GenericType
+    def self.introspect(obj)
+      new.tap do |var|
+        obj.each_pair do |key, value|
+          var[:key] << Gelauto.introspect(key)
+          var[:value] << Gelauto.introspect(value)
+        end
+      end
+    end
+
+    def initialize
+      super(::Hash, [:key, :value])
+    end
+
+    def to_sig
+      if self[:key].empty? && self[:value].empty?
+        'T::Hash'
+      else
+        "T::Hash[#{self[:key].to_sig}, #{self[:value].to_sig}]"
+      end
+    end
+
+    def merge!(other)
+      self[:key].merge!(other[:key])
+      self[:value].merge!(other[:value])
+    end
+  end
+end

data/lib/gelauto/logger.rb

@@ -0,0 +1,31 @@
+module Gelauto
+  module Logger
+    class << self
+      def debug(str)
+        Gelauto.logger.debug(fmt(str))
+      end
+
+      def info(str)
+        Gelauto.logger.info(fmt(str))
+      end
+
+      def warn(str)
+        Gelauto.logger.warn(fmt(str))
+      end
+
+      def error(str)
+        Gelauto.logger.error(fmt(str))
+      end
+
+      def fatal(str)
+        Gelauto.logger.fatal(fmt(str))
+      end
+
+      private
+
+      def fmt(str)
+        "[Gelauto] #{str}"
+      end
+    end
+  end
+end

data/lib/gelauto/method_def.rb

@@ -0,0 +1,34 @@
+require 'set'
+
+module Gelauto
+  class MethodDef
+    attr_reader :name, :args, :nesting, :return_types
+
+    def initialize(name, args, nesting, return_types = TypeSet.new)
+      @name = name
+      @args = ArgList.new(args.map { |arg| Var.new(arg) })
+      @nesting = nesting
+      @return_types = return_types
+    end
+
+    def to_sig
+      components = []
+
+      unless args.empty?
+        components << "params(#{args.to_sig})"
+      end
+
+      if name == :initialize
+        components << 'void'
+      else
+        components << "returns(#{return_types.to_sig})"
+      end
+
+      "sig { #{components.join('.')} }"
+    end
+
+    def to_rbi
+      "#{to_sig}\ndef #{name}; end"
+    end
+  end
+end

data/lib/gelauto/method_index.rb

@@ -0,0 +1,97 @@
+module Gelauto
+  class MethodIndex
+    attr_reader :index
+
+    def initialize
+      @index = Hash.new { |h, k| h[k] = {} }
+    end
+
+    def index_methods_in(path, ast, nesting = [])
+      return unless ast
+
+      case ast.type
+        when :def, :defs
+          name = nil
+          args = nil
+
+          if ast.type == :def
+            name = ast.children[0]
+            args = ast.children[1].children.map { |c| c.children.first }
+          else
+            name = ast.children[1]
+            args = ast.children[2].children.map { |c| c.children.first }
+          end
+
+          md = MethodDef.new(name, args, nesting)
+          index[path][ast.location.name.line] = md
+
+          # point to start of method
+          index[path][ast.location.end.line] = ast.location.name.line
+
+        when :class, :module
+          const_name = ast.children.first.children.last
+          return visit_children(path, ast, nesting + [Namespace.new(const_name, ast.type)])
+      end
+
+      visit_children(path, ast, nesting)
+    end
+
+    def find(path, lineno)
+      if md = index[path][lineno]
+        return md if md.is_a?(MethodDef)
+
+        # md is actually an index pointing to another line
+        index[path][md]
+      end
+    end
+
+    def each
+      return to_enum(__method__) unless block_given?
+
+      index.each_pair do |path, line_index|
+        line_index.each_pair do |lineno, md|
+          yield(path, lineno, md) if md.is_a?(MethodDef)
+        end
+      end
+    end
+
+    def each_method_in(path)
+      return to_enum(__method__, path) unless block_given?
+
+      index[path].each_pair do |lineno, md|
+        yield lineno, md if md.is_a?(MethodDef)
+      end
+    end
+
+    def annotate(path, code)
+      lines = code.split(/\r?\n/)
+      mds = index[path]
+
+      [].tap do |annotated|
+        lines.each_with_index do |line, idx|
+          lineno = idx + 1
+          md = mds[lineno]
+
+          if md.is_a?(MethodDef)
+            indent = line[0...line.index(/[^\s]/)]
+            annotated << "#{indent}#{md.to_sig}"
+          end
+
+          annotated << line
+        end
+      end.join("\n")
+    end
+
+    def reset
+      index.clear
+    end
+
+    private
+
+    def visit_children(path, ast, nesting)
+      ast.children.each do |child|
+        index_methods_in(path, child, nesting) if child.is_a?(Parser::AST::Node)
+      end
+    end
+  end
+end

data/lib/gelauto/namespace.rb

@@ -0,0 +1,10 @@
+module Gelauto
+  class Namespace
+    attr_reader :name, :type
+
+    def initialize(name, type)
+      @name = name
+      @type = type
+    end
+  end
+end

data/lib/gelauto/rbi.rb

@@ -0,0 +1,47 @@
+module Gelauto
+  class Rbi
+    attr_reader :method_index, :paths
+
+    def initialize(method_index, paths = Gelauto.paths)
+      @method_index = method_index
+      @paths = paths
+    end
+
+    def to_s
+      StringIO.new.tap { |io| compose(method_groups, io) }.string
+    end
+
+    private
+
+    def method_groups
+      @method_groups ||= { methods: [], children: {} }.tap do |groups|
+        Utils.each_absolute_path(paths) do |path|
+          method_index.each_method_in(path) do |_lineno, md|
+            cur_group = md.nesting.inject(groups) do |group, namespace|
+              group[:children][[namespace.name, namespace.type]] ||= { methods: [], children: {} }
+            end
+
+            cur_group[:methods] << md
+          end
+        end
+      end
+    end
+
+    def compose(h, io, indent_level = 0)
+      io.write(indent(h[:methods].map { |md| md.to_rbi }.join("\n\n"), indent_level))
+
+      h[:children].each_with_index do |((namespace, type), next_level), idx|
+        io.write("\n\n") if idx > 0
+        io.write(indent("#{type} #{namespace}", indent_level))
+        io.write("\n")
+        compose(next_level, io, indent_level + 1)
+        io.write("\n")
+        io.write(indent('end', indent_level))
+      end
+    end
+
+    def indent(str, indent_level)
+      str.split("\n").map { |s| "#{'  ' * indent_level}#{s}" }.join("\n")
+    end
+  end
+end

data/lib/gelauto/rspec.rb

@@ -0,0 +1,13 @@
+require 'gelauto'
+
+RSpec.configure do |config|
+  config.before(:suite) { Gelauto.setup }
+  config.after(:suite) do
+    Gelauto.teardown
+
+    Gelauto.each_absolute_path do |path|
+      Gelauto.annotate_file(path)
+      Gelauto::Logger.info("Annotated #{path}")
+    end
+  end
+end

data/lib/gelauto/type.rb

@@ -0,0 +1,18 @@
+module Gelauto
+  class Type
+    def self.introspect(obj)
+      new(obj.class)
+    end
+
+    attr_reader :ruby_type
+
+    def initialize(ruby_type)
+      @ruby_type = ruby_type
+    end
+
+    def to_sig
+      # i.e. class name
+      ruby_type.name
+    end
+  end
+end

data/lib/gelauto/type_set.rb

@@ -0,0 +1,61 @@
+require 'set'
+
+module Gelauto
+  class TypeSet
+    include Enumerable
+
+    attr_reader :set
+
+    def initialize
+      @set = {}
+    end
+
+    def size
+      set.size
+    end
+
+    def empty?
+      set.empty?
+    end
+
+    def <<(type)
+      set[type.ruby_type] = type
+    end
+
+    def merge!(other)
+      other.set.each do |other_ruby_type, other_type|
+        if set[other_ruby_type]
+          set[other_ruby_type].merge!(other_type)
+        else
+          set[other_ruby_type] = other_type
+        end
+      end
+    end
+
+    def each(&block)
+      set.each_value(&block)
+    end
+
+    def to_sig
+      nilable = false
+
+      sigs = set.each_with_object([]) do |(rt, t), ret|
+        if rt == ::NilClass
+          nilable = true
+        else
+          ret << t.to_sig
+        end
+      end
+
+      sigs.uniq!
+
+      if sigs.size == 0
+        'T.untyped'
+      elsif sigs.size == 1
+        sigs.first
+      else
+        "T.#{nilable ? 'nilable' : 'any'}(#{sigs.join(', ')})"
+      end
+    end
+  end
+end

data/lib/gelauto/utils.rb

@@ -0,0 +1,13 @@
+module Gelauto
+  module Utils
+    def each_absolute_path(paths)
+      return to_enum(__method__, paths) unless block_given?
+
+      paths.each do |path|
+        yield File.expand_path(path)
+      end
+    end
+
+    extend self
+  end
+end

data/lib/gelauto/var.rb

@@ -0,0 +1,17 @@
+require 'set'
+
+module Gelauto
+  class Var
+    attr_reader :name
+    attr_accessor :types
+
+    def initialize(name, types = TypeSet.new)
+      @name = name
+      @types = types
+    end
+
+    def to_sig
+      "#{name}: #{types.to_sig}"
+    end
+  end
+end

data/lib/gelauto/version.rb

@@ -0,0 +1,3 @@
+module Gelauto
+  VERSION = '1.0.0'
+end

data/lib/gelauto.rb

@@ -0,0 +1,124 @@
+require 'logger'
+require 'parser/current'
+
+module Gelauto
+  autoload :ArgList,     'gelauto/arg_list'
+  autoload :ArrayType,   'gelauto/array_type'
+  autoload :BooleanType, 'gelauto/boolean_type'
+  autoload :CLIUtils,    'gelauto/cli_utils'
+  autoload :GenericType, 'gelauto/generic_type'
+  autoload :HashType,    'gelauto/hash_type'
+  autoload :Logger,      'gelauto/logger'
+  autoload :MethodDef,   'gelauto/method_def'
+  autoload :MethodIndex, 'gelauto/method_index'
+  autoload :Namespace,   'gelauto/namespace'
+  autoload :Rbi,         'gelauto/rbi'
+  autoload :Type,        'gelauto/type'
+  autoload :TypeSet,     'gelauto/type_set'
+  autoload :Utils,       'gelauto/utils'
+  autoload :Var,         'gelauto/var'
+
+  class << self
+    attr_accessor :paths
+    attr_writer :logger
+
+    def setup
+      enable_traces
+      index_methods
+    end
+
+    def teardown
+      disable_traces
+    end
+
+    def discover
+      setup
+      yield
+    ensure
+      teardown
+    end
+
+    def method_index
+      @method_index ||= MethodIndex.new
+    end
+
+    def paths
+      @paths ||= []
+    end
+
+    def each_absolute_path(&block)
+      Utils.each_absolute_path(paths, &block)
+    end
+
+    def register_type(type, handler)
+      types[type] = handler
+    end
+
+    def types
+      @types ||= Hash.new(Gelauto::Type)
+    end
+
+    def introspect(obj)
+      Gelauto.types[obj.class].introspect(obj)
+    end
+
+    def annotate_file(path)
+      annotated_code = Gelauto.method_index.annotate(path, File.read(path))
+      File.write(path, annotated_code)
+    end
+
+    def logger
+      @logger ||= ::Logger.new(STDOUT)
+    end
+
+    private
+
+    def enable_traces
+      call_trace.enable
+      return_trace.enable
+    end
+
+    def disable_traces
+      call_trace.disable
+      return_trace.disable
+    end
+
+    def index_methods
+      each_absolute_path.with_index do |path, idx|
+        begin
+          method_index.index_methods_in(
+            path, Parser::CurrentRuby.parse(File.read(path))
+          )
+
+          Gelauto::Logger.info("Indexed #{idx + 1}/#{paths.size} paths")
+        rescue Parser::SyntaxError => e
+          Gelauto::Logger.error("Syntax error in #{path}, skipping")
+        end
+      end
+    end
+
+    def call_trace
+      @call_trace ||= TracePoint.new(:call) do |tp|
+        if md = method_index.find(tp.path, tp.lineno)
+          md.args.each do |arg|
+            var = tp.binding.local_variable_get(arg.name)
+            arg.types << Gelauto.introspect(var)
+          end
+        end
+      end
+    end
+
+    def return_trace
+      @return_trace ||= TracePoint.new(:return) do |tp|
+        if md = method_index.find(tp.path, tp.lineno)
+          md.return_types << Gelauto.introspect(tp.return_value)
+        end
+      end
+    end
+  end
+end
+
+Gelauto.register_type(::Hash, Gelauto::HashType)
+Gelauto.register_type(::Array, Gelauto::ArrayType)
+Gelauto.register_type(::TrueClass, Gelauto::BooleanType)
+Gelauto.register_type(::FalseClass, Gelauto::BooleanType)

data/spec/gelauto_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe Gelauto do
+  before { index.reset }
+
+  let(:index) { Gelauto.method_index }
+
+  context 'with simple types' do
+    it 'identifies method signatures correctly' do
+      img = nil
+
+      Gelauto.discover do
+        img = GelautoSpecs::Image.new('foo.jpg', 800, 400)
+        expect(img.aspect_ratio).to eq(2.0)
+      end
+
+      init = get_indexed_method(img, :initialize)
+      expect(init).to accept(path: String, width: Integer, height: Integer)
+      expect(init).to hand_back_void
+
+      aspect_ratio = get_indexed_method(img, :aspect_ratio)
+      expect(aspect_ratio).to hand_back(Float)
+    end
+  end
+
+  context 'with generic types' do
+    before do
+      Gelauto.discover do
+        @client = GelautoSpecs::Client.new(url: 'http://foo.com', username: 'bar')
+        @response = @client.request('body', param1: 'abc', param2: 'def')
+        expect(@response.to_a).to eq([200, 'it worked!'])
+      end
+    end
+
+    it 'identifies signature for Client#initialize' do
+      init = get_indexed_method(@client, :initialize)
+      expect(init).to accept(options: { Hash => { key: Symbol, value: String } })
+      expect(init).to hand_back_void
+    end
+
+    it 'identifies signature for Client#request' do
+      request = get_indexed_method(@client, :request)
+      expect(request).to accept(body: String, headers: { Hash => { key: Symbol, value: String } })
+      expect(request).to hand_back(GelautoSpecs::Response)
+    end
+
+    it 'identifies signature for Response#initialize' do
+      init = get_indexed_method(@response, :initialize)
+      expect(init).to accept(status: Integer, body: String)
+      expect(init).to hand_back_void
+    end
+
+    it 'identifies signature for Response#to_a' do
+      to_a = get_indexed_method(@response, :to_a)
+      expect(to_a).to hand_back(Array => { elem: [Integer, String] })
+    end
+  end
+
+  context 'with nested generic types' do
+    before do
+      Gelauto.discover do
+        GelautoSpecs::System.configure(YAML.load_file('spec/support/config.yml'))
+      end
+    end
+
+    it 'identifies signatures for System.configure' do
+      configure = get_indexed_method(GelautoSpecs::System, :configure)
+      expect(configure).to accept(
+        config: {
+          Hash => {
+            key: String,
+            value: [
+              {
+                Array => {
+                  elem: [
+                    String,
+                    {
+                      Hash => {
+                        key: String,
+                        value: {
+                          Hash => {
+                            key: String,
+                            value: [
+                              String,
+                              {
+                                Array => {
+                                  elem: String
+                                }
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            ]
+          }
+        }
+      )
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+$:.push(File.dirname(__FILE__))
+
+require 'rspec'
+require 'gelauto'
+require 'pry-byebug'
+
+Dir.chdir('spec') do
+  Dir.glob('support/*.rb').each do |f|
+    require f
+  end
+end
+
+RSpec.configure do |config|
+  config.include(GelautoSpecs::AcceptMatcher)
+  config.include(GelautoSpecs::HandBackMatcher)
+
+  config.include(
+    Module.new do
+      def get_indexed_method(obj, method_name)
+        path, lineno = obj.method(method_name).source_location
+        Gelauto.method_index.find(path, lineno)
+      end
+    end
+  )
+end
+
+# quiet logs for test runs
+Gelauto.logger.level = :fatal

data/spec/support/client.rb

@@ -0,0 +1,29 @@
+module GelautoSpecs
+  class Response
+    attr_reader :status, :body
+
+    def initialize(status, body)
+      @status = status
+      @body = body
+    end
+
+    def to_a
+      [status, body]
+    end
+  end
+
+  class Client
+    attr_reader :url, :username
+
+    def initialize(options = {})
+      @url = options[:url]
+      @username = options[:username]
+    end
+
+    def request(body, headers = {})
+      Response.new(200, 'it worked!')
+    end
+  end
+end
+
+Gelauto.paths << __FILE__

data/spec/support/config.yml

@@ -0,0 +1,8 @@
+param1:
+  - item1
+  - item2
+  - item3:
+      nested1: foo
+      nested2:
+        - bar
+        - baz

data/spec/support/image.rb

@@ -0,0 +1,17 @@
+module GelautoSpecs
+  class Image
+    attr_reader :path, :width, :height
+
+    def initialize(path, width, height)
+      @path = path
+      @width = width
+      @height = height
+    end
+
+    def aspect_ratio
+      width.to_f / height
+    end
+  end
+end
+
+Gelauto.paths << __FILE__

data/spec/support/matchers.rb

@@ -0,0 +1,103 @@
+module GelautoSpecs
+  def self.arg_hash_to_arglist(params)
+    Gelauto::ArgList.new.tap do |arg_list|
+      params.each_pair do |name, type_info|
+        arg_list << case type_info
+          when Hash
+            Gelauto::Var.new(name).tap do |v|
+              v.types.merge!(type_hash_to_typeset(type_info))
+            end
+          else
+            Gelauto::Var.new(name).tap do |v|
+              Array(type_info).each { |t| v.types << Gelauto::Type.new(t) }
+            end
+        end
+      end
+    end
+  end
+
+  def self.type_hash_to_typeset(type_info)
+    Gelauto::TypeSet.new.tap do |typeset|
+      type_info.each_pair do |type, generics|
+        type = Gelauto.types[type].new
+
+        generics.each_pair do |generic_name, generic_type|
+          type.generic_args[generic_name].merge!(
+            case generic_type
+              when Hash
+                type_hash_to_typeset(generic_type)
+              else
+                type_array_to_typeset(Array(generic_type))
+            end
+          )
+        end
+
+        typeset << type
+      end
+    end
+  end
+
+  def self.type_array_to_typeset(params)
+    Gelauto::TypeSet.new.tap do |typeset|
+      params.each do |type_info|
+        case type_info
+          when Hash
+            typeset.merge!(type_hash_to_typeset(type_info))
+          when Array
+            typeset.merge!(type_array_to_typeset(type_info))
+          else
+            typeset << Gelauto::Type.new(type_info)
+        end
+      end
+    end
+  end
+
+  module AcceptMatcher
+    extend RSpec::Matchers::DSL
+
+    matcher :accept do |expected_params = {}|
+      match do |actual_md|
+        @expected_arg_list = GelautoSpecs.arg_hash_to_arglist(expected_params)
+        @expected_arg_list.to_sig == actual_md.args.to_sig
+      end
+
+      failure_message do |actual_md|
+        <<~END
+          Expected: #{@expected_arg_list.to_sig}
+               Got: #{actual_md.args.to_sig}
+        END
+      end
+    end
+  end
+
+  module HandBackMatcher
+    extend RSpec::Matchers::DSL
+
+    matcher :hand_back do |*expected_types|
+      match do |actual_md|
+        @expected_typeset = GelautoSpecs.type_array_to_typeset(expected_types)
+        @expected_typeset.to_sig == actual_md.return_types.to_sig
+      end
+
+      failure_message do |actual_md|
+        <<~END
+          Expected: #{@expected_typeset.to_sig}
+               Got: #{actual_md.return_types.to_sig}
+        END
+      end
+    end
+
+    matcher :hand_back_void do
+      match do |actual_md|
+        actual_md.to_sig.end_with?('.void }')
+      end
+
+      failure_message do |actual_md|
+        <<~END
+          Expected: void
+               Got: #{actual_md.return_types.to_sig}
+        END
+      end
+    end
+  end
+end

data/spec/support/system.rb

@@ -0,0 +1,10 @@
+module GelautoSpecs
+  class System
+    def self.configure(config)
+      @config = config
+      nil
+    end
+  end
+end
+
+Gelauto.paths << __FILE__

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: gelauto
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Cameron Dutro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Automatically annotate your code with Sorbet type definitions.
+email:
+- camertron@gmail.com
+executables:
+- gelauto
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- README.md
+- Rakefile
+- bin/gelauto
+- gelauto.gemspec
+- lib/gelauto.rb
+- lib/gelauto/arg_list.rb
+- lib/gelauto/array_type.rb
+- lib/gelauto/boolean_type.rb
+- lib/gelauto/cli_utils.rb
+- lib/gelauto/generic_type.rb
+- lib/gelauto/hash_type.rb
+- lib/gelauto/logger.rb
+- lib/gelauto/method_def.rb
+- lib/gelauto/method_index.rb
+- lib/gelauto/namespace.rb
+- lib/gelauto/rbi.rb
+- lib/gelauto/rspec.rb
+- lib/gelauto/type.rb
+- lib/gelauto/type_set.rb
+- lib/gelauto/utils.rb
+- lib/gelauto/var.rb
+- lib/gelauto/version.rb
+- spec/gelauto_spec.rb
+- spec/spec_helper.rb
+- spec/support/client.rb
+- spec/support/config.yml
+- spec/support/image.rb
+- spec/support/matchers.rb
+- spec/support/system.rb
+homepage: http://github.com/camertron/gelauto
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.4
+signing_key: 
+specification_version: 4
+summary: Automatically annotate your code with Sorbet type definitions.
+test_files: []