yardcheck 0.0.1

data/spec/unit/yardcheck/method_tracer_spec.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+RSpec.describe Yardcheck::MethodTracer do
+  it 'traces method calls and returns for a namespace' do
+    stub_const('Foo', Class.new)
+    stub_const('Qux', Class.new)
+
+    class Foo
+      def self.singleton_method_example(baz)
+        baz.upcase
+      end
+
+      def instance_method_example(baz)
+        Foo.singleton_method_example(baz)
+      end
+    end # Foo
+
+    class Qux
+      def self.singleton_method_example(baz)
+        baz.upcase
+      end
+
+      def instance_method_example(baz)
+        Qux.singleton_method_example(baz)
+      end
+    end # Qux
+
+    tracer = described_class.new(Foo)
+    foo    = Foo.new # Capture the activity for this object
+    qux    = Qux.new # Ignore this one
+    str    = 'Hello'
+
+    tracer.trace do
+      foo.instance_method_example(str)
+      qux.instance_method_example(str)
+    end
+
+    expect(tracer.events).to eq([
+      Yardcheck::MethodCall.process(
+        scope:            :class,
+        selector:         :singleton_method_example,
+        namespace:        Foo.singleton_class,
+        params:           { baz: 'Hello' },
+        return_value:     'HELLO',
+        example_location: RSpec.current_example.location,
+        error_raised:     false
+      ),
+      Yardcheck::MethodCall.process(
+        scope:            :instance,
+        selector:         :instance_method_example,
+        namespace:        Foo,
+        params:           { baz: 'Hello' },
+        return_value:     'HELLO',
+        example_location: RSpec.current_example.location,
+        error_raised:     false
+      )
+    ])
+  end
+end

