feat(ancestry): Add types for v5.0 (#1032)

* feat(ancestry): Add types for v5.0

Copied from 4.9

* feat(ancestry): Update class_methods types for v5.0

* feat(ancestry): Update has_ancestry types for v5.0

* feat(ancestry): Update instance_methods types for v5.0

* feat(ancestry): Update materialized_path types for v5.0

* feat(ancestry): Update materialized_path2 types for v5.0

* feat(ancestry): Update materialized_path_pg types for v5.0

Author: sanfrecce-osaka

gems/ancestry/5.0/_test/metadata.yaml

@@ -0,0 +1,4 @@
+# If the test needs gem's RBS files, declare them here.
+#
+additional_gems:
+  - activerecord

gems/ancestry/5.0/_test/test.rb

@@ -0,0 +1,99 @@
+require 'ancestry'
+
+Ancestry.default_ancestry_format = :materialized_path2
+Ancestry.default_ancestry_format
+Ancestry.default_update_strategy = :sql
+Ancestry.default_update_strategy
+Ancestry.default_primary_key_format = '[-A-Fa-f0-9]{36}'
+Ancestry.default_primary_key_format
+
+class Directory < ActiveRecord::Base
+  has_ancestry
+
+  def rank
+    1
+  end
+end
+
+class Group < ActiveRecord::Base
+  has_ancestry ancestry_column: :ancestry, orphan_strategy: :rootify, touch: true, counter_cache: true, primary_key_format: '[-A-Fa-f0-9]{36}', update_strategy: :sql, ancestry_format: :materialized_path2
+end
+
+class Category < ActiveRecord::Base
+  has_ancestry orphan_strategy: :adopt, cache_depth: true, depth_cache_column: :ancestry_depth_cache, update_strategy: :ruby, ancestry_format: :materialized_path
+end
+
+class Tag < ActiveRecord::Base
+  has_ancestry orphan_strategy: :none
+end
+
+class Item < ActiveRecord::Base
+  has_ancestry cache_depth: 'item_depth'
+end
+
+class Node < ActiveRecord::Base
+  has_ancestry cache_depth: :virtual
+end
+
+class MySerializer
+  def initialize(parent, children:)
+    @parent = parent
+    @children = children
+  end
+end
+
+Category.build_ancestry_from_parent_ids!
+Category.check_ancestry_integrity!
+Category.rebuild_depth_cache!
+Category.rebuild_depth_cache_sql!
+
+Group.rebuild_counter_cache!
+
+Directory.arrange_nodes(Directory.all)
+Directory.arrange_nodes(Directory.all, orphan_strategy: :rootify)
+Directory.arrange_nodes(Directory.all, orphan_strategy: :destroy)
+Directory.arrange_nodes(Directory.roots.to_a, orphan_strategy: :rootify)
+
+Directory.ancestry_depth_change('1/2', '1/2/3')
+Directory.ancestry_depth_change(nil, '1')
+
+node = Directory.find(1)
+Directory.find(2).in_subtree_of?(node)
+
+Directory.find(1).ancestors(from_depth: -6, to_depth: -4)
+Directory.find(1).descendants(from_depth: 2, to_depth: 4)
+Directory.find(1).path(from_depth: 3, to_depth: 4)
+Directory.find(1).subtree(from_depth: 10, to_depth: 12)
+
+Directory.arrange(order: 'id desc')
+Directory.find_by!(name: 'Crunchy').subtree.arrange
+Directory.find_by!(name: 'Crunchy').subtree.arrange(order: :name)
+
+Directory.roots.to_a
+Directory.ancestors_of(Directory.find(1).ancestors.first!).ancestors_of(1)
+Directory.children_of(Directory.find(1).children.first!).children_of(1)
+Directory.descendants_of(Directory.find(1).descendants.first!).descendants_of(1)
+Directory.indirects_of(Directory.find(1).indirects.first!).indirects_of(1)
+Directory.subtree_of(Directory.find(1).subtree.first!).subtree_of(1)
+Directory.siblings_of(Directory.find(1).siblings.first!).siblings_of(1)
+Directory.path_of(Directory.find(1).path.first!).path_of(1)
+
+Directory.sort_by_ancestry(Directory.all.ordered_by_ancestry_and(id: :desc))
+Directory.sort_by_ancestry(Directory.all.ordered_by_ancestry_and(id: :desc).offset(3).take(2))
+Directory.sort_by_ancestry(Directory.all.ordered_by_ancestry_and(:rank))
+Directory.sort_by_ancestry(Directory.all.ordered_by_ancestry_and(:rank)) { |a, b| a.rank <=> b.rank }
+
+Group.arrange_serializable(order: :name)
+Group.arrange_serializable { |parent, children| MySerializer.new(parent, children:) }
+Group.arrange_serializable do |parent, children|
+  {
+    my_parent: parent,
+    my_children: children
+  }
+end
+Group.arrange_serializable(order: 'id desc') do |parent, children|
+  out = {} #: Hash[String, untyped]
+  out['parent'] = parent
+  out['children'] = children if children.count > 1
+  out
+end

gems/ancestry/5.0/_test/test.rbs

@@ -0,0 +1,88 @@
+class ActiveRecord::Base
+  extend Ancestry::HasAncestry
+end
+
+class Directory < ActiveRecord::Base
+  include Ancestry::InstanceMethods[Directory, ActiveRecord_Relation, Integer]
+  extend Ancestry::ClassMethods[Directory, ActiveRecord_Relation, Integer]
+  extend Ancestry::MaterializedPath[Directory, ActiveRecord_Relation, Integer]
+  include Ancestry::MaterializedPath::InstanceMethods[Directory, Integer]
+  extend ActiveRecord::Base::ClassMethods[Directory, ActiveRecord_Relation, Integer]
+
+  def rank: () -> Integer
+
+  class ActiveRecord_Relation < ::ActiveRecord::Relation
+    include ::ActiveRecord::Relation::Methods[Directory, ::Integer]
+    include Ancestry::ClassMethods[Directory, ActiveRecord_Relation, Integer]
+    include Ancestry::MaterializedPath[Directory, ActiveRecord_Relation, Integer]
+  end
+end
+
+class Group < ActiveRecord::Base
+  include Ancestry::InstanceMethods[Group, ActiveRecord_Relation, Integer]
+  extend Ancestry::ClassMethods[Group, ActiveRecord_Relation, Integer]
+  extend Ancestry::MaterializedPath2[Group, ActiveRecord_Relation, Integer]
+  include Ancestry::MaterializedPathPg
+  include Ancestry::MaterializedPath::InstanceMethods[Group, Integer]
+  include Ancestry::MaterializedPath2::InstanceMethods[Integer]
+
+  class ActiveRecord_Relation < ::ActiveRecord::Relation
+    include Ancestry::ClassMethods[Group, ActiveRecord_Relation, Integer]
+    include Ancestry::MaterializedPath2[Directory, ActiveRecord_Relation, Integer]
+  end
+end
+
+class Category < ActiveRecord::Base
+  include Ancestry::InstanceMethods[Category, ActiveRecord_Relation, Integer]
+  extend Ancestry::ClassMethods[Category, ActiveRecord_Relation, Integer]
+  extend Ancestry::MaterializedPath[Category, ActiveRecord_Relation, Integer]
+  include Ancestry::MaterializedPath::InstanceMethods[Category, Integer]
+
+  class ActiveRecord_Relation < ::ActiveRecord::Relation
+    include Ancestry::ClassMethods[Category, ActiveRecord_Relation, Integer]
+    include Ancestry::MaterializedPath[Category, ActiveRecord_Relation, Integer]
+  end
+end
+
+class Tag < ActiveRecord::Base
+  include Ancestry::InstanceMethods[Tag, ActiveRecord_Relation, Integer]
+  extend Ancestry::ClassMethods[Tag, ActiveRecord_Relation, Integer]
+  extend Ancestry::MaterializedPath[Tag, ActiveRecord_Relation, Integer]
+  include Ancestry::MaterializedPath::InstanceMethods[Tag, Integer]
+
+  class ActiveRecord_Relation < ::ActiveRecord::Relation
+    include Ancestry::ClassMethods[Tag, ActiveRecord_Relation, Integer]
+    include Ancestry::MaterializedPath[Tag, ActiveRecord_Relation, Integer]
+  end
+end
+
+class Item < ActiveRecord::Base
+  include Ancestry::InstanceMethods[Item, ActiveRecord_Relation, Integer]
+  extend Ancestry::ClassMethods[Item, ActiveRecord_Relation, Integer]
+  extend Ancestry::MaterializedPath[Item, ActiveRecord_Relation, Integer]
+  include Ancestry::MaterializedPath::InstanceMethods[Item, Integer]
+
+  class ActiveRecord_Relation < ::ActiveRecord::Relation
+    include Ancestry::ClassMethods[Item, ActiveRecord_Relation, Integer]
+    include Ancestry::MaterializedPath[Item, ActiveRecord_Relation, Integer]
+  end
+end
+
+class Node < ActiveRecord::Base
+  include Ancestry::InstanceMethods[Node, ActiveRecord_Relation, Integer]
+  extend Ancestry::ClassMethods[Node, ActiveRecord_Relation, Integer]
+  extend Ancestry::MaterializedPath[Node, ActiveRecord_Relation, Integer]
+  include Ancestry::MaterializedPath::InstanceMethods[Node, Integer]
+
+  class ActiveRecord_Relation < ::ActiveRecord::Relation
+    include Ancestry::ClassMethods[Node, ActiveRecord_Relation, Integer]
+    include Ancestry::MaterializedPath[Node, ActiveRecord_Relation, Integer]
+  end
+end
+
+class MySerializer
+  @parent: untyped
+  @children: Array[untyped]
+
+  def initialize: (untyped parent, children: Array[untyped]) -> void
+end

gems/ancestry/5.0/ancestry.rbs

@@ -0,0 +1,15 @@
+module Ancestry
+  type depth_options = Hash[:before_depth | :to_depth | :at_depth | :from_depth | :after_depth, Integer]
+
+  def self.default_update_strategy: () -> (:sql | :ruby)
+
+  def self.default_update_strategy=: (:sql | :ruby value) -> void
+
+  def self.default_ancestry_format: () -> (:materialized_path | :materialized_path2)
+
+  def self.default_ancestry_format=: (:materialized_path | :materialized_path2 value) -> void
+
+  def self.default_primary_key_format: () -> ('[0-9]+' | '[-A-Fa-f0-9]{36}')
+
+  def self.default_primary_key_format=: ('[0-9]+' | '[-A-Fa-f0-9]{36}' value) -> void
+end

gems/ancestry/5.0/ancestry/class_methods.rbs

@@ -0,0 +1,39 @@
+module Ancestry
+  module ClassMethods[AncestryBaseClass, Relation, PrimaryKey]
+    def to_node: (AncestryBaseClass | PrimaryKey object) -> AncestryBaseClass
+               | (untyped object) -> AncestryBaseClass
+
+    def scope_depth: (depth_options depth_options, Integer depth) -> Relation
+
+    def arrange: (?Hash[untyped, untyped] options) -> Hash[AncestryBaseClass, Hash[AncestryBaseClass, untyped]]
+
+    def arrange_nodes: (Relation | Array[AncestryBaseClass] nodes, ?orphan_strategy: :rootify | :destroy) -> Hash[AncestryBaseClass, Hash[AncestryBaseClass, untyped]]
+
+    def flatten_arranged_nodes: (Hash[AncestryBaseClass, Hash[AncestryBaseClass, untyped]] arranged, ?Array[AncestryBaseClass] nodes) -> Array[AncestryBaseClass]
+
+    def arrange_serializable: [R] (?Hash[untyped, untyped] options, ?Hash[AncestryBaseClass, Hash[AncestryBaseClass, untyped]]? nodes) ?{ (AncestryBaseClass parent, Array[R]) -> R } -> Array[R]
+                            | (?Hash[untyped, untyped] options, ?Hash[AncestryBaseClass, Hash[AncestryBaseClass, untyped]]? nodes) -> Array[Hash[String, untyped]]
+
+    def tree_view: (String | Symbol column, ?Hash[AncestryBaseClass, Hash[AncestryBaseClass, untyped]]? data) -> void
+
+    def sort_by_ancestry: (Relation | Array[AncestryBaseClass] | Hash[AncestryBaseClass, Hash[AncestryBaseClass, untyped]]) ?{ (AncestryBaseClass a, AncestryBaseClass b) -> Integer? } -> Array[AncestryBaseClass]
+
+    def check_ancestry_integrity!: (?{ ?report: :list | :echo } options) -> void
+
+    def restore_ancestry_integrity!: () -> void
+
+    def build_ancestry_from_parent_ids!: (?String | Symbol column, ?PrimaryKey? parent_id, ?Array[PrimaryKey] ancestor_ids) -> void
+
+    def rebuild_depth_cache!: () -> void
+
+    def rebuild_depth_cache_sql!: () -> void
+
+    def rebuild_counter_cache!: () -> void
+
+    def unscoped_where: [R] () { (Relation scope) -> R } -> R
+
+    ANCESTRY_UNCAST_TYPES: [:string, :uuid, :text]
+
+    def primary_key_is_an_integer?: () -> bool
+  end
+end

gems/ancestry/5.0/ancestry/exceptions.rbs

@@ -0,0 +1,7 @@
+module Ancestry
+  class AncestryException < RuntimeError
+  end
+
+  class AncestryIntegrityException < AncestryException
+  end
+end

gems/ancestry/5.0/ancestry/has_ancestry.rbs

@@ -0,0 +1,20 @@
+module Ancestry
+  module HasAncestry
+    def has_ancestry: (?{
+        ?ancestry_column: String | Symbol,
+        ?orphan_strategy: :destroy | :rootify | :restrict | :adopt | :none,
+        ?cache_depth: bool | String | :virtual | Symbol,
+        ?depth_cache_column: String | Symbol,
+        ?touch: bool,
+        ?counter_cache: bool | String | Symbol,
+        ?primary_key_format: '[0-9]+' | '[-A-Fa-f0-9]{36}',
+        ?update_strategy: :sql | :ruby,
+        ?ancestry_format: :materialized_path | :materialized_path2 } options) -> void
+
+    def acts_as_tree: (*untyped args) -> void
+
+    def self.ancestry_format_module: (:materialized_path2 ancestry_format) -> singleton(MaterializedPath2)
+                                   | (:materialized_path ancestry_format) -> singleton(MaterializedPath)
+                                   | (nil ancestry_format) -> (singleton(MaterializedPath2) | singleton(MaterializedPath))
+  end
+end