packwerk_yard 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 641e8d0ddb1071b14b67085d3b9ab52fe72aac4b49d96909ae43b76212254e3f
-  data.tar.gz: 3243f067d6d129efde447741ee15257acd184214ec42edbca3ef58aa4d12fe83
+  metadata.gz: e9a27f1f2b9a3c3610fe647c7be7b46e917717d9a341ded7c10c93c8146b0b9c
+  data.tar.gz: 4ec873d282498c7577be575a54bc8e99546b0023bbced4670c92fdb9c69259b3
 SHA512:
-  metadata.gz: 6e5272b9c7c1fa88234dedce138a5fd1bc15ddb6a7b98ef351741b7061ffee20a0198ab1765bc5517a5560d9c1f2cb44d5095cb7b3304fb7ca6e4a9d73844bee
-  data.tar.gz: bc151f151c15c7bd7d64acb0b8c6f9c8768b79eccbee85326c4d501dea284203e525719f63a837c92933e6d01a4146a2a40d2f861a91c6df643b8f4134f64b1e
+  metadata.gz: 800d9e2a2e50d44f3aaaeb671a27790f7ad5c4e27503fd647e4ae84f3b1d98c53e06b3fb88d43d9d10f295e280323fc951081fe0cf44f240aa86ecaf3e6acfa7
+  data.tar.gz: a771a4fc12e32723c15a395b9388b99350f469c66a9aff34a1208f28b394f5078a4efc1b197f42d5dc609c69f7e59026fb644648748601c88111da006e867649

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.2.0] - 2024-01-07
+
+- Add packwerk to dependencies https://github.com/euglena1215/packwerk-yard/pull/6
+- Introduce sorbet https://github.com/euglena1215/packwerk-yard/pull/7
+- Support nested array & nested hash https://github.com/euglena1215/packwerk-yard/pull/8
+
 ## [0.1.0] - 2024-01-07
 
 - Initial release

data/README.md

@@ -11,7 +11,7 @@ Add YARD support to packwerk.
 1. Add this line to your application's Gemfile:
 
 ```ruby
-gem 'packwerk_yard', github: 'euglena1215/packwerk-yard', group: :development
+gem 'packwerk_yard', require: false, group: :development
 ```
 
 2. Require `packwerk-yard` in your `packwerk.yml`

data/Rakefile

@@ -9,4 +9,8 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-task default: [:test, :rubocop]
+task :sorbet do
+  sh "bundle exec srb tc"
+end
+
+task default: [:test, :rubocop, :sorbet]

data/lib/packwerk_yard/parser.rb

@@ -1,18 +1,25 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 module PackwerkYard
   class Parser
+    extend T::Sig
     include Packwerk::FileParser
 
     # Array Syntax e.g. Array<String>
-    ARRAY_REGEXP = /Array<(.+)>/.freeze
+    ARRAY_REGEXP = T.let(/\AArray<(.+)>/.freeze, Regexp)
     private_constant :ARRAY_REGEXP
 
+    # Hash Syntax e.g. Hash<String, String>
+    HASH_REGEXP = T.let(/\AHash<([^,]*),\s?(.*)>/.freeze, Regexp)
+    private_constant :HASH_REGEXP
+
+    sig { params(ruby_parser: T.nilable(Packwerk::Parsers::Ruby)).void }
     def initialize(ruby_parser: Packwerk::Parsers::Ruby.new)
       @ruby_parser = ruby_parser
     end
 
+    sig { override.params(io: T.any(IO, StringIO), file_path: String).returns(T.untyped) }
     def call(io:, file_path: "<unknown>")
       source_code = io.read
       return to_ruby_ast(nil.inspect, file_path) if source_code.nil?
@@ -20,19 +27,21 @@ module PackwerkYard
       types = extract_from_yard_to_types(source_code)
 
       to_ruby_ast(
-        types.map { |type| to_evaluable_type(type) }
+        types.map { |type| to_evaluable_type(type) }.flatten
              .reject { |type| to_constant(type).nil? }
              .inspect.delete('"'),
         file_path,
       )
     end
 