data/spec/unit/yardcheck/runner_spec.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+RSpec.describe Yardcheck::Runner do
+  subject(:runner) do
+    described_class.new(observer.associate_with(docs), io)
+  end
+
+  let(:observer) { Yardcheck::SpecObserver.new(observed_events) }
+  let(:docs)     { Yardcheck::Documentation.new(yardocs)        }
+  let(:io)       { StringIO.new                                 }
+
+  let(:yardocs) do
+    YardcheckSpec::YARDOCS.each do |yardoc|
+      allow(yardoc).to receive(:file).and_wrap_original do |method|
+        File.join('./test_app', method.call).to_s
+      end
+    end
+  end
+
+  let(:observed_events) do
+    [
+      Yardcheck::MethodCall.process(
+        scope:            :instance,
+        selector:         :add,
+        namespace:        TestApp::Namespace,
+        params:           { left: 'foo', right: 3 },
+        return_value:     5,
+        example_location: 'test_app_spec.rb:1',
+        error_raised:     false
+      ),
+      Yardcheck::MethodCall.process(
+        scope:            :class,
+        selector:         :add,
+        namespace:        TestApp::Namespace.singleton_class,
+        params:           { left: 2, right: 3 },
+        return_value:     5,
+        example_location: 'test_app_spec.rb:2',
+        error_raised:     false
+      )
+    ]
+  end
+
+  let(:output) do
+    <<~MSG
+      Expected #<Class:TestApp::Namespace>#add to return String but observed Fixnum
+
+          source: ./test_app/lib/test_app.rb:9
+          tests:
+            - test_app_spec.rb:2
+
+          # Singleton method with correct param definition and incorrect return
+          #
+          # @param left [Integer]
+          # @param right [Integer]
+          #
+          # @return [String]
+          def self.add(left, right)
+            left + right
+          end
+
+      Expected TestApp::Namespace#add to receive Integer for left but observed String
+
+          source: ./test_app/lib/test_app.rb:19
+          tests:
+            - test_app_spec.rb:1
+
+          # Instance method with correct param definition and incorrect return
+          #
+          # @param left [Integer]
+          # @param right [Integer]
+          #
+          # @return [String]
+          def add(left, right)
+            left + right
+          end
+
+      Expected TestApp::Namespace#add to return String but observed Fixnum
+
+          source: ./test_app/lib/test_app.rb:19
+          tests:
+            - test_app_spec.rb:1
+
+          # Instance method with correct param definition and incorrect return
+          #
+          # @param left [Integer]
+          # @param right [Integer]
+          #
+          # @return [String]
+          def add(left, right)
+            left + right
+          end
+
+    MSG
+  end
+
+  def remove_color(string)
+    string.gsub(/\e\[(?:1\;)?\d+m/, '')
+  end
+
+  shared_examples 'violation output' do
+    it 'compares the spec observations against the documentation' do
+      runner.check
+
+      expect(remove_color(io.string)).to eql(output)
+    end
+  end
+
+  include_examples 'violation output'
+
+  context 'when multiple tests find the same violation' do
+    let(:observed_events) do
+      [
+        Yardcheck::MethodCall.process(
+          scope:            :instance,
+          selector:         :add,
+          namespace:        TestApp::Namespace,
+          params:           { left: 'foo', right: 3 },
+          return_value:     'valid return type',
+          example_location: 'test_app_spec.rb:1',
+          error_raised:     false
+        ),
+        Yardcheck::MethodCall.process(
+          scope:            :instance,
+          selector:         :add,
+          namespace:        TestApp::Namespace,
+          params:           { left: 'foo', right: 3 },
+          return_value:     'valid return type',
+          example_location: 'test_app_spec.rb:2',
+          error_raised:     false
+        ),
+        Yardcheck::MethodCall.process(
+          scope:            :instance,
+          selector:         :add,
+          namespace:        TestApp::Namespace,
+          params:           { left: 1, right: 'now this one is wrong' },
+          return_value:     'valid return type',
+          example_location: 'test_app_spec.rb:3',
+          error_raised:     false
+        )
+      ]
+    end
+
+    let(:output) do
+      <<~MSG
+        Expected TestApp::Namespace#add to receive Integer for left but observed String
+
+            source: ./test_app/lib/test_app.rb:19
+            tests:
+              - test_app_spec.rb:1
+              - test_app_spec.rb:2
+
+            # Instance method with correct param definition and incorrect return
+            #
+            # @param left [Integer]
+            # @param right [Integer]
+            #
+            # @return [String]
+            def add(left, right)
+              left + right
+            end
+
+        Expected TestApp::Namespace#add to receive Integer for right but observed String
+
+            source: ./test_app/lib/test_app.rb:19
+            tests:
+              - test_app_spec.rb:3
+
+            # Instance method with correct param definition and incorrect return
+            #
+            # @param left [Integer]
+            # @param right [Integer]
+            #
+            # @return [String]
+            def add(left, right)
+              left + right
+            end
+
+      MSG
+    end
+
+    include_examples 'violation output'
+  end
+end

data/spec/unit/yardcheck/test_value_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+RSpec.describe Yardcheck::TestValue do
+  it 'just wraps normal values' do
+    expect(described_class.process(1)).to eql(described_class.new(1))
+  end
+
+  it 'extracts the namespace from instance doubles' do
+    expect(described_class.process(instance_double(String))).to eql(
+      described_class::InstanceDouble.new(String)
+    )
+  end
+
+  it 'extracts the name from doubles' do
+    expect(described_class.process(double(:foo))).to eql(
+      described_class::Double.new(:foo)
+    )
+  end
+
+  it 'handles anonymous doubles' do
+    expect(described_class.process(double)).to eql(
+      described_class::Double.new('(anonymous)')
+    )
+  end
+end

data/spec/unit/yardcheck/typedef/parser_spec.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+RSpec.describe Yardcheck::Typedef::Parser do
+  def parse(*types)
+    described_class.new('TestApp::Namespace', types).parse
+  end
+
+  it 'resolves one normal constant' do
+    expect(parse('Integer')).to eql(Yardcheck::Typedef.new([
+      Yardcheck::Typedef::Literal.new(Yardcheck::Const.new(Integer))
+    ]))
+  end
+
+  it 'resolves multiple constants' do
+    expect(parse('Integer', 'String')).to eql(Yardcheck::Typedef.new([
+      Yardcheck::Typedef::Literal.new(Yardcheck::Const.new(Integer)),
+      Yardcheck::Typedef::Literal.new(Yardcheck::Const.new(String))
+    ]))
+  end
+
+  it 'resolves child of namespace' do
+    expect(parse('Child')).to eql(Yardcheck::Typedef.new([
+      Yardcheck::Typedef::Literal.new(Yardcheck::Const.new(TestApp::Namespace::Child))
+    ]))
+  end
+
+  it 'handles array of items' do
+    expect(parse('Array<String>')).to eql(
+      Yardcheck::Typedef.new([
+        Yardcheck::Typedef::Collection.new(
+          Yardcheck::Const.new(Array),
+          [Yardcheck::Typedef::Literal.new(Yardcheck::Const.new(String))]
+        )
+      ])
+    )
+  end
+end

data/spec/unit/yardcheck/typedef_spec.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+RSpec.describe Yardcheck::Typedef do
+  def typedef(*types)
+    typedefs =
+      types.map do |type|
+        described_class::Literal.new(Yardcheck::Const.new(type))
+      end
+
+    described_class.new(typedefs)
+  end
+
+  it 'matches exact type matches' do
+    expect(typedef(Integer).match?(Yardcheck::TestValue.new(1))).to be(true)
+  end
+
+  it 'matches descendants' do
+    parent = Class.new
+    child  = Class.new(parent)
+
+    expect(typedef(parent).match?(Yardcheck::TestValue.new(child.new))).to be(true)
+  end
+
+  it 'matches union type definitions' do
+    aggregate_failures do
+      definition = typedef(Integer, String)
+      expect(definition.match?(Yardcheck::TestValue.new(1))).to be(true)
+      expect(definition.match?(Yardcheck::TestValue.new('hi'))).to be(true)
+      expect(definition.match?(Yardcheck::TestValue.new(:hi))).to be(false)
+    end
+  end
+end

data/test_app/.rspec

@@ -0,0 +1 @@
+--color

data/test_app/Gemfile

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+gem 'yardcheck', path: '..'
+gem 'pry'
+gem 'pry-byebug'

data/test_app/Gemfile.lock

@@ -0,0 +1,66 @@
+PATH
+  remote: ..
+  specs:
+    yardcheck (0.0.0)
+      anima
+      coderay (~> 1.1)
+      concord
+      rspec
+      yard (~> 0.9)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    abstract_type (0.0.7)
+    adamantium (0.2.0)
+      ice_nine (~> 0.11.0)
+      memoizable (~> 0.4.0)
+    anima (0.3.0)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2)
+      equalizer (~> 0.0.11)
+    byebug (9.0.6)
+    coderay (1.1.1)
+    concord (0.1.5)
+      adamantium (~> 0.2.0)
+      equalizer (~> 0.0.9)
+    diff-lcs (1.2.5)
+    equalizer (0.0.11)
+    ice_nine (0.11.2)
+    memoizable (0.4.2)
+      thread_safe (~> 0.3, >= 0.3.1)
+    method_source (0.8.2)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-byebug (3.4.2)
+      byebug (~> 9.0)
+      pry (~> 0.10)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    slop (3.6.0)
+    thread_safe (0.3.6)
+    yard (0.9.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry
+  pry-byebug
+  yardcheck!
+
+BUNDLED WITH
+   1.14.6

data/test_app/lib/test_app.rb

@@ -0,0 +1,119 @@
+module TestApp
+  class Namespace
+    # Singleton method with correct param definition and incorrect return
+    #
+    # @param left [Integer]
+    # @param right [Integer]
+    #
+    # @return [String]
+    def self.add(left, right)
+      left + right
+    end
+
+    # Instance method with correct param definition and incorrect return
+    #
+    # @param left [Integer]
+    # @param right [Integer]
+    #
+    # @return [String]
+    def add(left, right)
+      left + right
+    end
+
+    # Untested method with documentation
+    #
+    # @param str [String]
+    #
+    # @return [String]
+    def untested_method(str)
+    end
+
+    def undocumented
+    end
+
+    # @param foo [What]
+    #
+    # @return [Wow]
+    def ignoring_invalid_types(foo)
+    end
+
+    # @return [TestApp::Namespace::Parent]
+    def returns_generic
+      Child.new
+    end
+
+    # @return [Child]
+    def documents_relative
+      'str'
+    end
+
+    # @return no type specified here
+    def return_tag_without_type
+    end
+
+    # @param [String]
+    def param_without_name(unnamed)
+    end
+
+    # @return [nil]
+    def return_nil
+    end
+
+    # @return [Namespace]
+    def return_self
+      self
+    end
+
+    # @return [undefined]
+    def undefined_return
+    end
+
+    # @return [Boolean]
+    def bool_return
+    end
+
+    # @return [Array<String>]
+    def array_return
+    end
+
+    # @return [String] in some cases
+    # @return [nil] otherwise
+    def multiple_returns
+    end
+
+    # @param list [Enumerable<Integer>]
+    # @return [nil]
+    def enumerable_param(list)
+    end
+
+    # @param value [String]
+    # @return [nil]
+    def properly_tested_with_instance_double(value)
+    end
+
+    # @param value [String]
+    # @return [nil]
+    def improperly_tested_with_instance_double(value)
+    end
+
+    AppError = Class.new(StandardError)
+
+    # @return [Fixnum]
+    def always_raise
+      raise AppError
+
+      1
+    end
+
+    # @return [:foo]
+    def returns_literal_symbol
+      :foo
+    end
+
+    class Parent
+    end
+
+    class Child < Parent
+    end
+  end
+end