yard-sorbet 0.0.0 → 0.0.1

data/spec/data/sig_handler.rb.txt

@@ -0,0 +1,196 @@
+class Signatures
+  # comment sig_void
+  sig {void}
+  def sig_void; end
+
+  # comment sig_override_void
+  sig.override.void
+  def sig_override_void; end
+
+  # comment sig_arguments
+  sig {params(a: Integer, b: Integer).void}
+  def sig_arguments(a, b); end
+
+  # comment sig_multiline_arguments
+  sig do
+    params(
+      a: Integer,
+      b: Integer,
+    ).void
+  end
+  def sig_multiline_arguments(a, b); end
+
+  # comment sig_multiline_comments
+  # comment sig_multiline_comments
+  sig {void}
+  def sig_multiline_comments; end
+
+  # comment sig_class_method
+  sig {void}
+  def self.sig_class_method; end
+
+  class << self
+    # comment reopening
+    sig {void}
+    def reopening; end
+  end
+
+  # At end of class
+  sig {void}
+end
+
+class Subclass < Signatures
+  # with subclass
+  sig {void}
+  def method; end
+end
+
+class ClassWithCode
+  # bar
+  sig {void}
+  def bar; end
+
+  puts 'foobar'
+
+  # foo
+  sig {void}
+  def foo; end
+end
+
+class Outer
+  # outer method
+  sig {void}
+  def outer; end
+
+  class Inner
+    # inner method
+    sig {void}
+    def inner; end
+  end
+
+  # outer method 2
+  sig {void}
+  def outer2; end
+end
+
+module Module
+  # module function
+  sig {void}
+  def self.foo; end
+
+  # module instance method
+  sig {void}
+  def bar; end
+end
+
+class SigReturn
+  sig {returns(Integer)}
+  def one; 1; end
+
+  # @deprecated do not use
+  sig {returns(Integer)}
+  def two; 2; end
+
+  # @return [Numeric]
+  sig {returns(Integer)}
+  def three; 3; end
+
+  # @return the number four
+  sig {returns(Integer)}
+  def four; 4; end
+
+  sig {params(int: Integer).returns(Float)}
+  def plus_one(int); int + 1.0; end
+
+  sig {returns(T.any(Numeric, String))}
+  def plus(a, b); a + b; end
+
+  sig {void}
+  def void_method; end
+end
+
+class SigAbstract
+  sig {abstract}
+  def one; end
+
+  # @abstract subclass must implement
+  sig {abstract}
+  def two; end
+
+  sig {abstract.returns(Boolean)}
+  def with_return; true; end
+
+  sig {abstract.void}
+  def with_void; end
+end
+
+class SigParams
+  # @param bar the thing
+  # @param baz [Object] the other thing
+  sig {params(bar: T.any(String, Symbol), baz: T.nilable(String)).void}
+  def foo(bar, baz); end
+
+  sig do
+    params(
+      blk: T.proc.params(arg0: String).returns(T::Array[Hash])
+    )
+    .returns(NilClass)
+  end
+  def blk_method(&blk); nil; end
+
+  sig do
+    override
+    .params(block: T.proc.params(
+      model: EmailConversation,
+      mutator: T.untyped,
+    ).void)
+    .void
+  end
+  def impl_blk_method(&block); end
+end
+
+class CollectionSigs
+  sig {params(arr: T::Array[String]).void}
+  def collection(arr); end
+
+  sig {params(arr: T::Array[T::Array[String]]).void}
+  def nested_collection(arr); end
+
+  sig {params(arr: T::Array[T.any(String, Symbol)]).returns(TrueClass)}
+  def mixed_collection(arr); true; end
+
+  sig {returns(T::Hash[String, Symbol])}
+  def hash_method; end
+
+  sig {returns([String, Integer])}
+  def fixed_array; ['', 0]; end
+
+  # @!visibility protected
+  sig {returns({foo: T.nilable(String)})}
+  def fixed_hash; {foo: nil}; end
+
+  sig do
+    params(
+      tos_acceptance: T.nilable({
+        date: Integer,
+        ip: String,
+        user_agent: T.nilable(String),
+        signator: T.nilable(String),
+        iovation_blackbox: T.nilable(String),
+      })
+    )
+    .returns(NilClass)
+  end
+  def fixed_param_hash(tos_acceptance); nil; end
+end
+
+class AttrSigs
+  sig {returns(String)}
+  attr_accessor :my_accessor
+
+  sig {returns(Integer)}
+  attr_reader :my_reader
+
+  sig {params(my_writer: T.nilable(Symbol)).returns(T.nilable(Symbol))}
+  attr_writer :my_writer
+end

data/spec/data/struct_handler.rb.txt

