yardcheck 0.0.1

data/lib/yardcheck/runner.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class Runner
+    include Concord.new(:observations, :output), Memoizable
+
+    # rubocop:disable MethodLength
+    def self.run(args)
+      options = { rspec: 'spec' }
+
+      parser =
+        OptionParser.new do |opt|
+          opt.on(
+            '--namespace NS',
+            'Namespace to check documentation for and watch methods calls for'
+          ) do |arg|
+            options[:namespace] = arg
+          end
+
+          opt.on('--include PATH', 'Path to add to load path') do |arg|
+            options[:include] = arg
+          end
+
+          opt.on('--require LIB', 'Library to require') do |arg|
+            options[:require] = arg
+          end
+
+          opt.on('--rspec ARGS', 'Arguments to give to rspec') do |arg|
+            options[:rspec] = arg
+          end
+        end
+
+      parser.parse(args)
+
+      arguments = options.fetch_values(:namespace, :include, :require, :rspec)
+      namespace, include_path, require_target, rspec = arguments
+
+      fail 'All arguments are required' if arguments.any?(&:nil?)
+
+      $LOAD_PATH.unshift(include_path)
+      require require_target
+
+      rspec = rspec.split(' ')
+
+      observations =
+        Yardcheck::SpecObserver
+          .run(rspec, namespace)
+          .associate_with(Yardcheck::Documentation.parse)
+
+      new(observations, $stderr)
+    end
+
+    def check
+      warn_all(warnings)
+      warn_all(offenses)
+    end
+
+    private
+
+    def warnings
+      observations
+        .flat_map(&:documentation_warnings)
+        .map(&:message)
+    end
+
+    def offenses
+      combined_violations.map(&:offense)
+    end
+
+    def warn_all(output_lines)
+      output_lines.map(&method(:warn))
+    end
+
+    def combined_violations
+      violations.group_by(&:combination_identifier).flat_map do |_, grouped_violations|
+        grouped_violations.reduce(:combine)
+      end
+    end
+    memoize :combined_violations
+
+    def violations
+      observations
+        .flat_map(&:violations)
+        .uniq
+        .compact
+    end
+    memoize :violations
+
+    def warn(message)
+      output.puts(message)
+    end
+  end # Runner
+end # Yardcheck

data/lib/yardcheck/source_lines.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class SourceLines
+    include Concord.new(:lines)
+
+    def self.process(contents)
+      new(
+        contents.split("\n").map do |line|
+          line.gsub(/^\s+/, '')
+        end
+      )
+    end
+
+    def documentation_above(line)
+      first_line = last_line = line - 1
+
+      first_line -= 1 until first_line.equal?(0) || line(first_line) !~ /^\s*#/
+
+      lines[first_line..(last_line - 1)]
+    end
+
+    private
+
+    def line(number)
+      lines.fetch(number - 1)
+    end
+  end # SourceLines
+end # Yardcheck

data/lib/yardcheck/spec_observer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class SpecObserver
+    include Concord.new(:events), Memoizable
+
+    def self.run(rspec_arguments, namespace)
+      tracer      = MethodTracer.new(Object.const_get(namespace))
+      test_runner = TestRunner.new(rspec_arguments)
+
+      test_runner.wrap_test(tracer.method(:trace))
+      test_runner.run
+
+      new(tracer.events)
+    end
+
+    def associate_with(documentation)
+      docs    = documentation.method_objects.group_by(&:method_identifier)
+      calls   = events.group_by(&:method_identifier)
+      overlap = docs.keys & calls.keys
+
+      overlap.flat_map do |key|
+        method_object = docs.fetch(key).first
+        calls.fetch(key).map { |call| Observation.new(method_object, call) }
+      end
+    end
+  end # SpecObserver
+end # Yardcheck

data/lib/yardcheck/test_runner.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class TestRunner
+    include Concord.new(:arguments)
+
+    def wrap_test(wrapper)
+      RSpec.configure do |config|
+        config.around do |test|
+          wrapper.call(&test)
+        end
+      end
+    end
+
+    def run
+      runner.run_specs(RSpec.world.ordered_example_groups)
+    end
+
+    private
+
+    def runner
+      RSpec::Core::Runner.new(RSpec::Core::ConfigurationOptions.new(arguments)).tap do |runner|
+        runner.setup($stderr, $stdout)
+      end
+    end
+  end # TestRunner
+end # Yardcheck

data/lib/yardcheck/test_value.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class TestValue
+    include Concord.new(:value)
+
+    def self.process(value)
+      case value
+      when RSpec::Mocks::InstanceVerifyingDouble
+        InstanceDouble.process(value)
+      when RSpec::Mocks::Double
+        Double.process(value)
+      else
+        new(Proxy.new(value))
+      end
+    end
+
+    def is?(annotated_value)
+      if annotated_value.is_a?(Module)
+        value.is_a?(annotated_value)
+      else
+        value == annotated_value
+      end
+    end
+
+    def duck_type?(method_name)
+      value.respond_to?(method_name)
+    end
+
+    def type
+      value.class
+    end
+
+    def inspect
+      "#{self.class}.new(#{value.inspect})"
+    end
+
+    class InstanceDouble < self
+      include Concord.new(:doubled_module)
+
+      def self.process(value)
+        new(value.instance_variable_get(:@doubled_module).target)
+      end
+
+      def is?(value)
+        doubled_module == value || (value.is_a?(Module) && doubled_module < value)
+      end
+
+      def type
+        doubled_module
+      end
+
+      def inspect
+        "#{self.class}.new(#{doubled_module.inspect})"
+      end
+
+      def duck_type?(method_name)
+        doubled_module.instance_methods.include?(method_name)
+      end
+    end # InstanceDouble
+
+    class Double < self
+      include Concord.new(:name)
+
+      def self.process(value)
+        new(value.instance_variable_get(:@name) || '(anonymous)')
+      end
+
+      def is?(_)
+        true
+      end
+
+      def type
+        '(double)'
+      end
+
+      def inspect
+        "#{self.class}.new(#{name.inspect})"
+      end
+    end # Double
+  end # TestValue
+end # Yardcheck

