rbi 0.1.13 → 0.1.14

data/lib/rbi/rewriters/attr_to_methods.rb

@@ -0,0 +1,169 @@
+# typed: strict
+# frozen_string_literal: true
+
+module RBI
+  class UnexpectedMultipleSigsError < Error
+    sig { returns(Node) }
+    attr_reader :node
+
+    sig { params(node: Node).void }
+    def initialize(node)
+      super(<<~MSG)
+        This declaration cannot have more than one sig.
+
+        #{node.string.chomp}
+      MSG
+
+      @node = node
+    end
+  end
+
+  module Rewriters
+    class AttrToMethods < Visitor
+      extend T::Sig
+
+      sig { override.params(node: T.nilable(Node)).void }
+      def visit(node)
+        case node
+        when Tree
+          visit_all(node.nodes.dup)
+
+        when Attr
+          replace(node, with: node.convert_to_methods)
+        end
+      end
+
+      private
+
+      sig { params(node: Node, with: T::Array[Node]).void }
+      def replace(node, with:)
+        tree = node.parent_tree
+        raise ReplaceNodeError, "Can't replace #{self} without a parent tree" unless tree
+
+        node.detach
+        with.each { |node| tree << node }
+      end
+    end
+  end
+
+  class Tree
+    extend T::Sig
+
+    sig { void }
+    def replace_attributes_with_methods!
+      visitor = Rewriters::AttrToMethods.new
+      visitor.visit(self)
+    end
+  end
+
+  class Attr
+    sig { abstract.returns(T::Array[Method]) }
+    def convert_to_methods; end
+
+    private
+
+    sig(:final) { returns([T.nilable(Sig), T.nilable(String)]) }
+    def parse_sig
+      raise UnexpectedMultipleSigsError, self if 1 < sigs.count
+
+      sig = sigs.first
+      return [nil, nil] unless sig
+
+      attribute_type = case self
+      when AttrReader, AttrAccessor then sig.return_type
+      when AttrWriter then sig.params.first&.type
+      end
+
+      [sig, attribute_type]
+    end
+
+    sig do
+      params(
+        name: String,
+        sig: T.nilable(Sig),
+        visibility: Visibility,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+      ).returns(Method)
+    end
+    def create_getter_method(name, sig, visibility, loc, comments)
+      Method.new(
+        name,
+        params: [],
+        visibility: visibility,
+        sigs: sig ? [sig] : [],
+        loc: loc,
+        comments: comments,
+      )
+    end
+
+    sig do
+      params(
+        name: String,
+        sig: T.nilable(Sig),
+        attribute_type: T.nilable(String),
+        visibility: Visibility,
+        loc: T.nilable(Loc),
+        comments: T::Array[Comment],
+      ).returns(Method)
+    end
+    def create_setter_method(name, sig, attribute_type, visibility, loc, comments) # rubocop:disable Metrics/ParameterLists
+      sig = if sig # Modify the original sig to correct the name, and remove the return type
+        params = attribute_type ? [SigParam.new(name, attribute_type)] : []
+
+        Sig.new(
+          params: params,
+          return_type: "void",
+          is_abstract: sig.is_abstract,
+          is_override: sig.is_override,
+          is_overridable: sig.is_overridable,
+          is_final: sig.is_final,
+          type_params: sig.type_params,
+          checked: sig.checked,
+          loc: sig.loc,
+        )
+      end
+
+      Method.new(
+        "#{name}=",
+        params: [ReqParam.new(name)],
+        visibility: visibility,
+        sigs: sig ? [sig] : [],
+        loc: loc,
+        comments: comments,
+      )
+    end
+  end
+
+  class AttrAccessor
+    sig { override.returns(T::Array[Method]) }
+    def convert_to_methods
+      sig, attribute_type = parse_sig
+
+      names.flat_map do |name|
+        [
+          create_getter_method(name.to_s, sig, visibility, loc, comments),
+          create_setter_method(name.to_s, sig, attribute_type, visibility, loc, comments),
+        ]
+      end
+    end
+  end
+
+  class AttrReader
+    sig { override.returns(T::Array[Method]) }
+    def convert_to_methods
+      sig, _ = parse_sig
+
+      names.map { |name| create_getter_method(name.to_s, sig, visibility, loc, comments) }
+    end
+  end
+
+  class AttrWriter
+    sig { override.returns(T::Array[Method]) }
+    def convert_to_methods
+      sig, attribute_type = parse_sig
+
+      names.map { |name| create_setter_method(name.to_s, sig, attribute_type, visibility, loc, comments) }
+    end
+  end
+end

