type_tracer 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5e49de66db3b5881bb0f7b967e38c6b5f629de42
+  data.tar.gz: aad4ad204a948e8dc7463a89d9b3325e52b2de73
+SHA512:
+  metadata.gz: 818a27edfff25e29d7773ac7784afddd9deda31e48a803ea57d35b670a18cf8a2799466fef4a7187493fa82c353f976ab5248de8a38dc2be75de0ca31ff59f8a
+  data.tar.gz: cc2d23289aacd3365347acdd88ac8fe8f856b8f152fa05f076df4374ca06081265aee0b7afcc6c3e278f83751a3a07e5d165f7247b8fe87cb2d1bf6c1d34f769

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Session.vim

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,8 @@
+AllCops:
+  TargetRubyVersion: 2.3
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 99

data/.travis.yml

@@ -0,0 +1,7 @@
+sudo: false
+cache:
+  bundler: true
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in type_tracer.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 draffensperger
+
+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,197 @@
+# TypeTracer
+
+[![Build Status](https://travis-ci.org/draffensperger/type_tracer.svg?branch=master)](https://travis-ci.org/draffensperger/type_tracer) [![Code Climate](https://codeclimate.com/github/draffensperger/type_tracer.png)](https://codeclimate.com/github/draffensperger/type_tracer)
+
+TypeTracer collects a set of experimental approaches to checking Ruby
+"types" (particularly method signatures) while still allowing a decent level of
+metaprogramming and without needing to specify annotations in the production
+code.
+
+It includes three proof-of-concept approaches to catch some `NoMethodError`
+cases automatically.
+
+See [tt_demos](https://github.com/draffensperger/tt_demos) for an example of using
+approach 1.,
+and [quote-randomizer](https://github.com/draffensperger/quote-randomizer)
+for a simple Rails app that incorporates support for approaches 2. and 3.
+
+### 1. Enhancing RSpec `instance_double` to check stubbed argument values
+
+Even if you have 100% unit test coverage, there still can be invalid method
+calls in the "seams" between your classes or groups of classes.
+
+RSpec's [Verifying Doubles](https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles),
+such as `instance_double` will check that stubbed method calls are actually
+defined on a instance of the class you specify and that the method arity (number
+of arguments) matches what you are stubbing.
+
+This gem includes a file you can include which monkey-patches `instance_double`
+to parse the abstract syntax tree of the stubbed method to check whether the
+arguments to the stubbed call would result in an `NoMethodError` were they actually to be passed into the stubbed method.
+
+To make your `instance_double`'s behave like that, include `type_tracer` in your
+`Gemfile` and add `require 'type_tracer/rspec/Instance_double_arg_checker`.
+
+It can only reliably assume that a method will be called on the actual value of
+an argument if that argument variable isn't reassigned and if the method doesn't
+contain any branches (because it could branch on the type of the argument). A
+lot of methods contain branches, so I may try to tighten that requirement (e.g.
+that the expression that it branches on must involve the argument).
+
+### 2. Check instance method calls in app environment (for runtime defined methods)
+
+It's very difficult / impossible to simply statically analyze Ruby code for
+undefined methods (though see the
+[ruby-lint](https://github.com/YorickPeterse/ruby-lint) gem for something that
+does a decent job at it).
+
+The approach here is instead to combine static and dynamic analysis of a Ruby program.
+That is to run the "undefined method" analysis in the context of a fully loaded
+app environment where many/most of the dynamically defined methods have been
+defined. In a typical Rails app for instance, the `has_many` association methods
+would be defined when a class is loaded.
+
+However, the database attribute methods for `ActiveRecord` objects won't be
+defined until a request on that class is made e.g. from a call to `new`. My idea
+would be for `TypeTracer` to provide a config option for a block that could be
+called to induce most of the dynamically defined methods to get defined, e.g. by
+calling `new` on all of the `ActiveRecord::Base` subclasses and perhaps doing
+other application-specific method defining. Of course, not all dynamic methods
+are defined in easy-to-induce ways, but this would still catch a lot of them.
+
+To use it, include the `type_tracer` gem in your `Gemfile`, then, assuming
+you're running a Rails app, you can run a new Rake task
+`rake type_tracer:check_method_calls` that will check for undefined top-level
+instance method calls (i.e. calls on `self` in methods).
+
+It's possible that you will have methods that are defined not at the time that a
+class is first loaded but later in the app runtime. E.g. ActiveRecord attribute
+methods aren't defined until the first ActiveRecord operation for that model.
+
+What `type_tracer` provides is a config option called `attribute_methods_definer`
+that specifies a proc that is called after the app environment is loaded but
+before the analysis starts. Here's an example that will call `new` on all
+classes that inherit from `ActiveRecord::Base` which will have the effect of
+making those classes define their attribute methods.
+
+```
+# config/initializers/type_tracer.rb
+require 'type_tracer'
+
+TypeTracer.config do |config|
+  config.attribute_methods_definer = proc do
+    # initialize all of the active record models so that they will define their
+    # attribute methods.
+    ActiveRecord::Base.descendants.each(&:new)
+  end
+end
+```
+
+This is similar to how you would define attribute methods for a dynamic class if
+you are using RSpec verifying doubles, see their doc for
+[dynamic-classes](https://relishapp.com/rspec/rspec-mocks/docs/verifying-doubles/dynamic-classes)
+
+### 3A. Sampling implied types from production to use in further analysis
+
+This is not a direct way to catch bad method calls, but it's an idea to use the
+running production application to gather the real implicit type signature for
+methods and then feed that back into the specs or analysis tools as more
+realistic type information (without needing to annotate production code or be
+super-specific about what the types actually are).
+
+It's common, for instance, for a method to take either `nil` or a specific value.
+It's also decently comment for a method to take a "duck type" i.e. it could take
+instances of a range of classes but call a fixed set of methods on all of them.
+Sometimes too a method may have an explicit `is_a?` check and do different
+things for different types (e.g. a method that operates recursively on a nested
+structure that could be either an Array or Hash).
+
+To try to represent as many of those cases as possible, the traced types are in
+effect union types of all the different classes that are passed in and what
+methods are called on instances of those different classes.
+
+To use type tracing in your Rails app, include the `type_tracer` gem, and then
+add an initializer like this:
+
+```
+# config/initializers/type_tracer.rb
+require 'type_tracer'
+
+TypeTracer.config do |config|
+  # This configures an Rack middleware for what requests to type sample on
+  config.sample_types_for_requests do |_rack_env|
+    # Only type sample 1% of requests
+    rand() > 0.01
+  end
+
+  # These configure the files to do type sampling on and the remote URL of the
+  # sampled types endpoint in a deployed app.
+  config.type_check_root_path = Rails.root
+  config.type_check_path_regex = %r{\A(app|lib)/}
+  config.sampled_types_url = 'https://quote-randomizer.herokuapp.com/sampled_types'
+
+  # To make the sampled types useful for checking local changes, we need to be
+  # able to know the git commit that produced the sampled types in case they are
+  # no longer applicable given local changes (if you changed the callers of the
+  # method in question).
+  # This will give the git commit on Heroku, though requires this buildpack:
+  # https://github.com/ianpurvis/heroku-buildpack-version
+  config.git_commit = ENV['SOURCE_VERSION']
+end
+```
+
+You'll also need to set up an endpoint in your app that will serve the sampled
+types (as referenced above with the `sampled_types_url`). Here's an example
+controller (that would need a corresponding route as well):
+
+```
+class SampledTypesController < ApplicationController
+  def show
+    render json: JSON.pretty_generate(TypeTracer::TypeSampler.sampled_type_info)
+  end
+end
+```
+
+### 3B. Using sampled types to check local changes to a method for undefined method calls on arguments
+
+To use the sampled method type signatures from a deployed app, run
+`rake type_tracer:check_arg_sends`. That will fetch the sampled types and Git
+commit hash from your specified `sampled_types_url`. It assumes you are using
+Git for your project and have the `git` executable installed.
+
+A similar caveat to the expanded `instance_double` above holds, that the
+checking will assume the method is correct if it either contains branches or a
+re-assignment of the argument variable (because those cases are harder to
+analyze and a common idiom is e.g. `return if x.nil?` or `x ||= default_value`
+both of which could change the type of the `x` argument).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'type_tracer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install type_tracer
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/type_tracer.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'type_tracer'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/rspec

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+#
+# This file was generated by Bundler.
+#
+# The application 'rspec' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'pathname'
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile',
+                                           Pathname.new(__FILE__).realpath)
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('rspec-core', 'rspec')

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/type_tracer/arg_send_type_check/ast_checker.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module TypeTracer
+  module ArgSendTypeCheck
+    class AstChecker
+      def initialize(ast:, types:)
+        @ast = ast
+        @types = types
+      end
+
+      def bad_arg_sends
+        method_defs.flat_map(&method(:method_bad_arg_sends))
+      end
+
+      private
+
+      def method_defs
+        @ast.each_descendant.select(&:def_type?)
+      end
+
+      def method_bad_arg_sends(method_def)
+        class_sym = method_class_sym(method_def)
+        method_sym = method_def.children.first
+
+        return [] unless @types && @types[class_sym] &&
+                         @types[class_sym][method_sym]
+
+        arg_types = @types[class_sym][method_sym][:arg_types]
+        MethodChecker.new(method_def: method_def, method_sym: method_sym,
+                          class_sym: class_sym, arg_types: arg_types)
+                     .bad_arg_send_messages
+      end
+
+      def method_class_sym(method_def)
+        context_ancestors = method_def.each_ancestor.select do |ancestor|
+          ancestor.class_type? || ancestor.module_type?
+        end
+        const_ancestors = context_ancestors.map { |n| n.children.first }
+        const_path = const_ancestors.map { |n| n.children[1] }
+        const_path.join('::').to_sym
+      end
+    end
+  end
+end

data/lib/type_tracer/arg_send_type_check/method_checker.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+module TypeTracer
+  module ArgSendTypeCheck
+    class MethodChecker
+      def initialize(method_def:, method_sym:, class_sym:, arg_types:)
+        @method_def = method_def
+        @method_sym = method_sym
+        @class_sym = class_sym
+        @arg_types = arg_types
+      end
+
+      def bad_arg_send_messages
+        # For each argument to the method
+        analyzer.arg_names.flat_map(&method(:bad_arg_sends)).compact
+      end
+
+      private
+
+      def bad_arg_sends(arg)
+        # For each of the sampled type classes for that argument
+        @arg_types[arg].flat_map do |arg_type|
+          bad_arg_sends_for_type(arg, arg_type[0])
+        end
+      end
+
+      def bad_arg_sends_for_type(arg, arg_type)
+        # Look up the sampled type class. We can do that because this runs with
+        # the app environment loaded into it.
+        type_class = Object.const_get(arg_type)
+
+        # For each of the statically-analyzed send calls on that argument
+        analyzer.arg_sends[arg].flat_map do |arg_send|
+          # Check to see if the send call (in a locally changed method)
+          # would be invalid based on the sampled type information (from the
+          # method as it is deployed currently).
+          next if instance_method?(type_class, arg_send)
+          bad_arg_send_message(arg, type_class, arg_send)
+        end
+      end
+
+      def analyzer
+        @analyzer ||= MethodAnalyzer.new(method_def: @method_def)
+      end
+
+      def bad_arg_send_message(arg_name, arg_type, arg_send)
+        source = @method_def.source_range
+        "The method #{@class_sym}##{@method_sym} as type sampled may receive a "\
+          "value of type #{arg_type} for the argument '#{arg_name}'. "\
+          "However, that type (#{arg_type}) does not contain the instance "\
+          "method '#{arg_send}' that the method tries to call on it. \n"\
+          'Method location:'\
+          "\n  #{source.source_buffer.name}:#{source.line}\n"
+      end
+
+      def instance_method?(klass, symbol)
+        klass.instance_methods.include?(symbol) ||
+          klass.private_instance_methods.include?(symbol)
+      end
+    end
+  end
+end

data/lib/type_tracer/arg_send_type_check/runner.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module TypeTracer
+  module ArgSendTypeCheck
+    class Runner
+      def initialize(files)
+        @files = files
+      end
+
+      def bad_arg_sends
+        @files.flat_map do |file|
+          ast = TypeTracer.parse_file(file)
+          AstChecker.new(ast: ast, types: filtered_types).bad_arg_sends
+        end
+      end
+
+      private
+
+      def changed_files
+        @changed_files ||=
+          `git diff --name-only #{fetched_types[:git_commit]}`.split("\n")
+      end
+
+      def fetched_types
+        @fetched_types ||= TypeFetcher.fetch_sampled_types
+      end
+
+      def filtered_types
+        @filtered_types ||= filter_types
+      end
+
+      def filter_types
+        type_info = fetched_types[:type_info]
+        type_info.each do |klass_sym, method_types|
+          method_types.each do |method_sym, method_type_info|
+            # All the callers of this method have at least one file changed, so
+            # assume that this method type signature may no longer be valid.
+            if all_have_changed_file(method_type_info[:callers])
+              # Remove it from the type list
+              type_info[klass_sym].delete(method_sym)
+            end
+          end
+        end
+      end
+
+      def all_have_changed_file(call_stacks)
+        call_stacks.all? do |call_stack|
+          stack_files = call_stack.map { |frame| frame.split(':')[0] }
+          !(stack_files & changed_files).empty?
+        end
+      end
+    end
+  end
+end

data/lib/type_tracer/config.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+require 'singleton'
+
+module TypeTracer
+  class Config
+    include Singleton
+
+    attr_accessor :attribute_methods_definer, :type_check_root_path,
+                  :type_check_path_regex, :git_commit, :sampled_types_url
+
+    # Set this by giving a block to sample_types_for_requests
+    attr_reader :rack_type_sample_decider
+
+    def initialize
+      @type_sampler_root_path = Dir.pwd
+    end
+
+    def sample_types_for_requests(&block)
+      @rack_type_sample_decider = block.to_proc
+    end
+  end
+end

data/lib/type_tracer/instance_method_checker.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+require 'type_tracer/parser'
+
+module TypeTracer
+  class InstanceMethodChecker
+    def initialize(ast)
+      @ast = ast
+    end
+
+    def undefined_method_messages
+      self_sends.map(&method(:bad_self_send_messages)).compact
+    end
+
+    private
+
+    def self_sends
+      @ast.each_descendant.select do |node|
+        node.send_type? && node.children.first.nil?
+      end
+    end
+
+    def bad_self_send_messages(send_node)
+      symbol = send_node.children[1]
+
+      # private/protected specifiers are parsed as a send, so just ignore them
+      # define_method also doesn't get listed as a method but is one!
+      return if [:private, :protected, :define_method].include?(symbol)
+
+      # Look up the class for the AST send node in the loaded Ruby
+      # environment. We can do that because this is being run in a Rake
+      # rask with the loaded app environment.
+      klass = loaded_class(send_node)
+      return if klass.instance_methods.include?(symbol) ||
+                klass.private_instance_methods.include?(symbol) ||
+                klass.respond_to?(symbol)
+
+      # The abstract syntax tree keeps a reference to the node's file/line
+      source = send_node.source_range
+      "Likely undefined method: #{symbol} for #{klass} instance"\
+        "\n  in #{source.source_buffer.name}:#{source.line}\n\n"
+    end
+
+    def loaded_class(send_node)
+      context_ancestors = send_node.each_ancestor.select do |ancestor|
+        ancestor.class_type? || ancestor.module_type?
+      end
+      const_ancestors = context_ancestors.map { |n| n.children.first }
+      const_path = const_ancestors.map { |n| n.children[1] }
+      Object.const_get(const_path.join('::'))
+    end
+  end
+end

data/lib/type_tracer/method_analyzer.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+module TypeTracer
+  class MethodAnalyzer
+    def initialize(method_def:)
+      @method_def = method_def
+    end
+
+    def arg_names
+      @arg_names ||= args.children.map { |arg_node| arg_node.children.first }
+    end
+
+    def arg_sends
+      return @arg_sends if @arg_sends
+      # For the simple version, just assume we don't know what will happen if
+      # there are branches in the method, so assume that no args definitely get
+      # called (as there could be conditioning on arg type).
+      @arg_sends =
+        if branches?
+          empty_arg_sends
+        else
+          Hash[arg_names.map { |arg| [arg, sends_for_arg(arg)] }]
+        end
+    end
+
+    private
+
+    def branches?
+      @method_def.each_descendant.any? { |node| node.if_type? || node.case_type? }
+    end
+
+    def empty_arg_sends
+      Hash[arg_names.map { |n| [n, []] }]
+    end
+
+    def sends_for_arg(arg)
+      # Assume that if there are any assignments to the local variable for the
+      # argument that we can't confidently know the type of the argument anymore
+      # even if we know its type coming in, so don't assume we know what sends
+      # are made on the initial argument value itself.
+      if local_var_assigns.include?(arg)
+        []
+      else
+        local_var_sends[arg].to_a
+      end
+    end
+
+    def args
+      @method_def.each_descendant.find(&:args_type?)
+    end
+
+    def local_var_sends
+      return @local_var_sends if @local_var_sends
+      @local_var_sends = {}
+
+      local_var_send_nodes.map do |send_node|
+        object, method_sym = send_node.children[0..1]
+        local_var = object.children.first
+        @local_var_sends[local_var] ||= Set.new
+        @local_var_sends[local_var] << method_sym
+      end
+
+      @local_var_sends
+    end
+
+    def local_var_assigns
+      return @local_var_assigns if @local_var_assigns
+      @local_var_assigns = Set.new
+      @method_def.each_descendant do |node|
+        @local_var_assigns << node.children.first if node.lvasgn_type?
+      end
+      @local_var_assigns
+    end
+
+    def local_var_send_nodes
+      @method_def.each_descendant.select do |node|
+        node.children && node.children.first && node.send_type? &&
+          node.children.first.lvar_type?
+      end
+    end
+  end
+end

data/lib/type_tracer/parser.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require 'rubocop'
+require 'parser/current'
+Parser::Builders::Default.emit_lambda = true
+
+module TypeTracer
+  class << self
+    def parse_file(file)
+      parse(File.read(file), file)
+    end
+
+    def parse(source, filename = '(string)')
+      buffer = Parser::Source::Buffer.new(filename)
+      buffer.source = source
+
+      builder = RuboCop::Node::Builder.new
+      parser = Parser::CurrentRuby.new(builder)
+      parser.parse(buffer)
+    end
+  end
+end

data/lib/type_tracer/rack/type_sampler_middleware.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+require 'type_tracer/type_sampler'
+
+module TypeTracer
+  class TypeSamplerMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      sample_decider = TypeTracer.config.rack_type_sample_decider
+      TypeSampler.start if sample_decider && sample_decider.call(env)
+      @app.call(env)
+    ensure
+      TypeSampler.stop
+    end
+  end
+end

data/lib/type_tracer/rails/railtie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+# rake tasks for Rails 3+
+module TypeTracer
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      require 'type_tracer/rake/tasks'
+    end
+
+    initializer 'type_tracer.insert_middleware' do |app|
+      require 'type_tracer/rack/type_sampler_middleware.rb'
+      app.config.middleware.use 'TypeTracer::TypeSamplerMiddleware'
+    end
+  end
+end

data/lib/type_tracer/rake/tasks.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+require 'type_tracer'
+
+desc 'Checks for undefined instance methods'
+namespace :type_tracer do
+  task check_method_calls: :environment do |_, _args|
+    root_dir = defined?(Rails) ? Rails.root : '.'
+    ruby_files = Dir.glob(root_dir.join('app/**/*.rb'))
+    ruby_files.each { |file| load(file) }
+
+    # Call the configured attribute methods definer to define
+    # methods on classes, e.g. initialize ActiveRecord models
+    TypeTracer.config.attribute_methods_definer.try(:call)
+
+    exit(1) unless undefined_method_messages(ruby_files).empty?
+  end
+
+  def undefined_method_messages(ruby_files)
+    ruby_files.flat_map do |file|
+      ast = TypeTracer.parse_file(file)
+      messages = TypeTracer::InstanceMethodChecker.new(ast).undefined_method_messages
+      messages.each(&method(:puts))
+      messages
+    end
+  end
+
+  task check_arg_sends: :environment do |_, _args|
+    root_dir = TypeTracer.config.type_check_root_path.to_s + '/'
+    files = Dir.glob(File.join(root_dir, '**/*.rb'))
+    TypeTracer.config.type_check_path_regex = %r{\A(app|lib)/}
+    type_check_files = files.select do |file|
+      project_path = file[root_dir.size..-1]
+      project_path =~ TypeTracer.config.type_check_path_regex
+    end
+
+    type_check_files.each { |file| load(file) }
+
+    runner = TypeTracer::ArgSendTypeCheck::Runner.new(type_check_files)
+    bad_arg_sends = runner.bad_arg_sends
+    bad_arg_sends.each { |message| puts message }
+    exit(1) if bad_arg_sends.present?
+  end
+end

data/lib/type_tracer/real_arg_sends_checker.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+module TypeTracer
+  class RealArgSendsChecker
+    def initialize(klass, symbol, args)
+      @klass = klass
+      @symbol = symbol
+      @args = args
+    end
+
+    def invalid_arg_messages
+      @args.each_with_index.flat_map(&method(:message_if_invalid_arg)).compact
+    end
+
+    private
+
+    # arg_value is the real argument value that we would be calling this method
+    # with (based on the method call on the stub).
+    # index is the argument's position in the call
+    def message_if_invalid_arg(arg_value, index)
+      arg_sends = method_analyzer.arg_sends.values[index]
+      return unless arg_sends
+
+      # arg_sends is the list of definite method calls on that argument that
+      # the static analyzer detected. If there are branches in the method or
+      # assignments to that argument in the method, the analyzer is conservative
+      # and doesn't assume that the sends will necessarily be on this value.
+      arg_sends.each do |arg_send|
+        next if arg_value.respond_to?(arg_send)
+
+        # Give an invalid arg message if the arg doesn't respond to the call
+        # that the stubbed method would make on it.
+        return invalid_arg_message(arg_value, arg_send, index)
+      end
+      nil
+    end
+
+    def invalid_arg_message(arg_value, arg_send, index)
+      "Called stubbed method #{@klass}##{@symbol} with unrealistic "\
+        "'#{method_analyzer.arg_names[index]}' argument: #{arg_value.inspect}. "\
+        "It should respond to #{arg_send.inspect} but it does not."
+    end
+
+    def method_analyzer
+      @method_analyzer ||= MethodAnalyzer.new(method_def: method_ast)
+    end
+
+    def method_ast
+      @method_ast ||=
+        begin
+          file, _line = @klass.instance_method(@symbol).source_location
+          ast = TypeTracer.parse_file(file)
+          find_method_def(ast, @symbol)
+        end
+    end
+
+    def find_method_def(ast, method_symbol)
+      ast.each_descendant.find do |node|
+        node.def_type? && node.children.first == method_symbol
+      end
+    end
+  end
+end

data/lib/type_tracer/rspec/instance_double_arg_checker.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+require 'rspec/mocks'
+require 'type_tracer'
+require 'type_tracer/real_arg_sends_checker'
+
+module RSpec
+  module Mocks
+    class VerifyingMethodDouble
+      alias orig_proxy_method_invoked proxy_method_invoked
+
+      def proxy_method_invoked(obj, *args, &block)
+        orig_proxy_method_invoked(obj, *args, &block)
+        return unless obj.is_a?(InstanceVerifyingDouble)
+
+        name = @method_reference.instance_variable_get('@method_name')
+        klass = @method_reference.instance_variable_get('@object_reference')
+                                 .instance_variable_get('@object')
+
+        checker = TypeTracer::RealArgSendsChecker.new(klass, name, args)
+        messages = checker.invalid_arg_messages
+        raise MockExpectationError.new, messages.join("\n") unless messages.empty?
+      end
+    end
+  end
+end

data/lib/type_tracer/sends_watcher.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+class SendsWatcher < BasicObject
+  def initialize(target, calls_list)
+    @target = target
+    @calls_list = calls_list
+  end
+
+  def method_missing(m, *args, &block)
+    @calls_list << m unless @calls_list.include?(m)
+    @target.send(m, *args, &block)
+  end
+end

data/lib/type_tracer/type_fetcher.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+require 'net/http'
+require 'json'
+require 'fileutils'
+
+module TypeTracer
+  class TypeFetcher
+    class << self
+      def fetch_sampled_types
+        url = TypeTracer.config.sampled_types_url
+        puts "Using sampled types from: #{url}\n\n"
+        json = Net::HTTP.get(URI.parse(url))
+        save_types_locally(json)
+        JSON.parse(json).deep_symbolize_keys
+      end
+
+      def save_types_locally(types_json)
+        root_path = TypeTracer.config.type_check_root_path
+        folder = File.join(root_path, 'tmp', 'type_tracer')
+        FileUtils.mkdir_p(folder)
+        file = File.join(folder, 'sampled_types.json')
+        File.write(file, types_json)
+      end
+    end
+  end
+end

data/lib/type_tracer/type_sampler.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+require 'type_tracer/sends_watcher'
+
+module TypeTracer
+  class TypeSampler
+    class << self
+      def start
+        @project_root ||= TypeTracer.config.type_check_root_path.to_s + '/'
+        @sample_path_regex ||= TypeTracer.config.type_check_path_regex
+        @ignored_classes ||= Set.new
+        @type_info_by_class ||= {}
+        @trace ||= TracePoint.new(:call, &method(:trace_method_call))
+        @trace.enable
+      end
+
+      def stop
+        return unless @trace && @trace.enabled?
+        @trace.disable
+      end
+
+      def sampled_type_info
+        {
+          git_commit: TypeTracer.config.git_commit,
+          type_info: @type_info_by_class
+        }
+      end
+
+      def clear_sampled_type_info
+        @type_info_by_class = {}
+      end
+
+      private
+
+      def trace_method_call(tp)
+        klass = tp.defined_class
+
+        # Skip if the method call is in this class or an ignored class
+        return if klass == self.class || @ignored_classes.include?(klass)
+
+        unbound_method = unbound_method_or_nil(tp)
+        return unless unbound_method
+
+        if in_sample_path?(unbound_method.source_location[0])
+          add_sampled_type_info(tp, unbound_method)
+        else
+          @ignored_classes << klass
+        end
+      end
+
+      def in_sample_path?(path)
+        return false unless path.start_with?(@project_root)
+        path[@project_root.size..-1] =~ @sample_path_regex
+      end
+
+      def unbound_method_or_nil(tp)
+        tp.defined_class.instance_method(tp.method_id)
+      rescue
+        # Return nil if the defined class fails to provide `instance_method`
+        nil
+      end
+
+      def add_sampled_type_info(tp, unbound_method)
+        method_info = find_method_info(tp, unbound_method)
+
+        add_project_call_stack(method_info[:callers])
+
+        arg_names = method_info[:args].map { |a| a[1] }
+        add_args_type_info(tp, method_info[:arg_types], arg_names)
+      end
+
+      def find_method_info(tp, unbound_method)
+        klass = tp.defined_class
+        @type_info_by_class[klass] ||= {}
+        class_type_info = @type_info_by_class[klass]
+        class_type_info[tp.method_id] ||= default_method_info(unbound_method)
+      end
+
+      def default_method_info(unbound_method)
+        { args: unbound_method.parameters, arg_types: {}, callers: [] }
+      end
+
+      def add_project_call_stack(call_stacks)
+        # Exclude non-project frames, and then also exclude the first project
+        # frame as that frame is for the method call we are type sampling.
+        stack = caller.select(&method(:in_sample_path?))[1..-1]
+                .map { |f| f[@project_root.size..-1] }
+        call_stacks << stack unless call_stacks.include?(stack)
+      end
+
+      def add_args_type_info(tp, args_type_info, arg_names)
+        arg_local_vars = arg_names & tp.binding.local_variables
+
+        arg_local_vars.each do |arg|
+          args_type_info[arg] ||= {}
+          add_arg_type_info(tp, args_type_info[arg], arg)
+        end
+      end
+
+      def add_arg_type_info(tp, arg_type_info, arg)
+        value = tp.binding.local_variable_get(arg)
+        value_klass = value.class
+
+        arg_type_info[value_klass] ||= []
+
+        # We can only do do a delegate-based type watching on truthy
+        # values because it's not possible to turn a custom object into a
+        # falsely value in Ruby
+        return unless value && !value.is_a?(Fixnum)
+        watcher = SendsWatcher.new(value, arg_type_info[value_klass])
+        tp.binding.local_variable_set(arg, watcher)
+      end
+    end
+  end
+end

data/lib/type_tracer/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module TypeTracer
+  VERSION = '0.1.0'
+end

data/lib/type_tracer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+Dir[File.join(File.dirname(__FILE__), 'type_tracer', '*.rb')].each do |file|
+  next if file =~ /version/
+  require File.join('type_tracer', File.basename(file, '.rb'))
+end
+require 'type_tracer/parser'
+require 'type_tracer/arg_send_type_check/ast_checker'
+require 'type_tracer/arg_send_type_check/method_checker'
+require 'type_tracer/arg_send_type_check/runner'
+require 'type_tracer/instance_method_checker'
+require 'type_tracer/config'
+require 'type_tracer/method_analyzer'
+
+module TypeTracer
+  class << self
+    def config
+      @config ||= TypeTracer::Config.instance
+      yield @config if block_given?
+      @config
+    end
+  end
+end
+
+require 'type_tracer/rails/railtie' if defined? Rails::Railtie

data/type_tracer.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'type_tracer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'type_tracer'
+  spec.version       = TypeTracer::VERSION
+  spec.authors       = ['draffensperger']
+  spec.email         = ['draff8660@gmail.com']
+
+  spec.summary       = 'Proof of concept tool for Ruby static/dynamic analysis'
+  spec.description   = 'Proof of concept tool for Ruby static/dynamic analysis'
+  spec.homepage      = 'https://github.com/draffensperger/type_tracer'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+                                        .reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency('parser', '>= 2.3.0.6', '< 3.0')
+  spec.add_runtime_dependency('activesupport', '~> 4.2.6')
+  spec.add_runtime_dependency('rubocop', '~> 0.39')
+
+  spec.add_development_dependency 'simplecov', '~> 0.11.2'
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'pry-byebug'
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: type_tracer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- draffensperger
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.0.6
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.6
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.39'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.39'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.11.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Proof of concept tool for Ruby static/dynamic analysis
+email:
+- draff8660@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/rspec
+- bin/setup
+- lib/type_tracer.rb
+- lib/type_tracer/arg_send_type_check/ast_checker.rb
+- lib/type_tracer/arg_send_type_check/method_checker.rb
+- lib/type_tracer/arg_send_type_check/runner.rb
+- lib/type_tracer/config.rb
+- lib/type_tracer/instance_method_checker.rb
+- lib/type_tracer/method_analyzer.rb
+- lib/type_tracer/parser.rb
+- lib/type_tracer/rack/type_sampler_middleware.rb
+- lib/type_tracer/rails/railtie.rb
+- lib/type_tracer/rake/tasks.rb
+- lib/type_tracer/real_arg_sends_checker.rb
+- lib/type_tracer/rspec/instance_double_arg_checker.rb
+- lib/type_tracer/sends_watcher.rb
+- lib/type_tracer/type_fetcher.rb
+- lib/type_tracer/type_sampler.rb
+- lib/type_tracer/version.rb
+- type_tracer.gemspec
+homepage: https://github.com/draffensperger/type_tracer
+licenses:
+- MIT
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: Proof of concept tool for Ruby static/dynamic analysis
+test_files: []