+    sig { override.params(path: String).returns(T::Boolean) }
     def match?(path:)
       path.end_with?(".rb")
     end
 
     private
 
+    sig { params(source_code: String).returns(T::Array[String]) }
     def extract_from_yard_to_types(source_code)
       YARD::Registry.clear
       YARD::Logger.instance.enter_level(YARD::Logger::ERROR) do
@@ -51,23 +60,23 @@ module PackwerkYard
       types.uniq
     end
 
+    sig { params(type: String).returns(T::Array[String]) }
     def to_evaluable_type(type)
-      # "Array<Integer>" => "Integer"
-      if type =~ ARRAY_REGEXP
-        Regexp.last_match(1)
-      else
-        type
-      end
+      matched_types = Array(ARRAY_REGEXP.match(type).to_a[1])
+      matched_types = Array(HASH_REGEXP.match(type).to_a[1..2]) if matched_types.empty?
+      matched_types.empty? ? [type] : matched_types.map { |t| to_evaluable_type(t) }.flatten
     end
 
+    sig { params(name: T.any(Symbol, String)).returns(T.untyped) }
     def to_constant(name)
       Object.const_get(name) # rubocop:disable Sorbet/ConstantsFromStrings
     rescue NameError
       nil
     end
 
+    sig { params(code: String, file_path: T.untyped).returns(T.untyped) }
     def to_ruby_ast(code, file_path)
