RubyでYARD定義を使って実行時にメソッド引数と戻り値の型チェックを試みる

module Animal

  #
  # This class is Dog
  #
  class Dog
    # @param name [String] a name
    # @param weight [Numeric] weight
    def initialize(name, weight)
      @name = name
      @weight = weight
      @children = []
    end

    # Add a child dog
    # 
    # @param dog [Animal::Dog] a child dog
    def add_child(dog)
      @children.push(dog)
    end

    # Run.
    # 
    # @param distance [Integer]
    # @return [String] message
    def run(distance)
      "#{@name} runs #{distance}."
    end

    # dummy method returns wrong type value
    # 
    # @return [Integer]
    def dummy
      "a string"
    end
  end

end

require 'rubygems'
require 'yard'

class MethodDefinition
  def initialize(method_obj)
    @name = method_obj.name(true)
    @args = []
    @ret = nil
    load_docstr(method_obj.docstring)
  end

  def validate_arguments(args)
    errors = []
    args.each_with_index do |arg, i|
      arg_def = @args[i]
      ts = arg_def.types
      result = ts.find { |t|
        klass = Object.const_get(t)
        arg.is_a?(klass)
      }
      if result.nil?
        if ts.count > 1
          errors.push "#{arg_def.name}: #{arg.inspect} isn't any of " + ts.join(',')
        else
          errors.push "#{arg_def.name}: #{arg.inspect} isn't #{ts[0]}"
        end
      end
    end
    errors.empty? ? nil : "#{@name}(" + errors.join(', ') + ")"
  end

  def validate_return(ret_val)
    return nil if @ret.nil?
    ts = @ret.types
    result = ts.find { |t|
    klass = Object.const_get(t)
    ret_val.is_a?(klass)
    }
    if result.nil?
      if ts.count > 1
        "#{@name} returned #{ret_val.inspect} isn't any of " + ts.join(',') + ")"
      else
        "#{@name} returned #{ret_val.inspect} isn't #{ts[0]})"
      end
    else
      nil
    end
  end

  def load_docstr(docstr)
    docstr.tags.each do |tag|
      tag_name = tag.tag_name
      if tag_name == 'param'
        @args.push OpenStruct.new({
          name: tag.name,
          types: tag.types
        })
      elsif tag_name == 'return'
        @ret = OpenStruct.new({ types: tag.types })
      end
    end
  end
end

class DefinitionStore
  def initialize
    @store = {}
    registry = YARD::Registry.load!
    registry.all(:class).each do |class_obj|
      add(class_obj)
    end
  end

  def add(class_obj)
    method_map = @store[class_obj.path] = {}
    class_obj.meths.each do |mt|
      method_map[mt.name] = MethodDefinition.new(mt)
    end
  end

  def get(klass_name, method_name)
    klass_def = @store[klass_name]
    klass_def[method_name]
  end
end

require 'tracer'
require_relative 'definition'

definition_store = DefinitionStore.new
TracePoint.trace(:call, :return) do |tp|
  klass_name = tp.defined_class.name
  method_def = definition_store.get(klass_name, tp.method_id)
  if tp.event == :call
    args = tp.binding.local_variables.map do |name|
      tp.binding.local_variable_get(name)
    end
    if err = method_def.validate_arguments(args)
      puts "Invalid call #{klass_name}#{err} on #{tp.path}:#{tp.lineno}"
    end
  elsif tp.event == :return && tp.method_id != :initialize
    if err = method_def.validate_return(tp.return_value)
      puts "Invalid return #{klass_name}#{err} on #{tp.path}:#{tp.lineno}"
    end
  end
end

# 試行
require_relative 'lib/dog'

dog1 = Animal::Dog.new(nil, "4.5")
p dog1.run(20)
dog1.dummy
dog2 = Animal::Dog.new("Taro", 6.5)
dog2.add_child(dog1)
dog2.add_child(nil)
p dog2.run(nil)