@@ -0,0 +1,25 @@
+# Comment on PersonStruct
+class PersonStruct < T:Struct
+  # A name
+  const :name, String
+  # An age
+  const :age, Integer
+  # An optional
+  const :optional, T.nilable(String)
+  const :mystery, T.untyped
+end
+
+class SpecializedPersonStruct < T::Struct
+  const :special, String
+
+  # This is a special intializer
+  def initialize(special:)
+    raise ArgumentError("bad human") if special != "special"
+    super
+  end
+end
+
+class DefaultPersonStruct < T::Struct
+  # This has a default
+  const :defaulted, String, default: 'hello'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,111 @@
+# typed: strict
+# frozen_string_literal: true
+
+require_relative '../lib/yard-sorbet'
+
+if ENV['CI'] == 'true'
+  require 'simplecov'
+  require 'codecov'
+  SimpleCov.start
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+  # The settings below are suggested to provide a good initial experience
+  # with RSpec, but feel free to customize to your heart's content.
+
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = 'spec/examples.txt'
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+end

data/spec/yard_sorbet/sig_handler_spec.rb

@@ -0,0 +1,233 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'yard'
+
+RSpec.describe YARDSorbet::SigHandler do
+  before do
+    YARD::Registry.clear
+    path = File.join(
+      File.expand_path('../data', __dir__),
+      'sig_handler.rb.txt'
+    )
+    YARD::Parser::SourceParser.parse(path)
+  end
+
+  describe 'attaching to method' do
+    it 'handles signatures without arguments' do
+      node = YARD::Registry.at('Signatures#sig_void')
+      expect(node.docstring).to eq('comment sig_void')
+    end
+
+    it 'handles chaining' do
+      node = YARD::Registry.at('Signatures#sig_override_void')
+      expect(node.docstring).to eq('comment sig_override_void')
+    end
+
+    it 'handles arguments' do
+      node = YARD::Registry.at('Signatures#sig_arguments')
+      expect(node.docstring).to eq('comment sig_arguments')
+    end
+
+    it 'handles multiline arguments' do
+      node = YARD::Registry.at('Signatures#sig_multiline_arguments')
+      expect(node.docstring).to eq('comment sig_multiline_arguments')
+    end
+
+    it 'handles multiline comments' do
+      node = YARD::Registry.at('Signatures#sig_multiline_comments')
+      expect(node.docstring).to eq("comment sig_multiline_comments\ncomment sig_multiline_comments")
+    end
+
+    it 'handles class methods' do
+      node = YARD::Registry.at('Signatures.sig_class_method')
+      expect(node.docstring).to eq('comment sig_class_method')
+    end
+
+    it 'handles subclasses' do
+      node = YARD::Registry.at('Subclass#method')
+      expect(node.docstring).to eq('with subclass')
+    end
+
+    it 'handles classes executing code' do
+      node = YARD::Registry.at('ClassWithCode#foo')
+      expect(node.docstring).to eq('foo')
+    end
+
+    it 'handles nested classes' do
+      node = YARD::Registry.at('Outer#outer')
+      expect(node.docstring).to eq('outer method')
+
+      node = YARD::Registry.at('Outer#outer2')
+      expect(node.docstring).to eq('outer method 2')
+
+      node = YARD::Registry.at('Outer::Inner#inner')
+      expect(node.docstring).to eq('inner method')
+    end
+
+    it 'handles modules' do
+      node = YARD::Registry.at('Module.foo')
+      expect(node.docstring).to eq('module function')
+
+      node = YARD::Registry.at('Module#bar')
+      expect(node.docstring).to eq('module instance method')
+    end
+
+    it 'handles singleton class syntax' do
+      skip('TODO')
+      node = YARD::Registry.at('Signatures.reopening')
+      expect(node.docstring).to eq('comment reopening')
+    end
+  end
+
+  describe 'sig parsing' do
+    it 'parses return types' do
+      node = YARD::Registry.at('SigReturn#one')
+      expect(node.tag(:return).types).to eq(['Integer'])
+    end
+
+    it 'merges tags' do
+      node = YARD::Registry.at('SigReturn#two')
+      expect(node.tag(:return).types).to eq(['Integer'])
+      expect(node.tag(:deprecated).text).to eq('do not use')
+    end
+
+    it 'overrides explicit tag' do
+      node = YARD::Registry.at('SigReturn#three')
+      expect(node.tag(:return).types).to eq(['Integer'])
+    end
+
+    it 'merges comment' do
+      node = YARD::Registry.at('SigReturn#four')
+      expect(node.tag(:return).types).to eq(['Integer'])
+      expect(node.tag(:return).text).to eq('the number four')
+    end
+
+    it 'with params' do
+      node = YARD::Registry.at('SigReturn#plus_one')
+      expect(node.tag(:return).types).to eq(['Float'])
+    end
+
+    it 'with T syntax' do
+      node = YARD::Registry.at('SigReturn#plus')
+      expect(node.tag(:return).types).to eq(%w[Numeric String])
+    end
+
+    it 'with void sig' do
+      node = YARD::Registry.at('SigReturn#void_method')
+      expect(node.tag(:return).types).to eq(['void'])
+    end
+
+    it 'with abstract sig' do
+      node = YARD::Registry.at('SigAbstract#one')
+      expect(node.tag(:abstract).text).to eq('')
+    end
+
+    it 'merges abstract tag' do
+      node = YARD::Registry.at('SigAbstract#two')
+      expect(node.tag(:abstract).text).to eq('subclass must implement')
+    end
+
+    it 'with returns' do
+      node = YARD::Registry.at('SigAbstract#with_return')
+      expect(node.tag(:abstract).text).to eq('')
+      expect(node.tag(:return).types).to eq(['Boolean'])
+    end
+
+    it 'with void' do
+      node = YARD::Registry.at('SigAbstract#with_void')
+      expect(node.tag(:abstract).text).to eq('')
+      expect(node.tag(:return).types).to eq(['void'])
+    end
+
+    it 'params' do
+      node = YARD::Registry.at('SigParams#foo')
+      bar_tag = node.tags.find { |t| t.name == 'bar' }
+      expect(bar_tag.text).to eq('the thing')
+      expect(bar_tag.types).to eq(%w[String Symbol])
+      baz_tag = node.tags.find { |t| t.name == 'baz' }
+      expect(baz_tag.text).to eq('the other thing')
+      expect(baz_tag.types).to eq(%w[String nil])
+    end
+
+    it 'block param' do
+      node = YARD::Registry.at('SigParams#blk_method')
+      blk_tag = node.tags.find { |t| t.name == 'blk' }
+      expect(blk_tag.types).to eq(
+        ['T.proc.params(arg0: String).returns(T::Array[Hash])']
+      )
+      expect(node.tag(:return).types).to eq(['nil'])
+    end
+
+    it 'block param with newlines' do
+      node = YARD::Registry.at('SigParams#impl_blk_method')
+      blk_tag = node.tags.find { |t| t.name == 'block' }
+      expect(blk_tag.types).to eq(
+        ['T.proc.params( model: EmailConversation, mutator: T.untyped, ).void']
+      )
+      expect(node.tag(:return).types).to eq(['void'])
+    end
+
+    it 'T::Array' do
+      node = YARD::Registry.at('CollectionSigs#collection')
+      param_tag = node.tags.find { |t| t.name == 'arr' }
+      expect(param_tag.types).to eq(['Array<String>'])
+    end
+
+    it 'nested T::Array' do
+      node = YARD::Registry.at('CollectionSigs#nested_collection')
+      param_tag = node.tags.find { |t| t.name == 'arr' }
+      expect(param_tag.types).to eq(['Array<Array<String>>'])
+    end
+
+    it 'mixed T::Array' do
+      node = YARD::Registry.at('CollectionSigs#mixed_collection')
+      param_tag = node.tags.find { |t| t.name == 'arr' }
+      expect(param_tag.types).to eq(['Array<String, Symbol>'])
+    end
+
+    it 'T::Hash' do
+      node = YARD::Registry.at('CollectionSigs#hash_method')
+      expect(node.tag(:return).types).to eq(['Hash{String => Symbol}'])
+    end
+
+    it 'fixed Array' do
+      node = YARD::Registry.at('CollectionSigs#fixed_array')
+      expect(node.tag(:return).types).to eq(['Array(String, Integer)'])
+    end
+
+    it 'fixed Hash' do
+      node = YARD::Registry.at('CollectionSigs#fixed_hash')
+      expect(node.tag(:return).types).to eq(['Hash'])
+      expect(node.visibility).to eq(:protected)
+    end
+
+    it 'fixed param Hash' do
+      node = YARD::Registry.at('CollectionSigs#fixed_param_hash')
+      param_tag = node.tags.find { |t| t.name == 'tos_acceptance' }
+      expect(param_tag.types).to eq(%w[Hash nil])
+    end
+  end
+
+  describe 'attributes' do
+    it 'handles attr_accessor getter' do
+      node = YARD::Registry.at('AttrSigs#my_accessor')
+      expect(node.tag(:return).types).to eq(['String'])
+    end
+
+    it 'handles attr_accessor setter' do
+      node = YARD::Registry.at('AttrSigs#my_accessor=')
+      expect(node.tag(:return).types).to eq(['String'])
+    end
+
+    it 'handles attr_reader' do
+      node = YARD::Registry.at('AttrSigs#my_reader')
+      expect(node.tag(:return).types).to eq(['Integer'])
+    end
+
+    it 'handles attr_writer' do
+      node = YARD::Registry.at('AttrSigs#my_writer=')
+      expect(node.tag(:return).types).to eq(%w[Symbol nil])
+    end
+  end
+end