data/lib/rbi/rewriters/group_nodes.rb

@@ -2,6 +2,8 @@
 # frozen_string_literal: true
 
 module RBI
+  class GroupNodesError < Error; end
+
   module Rewriters
     class GroupNodes < Visitor
       extend T::Sig
@@ -12,8 +14,7 @@ module RBI
 
         case node
         when Tree
-          kinds = node.nodes.map(&:group_kind)
-          kinds.compact!
+          kinds = node.nodes.map { |child| group_kind(child) }
           kinds.uniq!
 
           groups = {}
@@ -22,12 +23,54 @@ module RBI
           node.nodes.dup.each do |child|
             visit(child)
             child.detach
-            groups[child.group_kind] << child
+            groups[group_kind(child)] << child
           end
 
           groups.each { |_, group| node << group }
         end
       end
+
+      private
+
+      sig { params(node: Node).returns(Group::Kind) }
+      def group_kind(node)
+        case node
+        when Group
+          node.kind
+        when Include, Extend
+          Group::Kind::Mixins
+        when RequiresAncestor
+          Group::Kind::RequiredAncestors
+        when Helper
+          Group::Kind::Helpers
+        when TypeMember
+          Group::Kind::TypeMembers
+        when MixesInClassMethods
+          Group::Kind::MixesInClassMethods
+        when Send
+          Group::Kind::Sends
+        when Attr
+          Group::Kind::Attrs
+        when TStructField
+          Group::Kind::TStructFields
+        when TEnumBlock
+          Group::Kind::TEnums
+        when VisibilityGroup
+          Group::Kind::Methods
+        when Method
+          if node.name == "initialize"
+            Group::Kind::Inits
+          else
+            Group::Kind::Methods
+          end
+        when SingletonClass
+          Group::Kind::SingletonClasses
+        when Scope, Const
+          Group::Kind::Consts
+        else
+          raise GroupNodesError, "Unknown group for #{self}"
+        end
+      end
     end
   end
 
@@ -41,50 +84,6 @@ module RBI
     end
   end
 
-  class Node
-    extend T::Sig
-
-    sig { returns(Group::Kind) }
-    def group_kind
-      case self
-      when Group
-        kind
-      when Include, Extend
-        Group::Kind::Mixins
-      when RequiresAncestor
-        Group::Kind::RequiredAncestors
-      when Helper
-        Group::Kind::Helpers
-      when TypeMember
-        Group::Kind::TypeMembers
-      when MixesInClassMethods
-        Group::Kind::MixesInClassMethods
-      when Send
-        Group::Kind::Sends
-      when Attr
-        Group::Kind::Attrs
-      when TStructField
-        Group::Kind::TStructFields
-      when TEnumBlock
-        Group::Kind::TEnums
-      when VisibilityGroup
-        Group::Kind::Methods
-      when Method
-        if name == "initialize"
-          Group::Kind::Inits
-        else
-          Group::Kind::Methods
-        end
-      when SingletonClass
-        Group::Kind::SingletonClasses
-      when Scope, Const
-        Group::Kind::Consts
-      else
-        raise "Unknown group for #{self}"
-      end
-    end
-  end
-
   class Group < Tree
     extend T::Sig
 

data/lib/rbi/rewriters/merge_trees.rb

@@ -348,6 +348,8 @@ module RBI
     end
   end
 
+  class DuplicateNodeError < Error; end
+
   class Scope
     extend T::Sig
 
@@ -364,7 +366,7 @@ module RBI
       when SingletonClass
         SingletonClass.new(loc: loc, comments: comments)
       else
-        raise "Can't duplicate node #{self}"
+        raise DuplicateNodeError, "Can't duplicate node #{self}"
       end
     end
   end
@@ -592,6 +594,9 @@ module RBI
     sig { returns(Tree) }
     attr_reader :left, :right
 
+    sig { returns(String) }
+    attr_reader :left_name, :right_name
+
     sig { params(left_name: String, right_name: String).void }
     def initialize(left_name: "left", right_name: "right")
       super()
@@ -602,15 +607,6 @@ module RBI
       @right = T.let(Tree.new, Tree)
       @right.parent_tree = self
     end
-
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      v.printl("<<<<<<< #{@left_name}")
-      v.visit(left)
-      v.printl("=======")
-      v.visit(right)
-      v.printl(">>>>>>> #{@right_name}")
-    end
   end
 
   # A conflict between two scope headers
@@ -631,6 +627,9 @@ module RBI
     sig { returns(Scope) }
     attr_reader :left, :right
 