-      @ruby_parser.call(
+      T.must(@ruby_parser).call(
         io: StringIO.new(code),
         file_path: file_path,
       )

data/lib/packwerk_yard/version.rb

@@ -1,6 +1,6 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 module PackwerkYard
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/packwerk_yard.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: strict
 # frozen_string_literal: true
 
 require "packwerk"

data/sorbet/config

@@ -0,0 +1,4 @@
+--dir
+.
+--ignore=tmp/
+--ignore=vendor/

data/sorbet/rbi/annotations/.gitattributes

@@ -0,0 +1 @@
+**/*.rbi linguist-vendored=true

data/sorbet/rbi/annotations/actionview.rbi

@@ -0,0 +1,75 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module ActionView
+  TemplateError = T.type_alias { Template::Error }
+
+  class MissingTemplate < ActionView::ActionViewError
+    sig { returns(String) }
+    def path; end
+  end
+end
+
+class ActionView::Helpers::FormBuilder
+  sig { returns(T.untyped) }
+  def object; end
+end
+
+module ActionView::Helpers::NumberHelper
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_to_currency(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_to_human(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_to_human_size(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_to_percentage(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_to_phone(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_with_delimiter(number, options = T.unsafe(nil)); end
+
+  sig { params(number: T.untyped, options: T::Hash[T.untyped, T.untyped]).returns(T.nilable(String)) }
+  def number_with_precision(number, options = T.unsafe(nil)); end
+end
+
+module ActionView::Helpers::SanitizeHelper
+  mixes_in_class_methods ActionView::Helpers::SanitizeHelper::ClassMethods
+end
+
+module ActionView::Helpers::UrlHelper
+  extend ActiveSupport::Concern
+  include ActionView::Helpers::TagHelper
+  mixes_in_class_methods ActionView::Helpers::UrlHelper::ClassMethods
+
+  sig { params(name: T.nilable(String), options: T.untyped, html_options: T.untyped, block: T.untyped).returns(ActiveSupport::SafeBuffer) }
+  def link_to(name = nil, options = nil, html_options = nil, &block); end
+
+  sig { params(condition: T.untyped, name: String, options: T.untyped, html_options: T.untyped, block: T.untyped).returns(T.untyped) }
+  def link_to_if(condition, name, options = {}, html_options = {}, &block); end
+end
+
+module ActionView::Layouts
+  mixes_in_class_methods ActionView::Layouts::ClassMethods
+end
+
+module ActionView::Rendering
+  mixes_in_class_methods ActionView::Rendering::ClassMethods
+end
+
+module ActionView::ViewPaths
+  mixes_in_class_methods ActionView::ViewPaths::ClassMethods
+end
+
+module ActionView::ViewPaths::ClassMethods
+  sig { params(value: T.any(String, T::Array[String])).void }
+  def append_view_path(value); end
+end

data/sorbet/rbi/annotations/activesupport.rbi

@@ -0,0 +1,264 @@
+# typed: true
+
+# DO NOT EDIT MANUALLY
+# This file was pulled from a central RBI files repository.
+# Please run `bin/tapioca annotations` to update it.
+
+module ActiveSupport::Testing::Declarative
+  sig { params(name: String, block: T.proc.bind(T.untyped).void).void }
+  def test(name, &block); end
+end
+
+class ActiveSupport::EnvironmentInquirer
+  sig { returns(T::Boolean) }
+  def development?; end
+
+  sig { returns(T::Boolean) }
+  def production?; end
+
+  sig { returns(T::Boolean) }
+  def test?; end
+
+  # @method_missing: delegated to String through ActiveSupport::StringInquirer
+  sig { returns(T::Boolean) }
+  def staging?; end
+end
+
+module ActiveSupport::Testing::SetupAndTeardown::ClassMethods
+  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.untyped).void)).void }
+  def setup(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.untyped).void)).void }
+  def teardown(*args, &block); end
+end
+
+class ActiveSupport::TestCase
+  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).void)).void }
+  def self.setup(*args, &block); end
+
+  sig { params(args: T.untyped, block: T.nilable(T.proc.bind(T.attached_class).void)).void }
+  def self.teardown(*args, &block); end
+
+  sig { params(name: String, block: T.proc.bind(T.attached_class).void).void }
+  def self.test(name, &block); end
+end
+
+class ActiveSupport::TimeWithZone
+  # @shim: Methods on ActiveSupport::TimeWithZone are delegated to `Time` using `method_missing
+  include ::DateAndTime::Zones
+
+  # @shim: Methods on ActiveSupport::TimeWithZone are delegated to `Time` using `method_missing
+  include ::DateAndTime::Calculations
+
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  # @shim: since `blank?` is always false, `present?` always returns `true`
+  sig { returns(TrueClass) }
+  def present?; end
+end
+
+class Object
+  sig { returns(T::Boolean) }
+  def blank?; end
+
+  sig { returns(T.nilable(T.self_type)) }
+  def presence; end
+
+  sig { params(another_object: T.untyped).returns(T.nilable(T.self_type)) }
+  def presence_in(another_object); end
+
+  sig { returns(T::Boolean) }
+  def present?; end
+end
+
+class Hash
+  sig { returns(T::Boolean) }
+  def extractable_options?; end
+end
+
+class Array
+  sig { params(position: Integer).returns(T.self_type) }
+  def from(position); end
+
+  sig { params(position: Integer).returns(T.self_type) }
+  def to(position); end
+
+  sig { params(elements: T.untyped).returns(T::Array[T.untyped]) }
+  def including(*elements); end
+
+  sig { params(elements: T.untyped).returns(T.self_type) }
+  def excluding(*elements); end
+
+  sig { params(elements: T.untyped).returns(T.self_type) }
+  def without(*elements); end
+
+  sig { returns(T.nilable(Elem)) }
+  def second; end
+
+  sig { returns(T.nilable(Elem)) }
+  def third; end
+
+  sig { returns(T.nilable(Elem)) }
+  def fourth; end
+
+  sig { returns(T.nilable(Elem)) }
+  def fifth; end
+
+  sig { returns(T.nilable(Elem)) }
+  def forty_two; end
+
+  sig { returns(T.nilable(Elem)) }
+  def third_to_last; end
+
+  sig { returns(T.nilable(Elem)) }
+  def second_to_last; end
+
+  sig { params(options: T::Hash[T.untyped, T.untyped]).returns(String) }
+  def to_sentence(options = {}); end
+
+  sig { params(format: Symbol).returns(String) }
+  def to_fs(format = :default); end
+
+  sig { params(format: Symbol).returns(String) }
+  def to_formatted_s(format = :default); end
+
+  sig { returns(String) }
+  def to_xml; end
+
+  sig { returns(T::Hash[T.untyped, T.untyped]) }
+  def extract_options!; end
+
+  sig { type_parameters(:FillType).params(number: Integer, fill_with: T.type_parameter(:FillType), block: T.nilable(T.proc.params(group: T::Array[T.any(Elem, T.type_parameter(:FillType))]).void)).returns(T::Array[T::Array[T.any(Elem, T.type_parameter(:FillType))]]) }
+  def in_groups(number, fill_with = T.unsafe(nil), &block); end
+
+  sig { type_parameters(:FillType).params(number: Integer, fill_with: T.type_parameter(:FillType), block: T.nilable(T.proc.params(group: T::Array[T.any(Elem, T.type_parameter(:FillType))]).void)).returns(T::Array[T::Array[T.any(Elem, T.type_parameter(:FillType))]]) }
+  def in_groups_of(number, fill_with = T.unsafe(nil), &block); end
+
+  sig { params(value: T.untyped, block: T.nilable(T.proc.params(element: Elem).returns(T.untyped))).returns(T::Array[T::Array[Elem]]) }
+  def split(value = nil, &block); end
+
+  sig { params(object: T.untyped).returns(T::Array[T.untyped]) }
+  def self.wrap(object); end
+
+  sig { params(block: T.nilable(T.proc.params(element: Elem).returns(T.untyped))).returns(T.any(T::Array[Elem], T::Enumerator[Elem])) }
+  def extract!(&block); end
+
+  sig { returns(ActiveSupport::ArrayInquirer) }
+  def inquiry; end
+end
+
+class Date
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  # @shim: since `blank?` is always false, `present?` always returns `true`
+  sig { returns(TrueClass) }
+  def present?; end
+end
+
+class DateTime
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  # @shim: since `blank?` is always false, `present?` always returns `true`
+  sig { returns(TrueClass) }
+  def present?; end
+end
+
+class NilClass
+  sig { returns(TrueClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always false, `presence` always returns `nil`
+  sig { returns(NilClass) }
+  def presence; end
+
+  # @shim: since `blank?` is always true, `present?` always returns `false`
+  sig { returns(FalseClass) }
+  def present?; end
+end
+
+class FalseClass
+  sig { returns(TrueClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always false, `presence` always returns `nil`
+  sig { returns(NilClass) }
+  def presence; end
+
+  # @shim: since `blank?` is always true, `present?` always returns `false`
+  sig { returns(FalseClass) }
+  def present?; end
+end
+
+class TrueClass
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  # @shim: since `blank?` is always false, `present?` always returns `true`
+  sig { returns(TrueClass) }
+  def present?; end
+end
+
+class Numeric
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  # @shim: since `blank?` is always false, `present?` always returns `true`
+  sig { returns(TrueClass) }
+  def present?; end
+end
+
+class Time
+  sig { returns(FalseClass) }
+  def blank?; end
+
+  # @shim: since `present?` is always true, `presence` always returns `self`
+  sig { returns(T.self_type) }
+  def presence; end
+
+  # @shim: since `blank?` is always false, `present?` always returns `true`
+  sig { returns(TrueClass) }
+  def present?; end
+end
+
+class Symbol
+  # alias for `#start_with?`
+  sig { params(string_or_regexp: T.any(String, Regexp)).returns(T::Boolean) }
+  def starts_with?(*string_or_regexp); end
+
+  # alias for `#end_with?`
+  sig { params(string_or_regexp: T.any(String, Regexp)).returns(T::Boolean) }
+  def ends_with?(*string_or_regexp); end
+end
+
+class String
+  # alias for `#start_with?`
+  sig { params(string_or_regexp: T.any(String, Regexp)).returns(T::Boolean) }
+  def starts_with?(*string_or_regexp); end
+
+  # alias for `#end_with?`
+  sig { params(string_or_regexp: T.any(String, Regexp)).returns(T::Boolean) }
+  def ends_with?(*string_or_regexp); end
+end