yardcheck 0.0.1

data/lib/yardcheck/color.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  module Color
+    private
+
+    def color(code, text)
+      "\e[#{code}m#{text}\e[0m"
+    end
+
+    def blue(text)
+      color(34, text)
+    end
+
+    def red(text)
+      color(31, text)
+    end
+
+    def yellow(text)
+      color(33, text)
+    end
+
+    def grey(text)
+      color(30, text)
+    end
+  end # Color
+end # Yardcheck

data/lib/yardcheck/const.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class Const
+    include Concord::Public.new(:constant)
+
+    def self.resolve(constant_name, scope = Object)
+      return new(scope.const_get(constant_name)) if scope.const_defined?(constant_name)
+
+      parent = parent_namespace(scope)
+      from_parent = resolve(constant_name, parent.constant) if parent.valid?
+      from_parent && from_parent.valid? ? from_parent : Invalid.new(scope, constant_name)
+    end
+
+    def self.parent_namespace(scope)
+      parent_name = scope.name.split('::').slice(0...-1).join('::')
+
+      if parent_name.empty?
+        Invalid.new(Object, parent_name)
+      else
+        resolve(parent_name)
+      end
+    end
+
+    def valid?
+      true
+    end
+
+    class Invalid < self
+      include Concord.new(:scope, :constant)
+
+      public :constant
+
+      def valid?
+        false
+      end
+    end # Invalid
+  end # Const
+end # Yardcheck

data/lib/yardcheck/documentation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class Documentation
+    include Concord.new(:yardocs), Memoizable
+
+    # mutest:disable
+    def self.parse
+      load_yard
+      new(YARD::Registry.all(:method))
+    end
+
+    # This is just YARD implementation details so I don't want to mutation cover this
+    # mutest:disable
+    def self.load_yard
+      # YARD doesn't write to .yardoc/ without this lock_for_writing and save
+      YARD::Registry.lock_for_writing do
+        YARD.parse(['lib/**/*.rb'], [], YARD::Logger::ERROR)
+        YARD::Registry.save(true)
+      end
+
+      YARD::Registry.load!
+    end
+
+    def method_objects
+      yardocs.map { |yardoc| MethodObject.new(yardoc) }
+    end
+  end # Documentation
+end # Yardcheck

data/lib/yardcheck/documentation/method_object.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class Documentation
+    class MethodObject
+      include Concord.new(:yardoc), Adamantium::Flat
+
+      def selector
+        yardoc.name
+      end
+
+      def namespace
+        singleton? ? unscoped_namespace.singleton_class : unscoped_namespace
+      end
+      memoize :namespace
+
+      def params
+        param_typedefs.select { |key, value| key && !value.invalid_const? }
+      end
+      memoize :params
+
+      def return_type
+        return_typedef unless return_typedef&.invalid_const?
+      end
+
+      def singleton?
+        scope.equal?(:class)
+      end
+
+      def scope
+        yardoc.scope
+      end
+
+      def location
+        [yardoc.file, yardoc.line]
+      end
+
+      def method_identifier
+        [namespace, selector, scope]
+      end
+
+      def shorthand
+        "#{namespace}##{selector}"
+      end
+
+      def source
+        [documentation_source, yardoc.source].join("\n")
+      end
+
+      def location_pointer
+        location.join(':')
+      end
+
+      def warnings
+        param_warnings = param_typedefs.select { |_, typedef| typedef.invalid_const? }.values
+        return_warning = return_typedef if return_typedef&.invalid_const?
+
+        [*param_warnings, *return_warning].map { |warning| Warning.new(self, warning) }
+      end
+
+      private
+
+      def return_typedef
+        return_tag.map(&method(:typedefs)).reduce(:+)
+      end
+      memoize :return_typedef
+
+      def return_tag
+        tags(:return)
+      end
+
+      def param_typedefs
+        tags(:param).map do |param_tag|
+          param_name = param_tag.name.to_sym if param_tag.name
+          [param_name, typedefs(param_tag)]
+        end.to_h
+      end
+      memoize :param_typedefs
+
+      def documentation_source
+        file_source.documentation_above(source_starting_line)
+      end
+
+      def source_starting_line
+        location.last
+      end
+
+      def file_source
+        SourceLines.process(File.read(location.first))
+      end
+      memoize :file_source
+
+      def typedefs(tags)
+        Typedef::Parser.new(qualified_namespace, tags.types.to_a).parse
+      end
+
+      def unscoped_namespace
+        Const.resolve(qualified_namespace).constant
+      end
+      memoize :unscoped_namespace
+
+      def qualified_namespace
+        yardoc.namespace.to_s
+      end
+
+      def tags(type)
+        yardoc.tags(type)
+      end
+    end # MethodObject
+  end # Documentation
+end # Yardcheck