+    sig { returns(String) }
+    attr_reader :left_name, :right_name
+
     sig do
       params(
         left: Scope,
@@ -646,26 +645,5 @@ module RBI
       @left_name = left_name
       @right_name = right_name
     end
-
-    sig { override.params(v: Printer).void }
-    def accept_printer(v)
-      previous_node = v.previous_node
-      v.printn if previous_node && (!previous_node.oneline? || !oneline?)
-
-      v.printl("# #{loc}") if loc && v.print_locs
-      v.visit_all(comments)
-
-      v.printl("<<<<<<< #{@left_name}")
-      left.print_header(v)
-      v.printl("=======")
-      right.print_header(v)
-      v.printl(">>>>>>> #{@right_name}")
-      left.print_body(v)
-    end
-
-    sig { override.returns(T::Boolean) }
-    def oneline?
-      left.oneline?
-    end
   end
 end

data/lib/rbi/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module RBI
-  VERSION = "0.1.13"
+  VERSION = "0.1.14"
 end

data/lib/rbi/visitor.rb

@@ -2,18 +2,244 @@
 # frozen_string_literal: true
 
 module RBI
+  class VisitorError < Error; end
+
   class Visitor
     extend T::Helpers
     extend T::Sig
 
     abstract!
 
-    sig { abstract.params(node: T.nilable(Node)).void }
-    def visit(node); end
+    sig { params(node: T.nilable(Node)).void }
+    def visit(node)
+      return unless node
+
+      case node
+      when BlankLine
+        visit_blank_line(node)
+      when Comment
+        visit_comment(node)
+      when Module
+        visit_module(node)
+      when Class
+        visit_class(node)
+      when SingletonClass
+        visit_singleton_class(node)
+      when Struct
+        visit_struct(node)
+      when Group
+        visit_group(node)
+      when VisibilityGroup
+        visit_visibility_group(node)
+      when ConflictTree
+        visit_conflict_tree(node)
+      when ScopeConflict
+        visit_scope_conflict(node)
+      when Tree
+        visit_tree(node)
+      when Const
+        visit_const(node)
+      when AttrAccessor
+        visit_attr_accessor(node)
+      when AttrReader
+        visit_attr_reader(node)
+      when AttrWriter
+        visit_attr_writer(node)
+      when Method
+        visit_method(node)
+      when ReqParam
+        visit_req_param(node)
+      when OptParam
+        visit_opt_param(node)
+      when RestParam
+        visit_rest_param(node)
+      when KwParam
+        visit_kw_param(node)
+      when KwOptParam
+        visit_kw_opt_param(node)
+      when KwRestParam
+        visit_kw_rest_param(node)
+      when BlockParam
+        visit_block_param(node)
+      when Include
+        visit_include(node)
+      when Extend
+        visit_extend(node)
+      when Public
+        visit_public(node)
+      when Protected
+        visit_protected(node)
+      when Private
+        visit_private(node)
+      when Send
+        visit_send(node)
+      when KwArg
+        visit_kw_arg(node)
+      when Arg
+        visit_arg(node)
+      when Sig
+        visit_sig(node)
+      when SigParam
+        visit_sig_param(node)
+      when TStruct
+        visit_tstruct(node)
+      when TStructConst
+        visit_tstruct_const(node)
+      when TStructProp
+        visit_tstruct_prop(node)
+      when TEnum
+        visit_tenum(node)
+      when TEnumBlock
+        visit_tenum_block(node)
+      when Helper
+        visit_helper(node)
+      when TypeMember
+        visit_type_member(node)
+      when MixesInClassMethods
+        visit_mixes_in_class_methods(node)
+      when RequiresAncestor
+        visit_requires_ancestor(node)
+      else
+        raise VisitorError, "Unhandled node: #{node.class}"
+      end
+    end
 
     sig { params(nodes: T::Array[Node]).void }
     def visit_all(nodes)
       nodes.each { |node| visit(node) }
     end
+
+    sig { params(file: File).void }
+    def visit_file(file)
+      visit(file.root)
+    end
+
+    private
+
+    sig { params(node: Comment).void }
+    def visit_comment(node); end
+
+    sig { params(node: BlankLine).void }
+    def visit_blank_line(node); end
+
+    sig { params(node: Module).void }
+    def visit_module(node); end
+
+    sig { params(node: Class).void }
+    def visit_class(node); end
+
+    sig { params(node: SingletonClass).void }
+    def visit_singleton_class(node); end
+
+    sig { params(node: Struct).void }
+    def visit_struct(node); end
+
+    sig { params(node: Tree).void }
+    def visit_tree(node); end
+
+    sig { params(node: Const).void }
+    def visit_const(node); end
+
+    sig { params(node: AttrAccessor).void }
+    def visit_attr_accessor(node); end
+
+    sig { params(node: AttrReader).void }
+    def visit_attr_reader(node); end
+
+    sig { params(node: AttrWriter).void }
+    def visit_attr_writer(node); end
+
+    sig { params(node: Method).void }
+    def visit_method(node); end
+
+    sig { params(node: ReqParam).void }
+    def visit_req_param(node); end
+
+    sig { params(node: OptParam).void }
+    def visit_opt_param(node); end
+
+    sig { params(node: RestParam).void }
+    def visit_rest_param(node); end
+
+    sig { params(node: KwParam).void }
+    def visit_kw_param(node); end
+
+    sig { params(node: KwOptParam).void }
+    def visit_kw_opt_param(node); end
+
+    sig { params(node: KwRestParam).void }
+    def visit_kw_rest_param(node); end
+
+    sig { params(node: BlockParam).void }
+    def visit_block_param(node); end
+
+    sig { params(node: Include).void }
+    def visit_include(node); end
+
+    sig { params(node: Extend).void }
+    def visit_extend(node); end
+
+    sig { params(node: Public).void }
+    def visit_public(node); end
+
+    sig { params(node: Protected).void }
+    def visit_protected(node); end
+
+    sig { params(node: Private).void }
+    def visit_private(node); end
+
+    sig { params(node: Send).void }
+    def visit_send(node); end
+
+    sig { params(node: Arg).void }
+    def visit_arg(node); end
+
+    sig { params(node: KwArg).void }
+    def visit_kw_arg(node); end
+
+    sig { params(node: Sig).void }
+    def visit_sig(node); end
+
+    sig { params(node: SigParam).void }
+    def visit_sig_param(node); end
+
+    sig { params(node: TStruct).void }
+    def visit_tstruct(node); end
+
+    sig { params(node: TStructConst).void }
+    def visit_tstruct_const(node); end
+
+    sig { params(node: TStructProp).void }
+    def visit_tstruct_prop(node); end
+
+    sig { params(node: TEnum).void }
+    def visit_tenum(node); end
+
+    sig { params(node: TEnumBlock).void }
+    def visit_tenum_block(node); end
+
+    sig { params(node: Helper).void }
+    def visit_helper(node); end
+
+    sig { params(node: TypeMember).void }
+    def visit_type_member(node); end
+
+    sig { params(node: MixesInClassMethods).void }
+    def visit_mixes_in_class_methods(node); end
+
+    sig { params(node: RequiresAncestor).void }
+    def visit_requires_ancestor(node); end
+
+    sig { params(node: Group).void }
+    def visit_group(node); end
+
+    sig { params(node: VisibilityGroup).void }
+    def visit_visibility_group(node); end
+
+    sig { params(node: ConflictTree).void }
+    def visit_conflict_tree(node); end
+
+    sig { params(node: ScopeConflict).void }
+    def visit_scope_conflict(node); end
   end
 end

data/lib/rbi.rb

@@ -3,6 +3,13 @@
 
 require "sorbet-runtime"
 require "stringio"
+
+module RBI
+  class Error < StandardError
+    extend T::Sig
+  end
+end
+
 require "rbi/loc"
 require "rbi/model"
 require "rbi/visitor"
@@ -16,6 +23,7 @@ require "rbi/rewriters/nest_singleton_methods"
 require "rbi/rewriters/nest_non_public_methods"
 require "rbi/rewriters/group_nodes"
 require "rbi/rewriters/remove_known_definitions"
+require "rbi/rewriters/attr_to_methods"
 require "rbi/rewriters/sort_nodes"
 require "rbi/parser"
 require "rbi/printer"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbi
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.14
 platform: ruby
 authors:
 - Alexandre Terrasa
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-06 00:00:00.000000000 Z
+date: 2024-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prism
@@ -44,7 +44,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.5.9204
-description: 
+description:
 email:
 - ruby@shopify.com
 executables: []
@@ -63,6 +63,7 @@ files:
 - lib/rbi/printer.rb
 - lib/rbi/rewriters/add_sig_templates.rb
 - lib/rbi/rewriters/annotate.rb
+- lib/rbi/rewriters/attr_to_methods.rb
 - lib/rbi/rewriters/deannotate.rb
 - lib/rbi/rewriters/filter_versions.rb
 - lib/rbi/rewriters/group_nodes.rb
@@ -78,7 +79,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -93,8 +94,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
-signing_key: 
+rubygems_version: 3.5.15
+signing_key:
 specification_version: 4
 summary: RBI generation framework
 test_files: []