data/lib/yardcheck/typedef.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class Typedef
+    include Concord.new(:types)
+
+    def self.parse(types)
+      if types.include?(:undefined)
+        fail 'Cannot combined [undefined] with other types' unless types.one?
+        Undefined.new
+      elsif types.grep(Parser::Invalid).any?
+        Invalid.new(types)
+      else
+        new(types)
+      end
+    end
+
+    def match?(other)
+      types.any? do |type|
+        type.match?(other)
+      end
+    end
+
+    def signature
+      types.to_a.map(&:signature).join(' | ')
+    end
+
+    def +(other)
+      self.class.new((types + other.types).uniq)
+    end
+
+    def invalid_const?
+      types.any?(&:invalid_const?)
+    end
+
+    class Literal < self
+      include Concord.new(:const)
+
+      def match?(value)
+        value.is?(type_class)
+      end
+
+      def signature
+        type_class.inspect
+      end
+
+      def type_class
+        const.constant
+      end
+
+      def invalid_const?
+        !const.valid?
+      end
+    end # Literal
+
+    class Collection < self
+      include Concord.new(:collection_const, :member_typedefs)
+
+      def match?(other)
+        Literal.new(collection_const).match?(other)
+      end
+
+      def signature
+        "#{collection_class}<#{member_typedefs.map(&:signature)}>"
+      end
+
+      def collection_class
+        collection_const.constant
+      end
+
+      def invalid_const?
+        !collection_const.valid? || member_typedefs.any?(&:invalid_const?)
+      end
+    end # Collection
+
+    class Undefined < self
+      include Concord.new
+
+      def match?(_)
+        true
+      end
+
+      def signature
+        'Undefined'
+      end
+
+      def invalid_const?
+        false
+      end
+    end # Undefined
+
+    class Ducktype < self
+      include Concord.new(:method_name)
+
+      PATTERN = /\A\#(.+)\z/
+
+      def self.parse(name)
+        new(name[PATTERN, 1].to_sym)
+      end
+
+      def match?(other)
+        other.duck_type?(method_name)
+      end
+
+      def signature
+        "an object responding to ##{method_name}"
+      end
+
+      def invalid_const?
+        false
+      end
+    end # Ducktype
+
+    class Invalid < self
+      include Concord.new(:types)
+
+      def invalid_const?
+        true
+      end
+    end
+  end # Typedef
+end # Yardcheck

data/lib/yardcheck/typedef/parser.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Yardcheck
+  class Typedef
+    class Parser
+      include Concord.new(:namespace, :types), Adamantium
+
+      def parse
+        Typedef.parse(types.map(&method(:parse_type)).flatten.compact)
+      end
+
+      def parse_type(type)
+        parsed = parse_yard_type(type)
+        return [parsed] if parsed.is_a?(Invalid)
+
+        parsed.map do |parsed_type|
+          resolve_yard_type(parsed_type)
+        end
+      end
+
+      def parse_yard_type(type)
+        YARD::Tags::TypesExplainer::Parser.parse(type)
+      rescue SyntaxError => error
+        Invalid.new(type, error.message)
+      end
+
+      def resolve_yard_type(yard_type)
+        case yard_type
+        when YARD::Tags::TypesExplainer::CollectionType
+          Collection.new(
+            *resolve_type(yard_type.name),
+            yard_type.types.flat_map(&method(:resolve_yard_type))
+          )
+        when YARD::Tags::TypesExplainer::Type
+          types = resolve_type(yard_type.name)
+          case types
+          when :undefined then Undefined.new
+          when :ducktype  then Ducktype.parse(yard_type.name)
+          else
+            types.map { |type| Literal.new(type) }
+          end
+        else
+          fail "wtf! #{yard_type}"
+        end
+      end
+
+      def resolve_type(name)
+        case name
+        when 'nil' then   [Const.new(NilClass)]
+        when 'true' then  [Const.new(TrueClass)]
+        when 'false' then [Const.new(FalseClass)]
+        when 'self' then [namespace_const]
+        when 'undefined', 'void' then :undefined
+        when 'Boolean', 'Bool' then [Const.new(TrueClass), Const.new(FalseClass)]
+        when Ducktype::PATTERN then :ducktype
+        else [tag_const(name)]
+        end
+      end
+
+      def tag_const(name)
+        Const.resolve(name, namespace_constant)
+      end
+
+      def namespace_const
+        Const.resolve(namespace)
+      end
+
+      def namespace_constant
+        namespace_const.constant
+      end
+      memoize :namespace_constant
+
+      class Invalid
+        include Concord.new(:type, :error)
+
+        def signature
+          type
+        end
+      end
+    end # Parser
+  end # Typedef
+end # Yardcheck