data/lib/yardcheck/method_call.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class MethodCall
+    include Anima.new(
+      :scope,
+      :selector,
+      :namespace,
+      :params,
+      :example_location,
+      :return_value,
+      :error_raised
+    )
+
+    def self.process(params:, return_value:, **attributes)
+      params =
+        params.map do |key, value|
+          [key, TestValue.process(value)]
+        end.to_h
+
+      return_value = TestValue.process(return_value)
+
+      new(params: params, return_value: return_value, **attributes)
+    end
+
+    def method_identifier
+      [namespace, selector, scope]
+    end
+
+    def initialize?
+      selector == :initialize && scope == :instance
+    end
+
+    def raised?
+      error_raised
+    end
+  end # MethodCall
+end # Yardcheck

data/lib/yardcheck/method_tracer.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class MethodTracer
+    include Concord.new(:namespace, :seen, :call_stack), Memoizable
+
+    def initialize(namespace)
+      super(namespace, [], [])
+    end
+
+    def trace(&block)
+      tracer.enable(&block)
+    end
+
+    def events
+      seen.freeze
+    end
+
+    private
+
+    def tracer
+      TracePoint.new(:call, :return, :raise) do |event|
+        tracer.disable do
+          process(event) if target?(event.defined_class)
+        end
+      end
+    end
+    memoize :tracer
+
+    def process(trace_event)
+      case trace_event.event
+      when :call   then process_call(trace_event)
+      when :return then process_return(trace_event)
+      when :raise  then process_raise
+      end
+    end
+
+    def process_call(trace_event)
+      parameter_names =
+        trace_event
+          .defined_class
+          .instance_method(trace_event.method_id)
+          .parameters.map { |_, name| name }
+
+      scope  = trace_event.binding
+      params =
+        scope
+          .local_variables
+          .select { |lvar| parameter_names.include?(lvar) }
+          .map { |lvar| [lvar, scope.local_variable_get(lvar)] }.to_h
+
+      event = event_details(trace_event).update(params: params)
+      call_stack.push(event)
+    end
+
+    def process_return(trace_event)
+      seen << MethodCall.process(
+        call_stack.pop.merge(return_value: trace_event.return_value)
+      )
+    end
+
+    def process_raise
+      call_stack.last[:error_raised] = true
+    end
+
+    def event_details(event)
+      {
+        scope:            event.defined_class.__send__(:singleton_class?) ? :class : :instance,
+        selector:         event.method_id,
+        namespace:        event.defined_class,
+        example_location: RSpec.current_example.location,
+        error_raised:     false
+      }
+    end
+
+    def target?(klass)
+      return false unless klass
+
+      if klass.__send__(:singleton_class?)
+        klass.to_s =~ /\A#{Regexp.quote("#<Class:#{namespace}")}/
+      else
+        klass.name && klass.name.start_with?(namespace.name)
+      end
+    end
+  end # MethodTracer
+end # Yardcheck

data/lib/yardcheck/observation.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class Observation
+    include Concord.new(:documentation, :event)
+
+    def violations
+      param_violations + return_violations
+    end
+
+    def source_code
+      documentation.source
+    end
+
+    def source_location
+      documentation.location_pointer
+    end
+
+    def test_location
+      event.example_location
+    end
+
+    def method_shorthand
+      documentation.shorthand
+    end
+
+    def documented_param(name)
+      documentation.params.fetch(name)
+    end
+
+    def observed_param(name)
+      event.params.fetch(name)
+    end
+
+    def documented_return_type
+      documentation.return_type
+    end
+
+    def actual_return_type
+      event.return_value.type
+    end
+
+    def documentation_warnings
+      documentation.warnings
+    end
+
+    private
+
+    def param_violations
+      overlapping_keys = documentation.params.keys & event.params.keys
+
+      overlapping_keys.map do |key|
+        type_definition = documentation.params.fetch(key)
+        test_value      = event.params.fetch(key)
+
+        next if type_definition.match?(test_value)
+        Violation::Param.new(key, self)
+      end
+    end
+
+    def return_violations
+      invalid_return_type? ? [Violation::Return.new(self)] : []
+    end
+
+    def invalid_return_type?
+      documentation.return_type &&
+        !documentation.return_type.match?(event.return_value) &&
+        !event.raised? &&
+        !event.initialize?
+    end
+  end # Observation
+end # Yardcheck

data/lib/yardcheck/proxy.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class Proxy < BasicObject
+    def initialize(target)
+      @target = target
+    end
+
+    undef_method :==
+    undef_method :!=
+    undef_method :!
+
+    def method_missing(method_name, *args, &block)
+      if target_respond_to?(method_name)
+        @target.__send__(method_name, *args, &block)
+      else
+        ::Object
+          .instance_method(method_name)
+          .bind(@target)
+          .call(*args, &block)
+      end
+    end
+
+    private
+
+    def target_respond_to?(method_name)
+      ::Object
+        .instance_method(:respond_to?)
+        .bind(@target)
+        .call(method_name, true)
+    end
+  end # Proxy
+end # Yardcheck