tapioca 0.4.17 → 0.4.22

data/lib/tapioca/rbi/rewriters/group_nodes.rb

@@ -0,0 +1,106 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module RBI
+    module Rewriters
+      class GroupNodes < Visitor
+        extend T::Sig
+
+        sig { override.params(node: T.nilable(Node)).void }
+        def visit(node)
+          return unless node
+
+          case node
+          when Tree
+            kinds = node.nodes.map(&:group_kind)
+            kinds.compact!
+            kinds.uniq!
+
+            groups = {}
+            kinds.each { |kind| groups[kind] = Group.new(kind) }
+
+            node.nodes.dup.each do |child|
+              visit(child)
+              child.detach
+              groups[child.group_kind] << child
+            end
+
+            groups.each { |_, group| node << group }
+          end
+        end
+      end
+    end
+
+    class Tree
+      extend T::Sig
+
+      sig { void }
+      def group_nodes!
+        visitor = Rewriters::GroupNodes.new
+        visitor.visit(self)
+      end
+    end
+
+    class Node
+      extend T::Sig
+
+      sig { returns(Group::Kind) }
+      def group_kind
+        case self
+        when Include, Extend
+          Group::Kind::Mixins
+        when Helper
+          Group::Kind::Helpers
+        when TypeMember
+          Group::Kind::TypeMembers
+        when MixesInClassMethods
+          Group::Kind::MixesInClassMethods
+        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 Scope, Const
+          Group::Kind::Consts
+        else
+          raise "Unknown group for #{self}"
+        end
+      end
+    end
+
+    class Group < Tree
+      extend T::Sig
+
+      sig { returns(Kind) }
+      attr_reader :kind
+
+      sig { params(kind: Kind).void }
+      def initialize(kind)
+        super()
+        @kind = kind
+      end
+
+      class Kind < T::Enum
+        enums do
+          Mixins              = new
+          Helpers             = new
+          TypeMembers         = new
+          MixesInClassMethods = new
+          TStructFields       = new
+          TEnums              = new
+          Inits               = new
+          Methods             = new
+          Consts              = new
+        end
+      end
+    end
+  end
+end

data/lib/tapioca/rbi/rewriters/nest_non_public_methods.rb

@@ -0,0 +1,65 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module RBI
+    module Rewriters
+      class NestNonPublicMethods < Visitor
+        extend T::Sig
+
+        sig { override.params(node: T.nilable(Node)).void }
+        def visit(node)
+          return unless node
+
+          case node
+          when Tree
+            public_group = VisibilityGroup.new(Visibility::Public)
+            protected_group = VisibilityGroup.new(Visibility::Protected)
+            private_group = VisibilityGroup.new(Visibility::Private)
+
+            node.nodes.dup.each do |child|
+              visit(child)
+              next unless child.is_a?(Method)
+              child.detach
+              case child.visibility
+              when Visibility::Protected
+                protected_group << child
+              when Visibility::Private
+                private_group << child
+              else
+                public_group << child
+              end
+            end
+
+            node << public_group unless public_group.empty?
+            node << protected_group unless protected_group.empty?
+            node << private_group unless private_group.empty?
+          end
+        end
+      end
+    end
+
+    class Tree
+      extend T::Sig
+
+      sig { void }
+      def nest_non_public_methods!
+        visitor = Rewriters::NestNonPublicMethods.new
+        visitor.visit(self)
+      end
+    end
+
+    class VisibilityGroup < Tree
+      extend T::Sig
+
+      sig { returns(Visibility) }
+      attr_reader :visibility
+
+      sig { params(visibility: Visibility).void }
+      def initialize(visibility)
+        super()
+        @visibility = visibility
+      end
+    end
+  end
+end

data/lib/tapioca/rbi/rewriters/nest_singleton_methods.rb

@@ -0,0 +1,42 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module RBI
+    module Rewriters
+      class NestSingletonMethods < Visitor
+        extend T::Sig
+
+        sig { override.params(node: T.nilable(Node)).void }
+        def visit(node)
+          return unless node
+
+          case node
+          when Tree
+            singleton_class = SingletonClass.new
+
+            node.nodes.dup.each do |child|
+              visit(child)
+              next unless child.is_a?(Method) && child.is_singleton
+              child.detach
+              child.is_singleton = false
+              singleton_class << child
+            end
+
+            node << singleton_class unless singleton_class.empty?
+          end
+        end
+      end
+    end
+
+    class Tree
+      extend T::Sig
+
+      sig { void }
+      def nest_singleton_methods!
+        visitor = Rewriters::NestSingletonMethods.new
+        visitor.visit(self)
+      end
+    end
+  end
+end

data/lib/tapioca/rbi/rewriters/sort_nodes.rb

@@ -0,0 +1,82 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module RBI
+    module Rewriters
+      class SortNodes < Visitor
+        extend T::Sig
+
+        sig { override.params(node: T.nilable(Node)).void }
+        def visit(node)
+          return unless node.is_a?(Tree)
+          visit_all(node.nodes)
+          node.nodes.sort! do |a, b|
+            res = node_rank(a) <=> node_rank(b)
+            res = node_name(a) <=> node_name(b) if res == 0
+            res || 0
+          end
+        end
+
+        private
+
+        sig { params(node: Node).returns(Integer) }
+        def node_rank(node)
+          case node
+          when Group                then kind_rank(node.kind)
+          when Include, Extend      then 0
+          when Helper               then 1
+          when TypeMember           then 2
+          when MixesInClassMethods  then 3
+          when TStructField         then 4
+          when TEnumBlock           then 5
+          when Method
+            if node.name == "initialize"
+              7
+            else
+              8
+            end
+          when Scope, Const then 9
+          else
+            10
+          end
+        end
+
+        sig { params(kind: Group::Kind).returns(Integer) }
+        def kind_rank(kind)
+          case kind
+          when Group::Kind::Mixins              then 0
+          when Group::Kind::Helpers             then 1
+          when Group::Kind::TypeMembers         then 2
+          when Group::Kind::MixesInClassMethods then 3
+          when Group::Kind::TStructFields       then 4
+          when Group::Kind::TEnums              then 5
+          when Group::Kind::Inits               then 6
+          when Group::Kind::Methods             then 7
+          when Group::Kind::Consts              then 8
+          else
+            T.absurd(kind)
+          end
+        end
+
+        sig { params(node: Node).returns(T.nilable(String)) }
+        def node_name(node)
+          case node
+          when Module, Class, Const, Method, Helper, TStructField
+            node.name
+          end
+        end
+      end
+    end
+
+    class Tree
+      extend T::Sig
+
+      sig { void }
+      def sort_nodes!
+        visitor = Rewriters::SortNodes.new
+        visitor.visit(self)
+      end
+    end
+  end
+end

data/lib/tapioca/rbi/visitor.rb

@@ -0,0 +1,21 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Tapioca
+  module RBI
+    class Visitor
+      extend T::Helpers
+      extend T::Sig
+
+      abstract!
+
+      sig { abstract.params(node: T.nilable(Node)).void }
+      def visit(node); end
+
+      sig { params(nodes: T::Array[Node]).void }
+      def visit_all(nodes)
+        nodes.each { |node| visit(node) }
+      end
+    end
+  end
+end

data/lib/tapioca/sorbet_ext/generic_name_patch.rb

@@ -0,0 +1,66 @@
+# typed: true
+# frozen_string_literal: true
+
+require "tapioca/sorbet_ext/name_patch"
+
+module T
+  module Generic
+    # This module intercepts calls to generic type instantiations and type variable definitions.
+    # Tapioca stores the data from those calls in a `GenericTypeRegistry` which can then be used
+    # to look up the original call details when we are trying to do code generation.
+    #
+    # We are interested in the data of the `[]`, `type_member` and `type_template` calls which
+    # are all needed to generate good generic information at runtime.
+    module TypeStoragePatch
+      def [](*types)
+        # `T::Generic#[]` just returns `self`, so let's call and store it.
+        constant = super
+        # `register_type` method builds and returns an instantiated clone of the generic type
+        # so, we just return that from this method as well.
+        Tapioca::GenericTypeRegistry.register_type(constant, types)
+      end
+
+      def type_member(variance = :invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
+        # `T::Generic#type_member` just instantiates a `T::Type::TypeMember` instance and returns it.
+        # We use that when registering the type member and then later return it from this method.
+        type_member = super
+        Tapioca::GenericTypeRegistry.register_type_member(self, type_member, fixed, lower, upper)
+        type_member
+      end
+
+      def type_template(variance = :invariant, fixed: nil, lower: T.untyped, upper: BasicObject)
+        # `T::Generic#type_template` just instantiates a `T::Type::TypeTemplate` instance and returns it.
+        # We use that when registering the type template and then later return it from this method.
+        type_template = super
+        Tapioca::GenericTypeRegistry.register_type_template(self, type_template, fixed, lower, upper)
+        type_template
+      end
+    end
+
+    prepend TypeStoragePatch
+  end
+
+  module Types
+    class Simple
+      # This module intercepts calls to the `name` method for
+      # simple types, so that it can ask the name to the type if
+      # the type is generic, since, by this point, we've created
+      # a clone of that type with the `name` method returning the
+      # appropriate name for that specific concrete type.
+      module GenericNamePatch
+        def name
+          if T::Generic === @raw_type
+            # for types that are generic, use the name
+            # returned by the "name" method of this instance
+            @name ||= T.unsafe(@raw_type).name.freeze
+          else
+            # otherwise, fallback to the normal name lookup
+            super
+          end
+        end
+      end
+
+      prepend GenericNamePatch
+    end
+  end
+end

data/lib/tapioca/sorbet_ext/name_patch.rb

@@ -0,0 +1,16 @@
+# typed: true
+# frozen_string_literal: true
+
+module T
+  module Types
+    class Simple
+      module NamePatch
+        def name
+          @name ||= Module.instance_method(:name).bind(@raw_type).call.freeze
+        end
+      end
+
+      prepend NamePatch
+    end
+  end
+end

data/lib/tapioca/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Tapioca
-  VERSION = "0.4.17"
+  VERSION = "0.4.22"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tapioca
 version: !ruby/object:Gem::Version
-  version: 0.4.17
+  version: 0.4.22
 platform: ruby
 authors:
 - Ufuk Kayserilioglu
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-03-11 00:00:00.000000000 Z
+date: 2021-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -125,8 +125,10 @@ files:
 - exe/tapioca
 - lib/tapioca.rb
 - lib/tapioca/cli.rb
+- lib/tapioca/cli/main.rb
 - lib/tapioca/compilers/dsl/action_controller_helpers.rb
 - lib/tapioca/compilers/dsl/action_mailer.rb
+- lib/tapioca/compilers/dsl/active_job.rb
 - lib/tapioca/compilers/dsl/active_record_associations.rb
 - lib/tapioca/compilers/dsl/active_record_columns.rb
 - lib/tapioca/compilers/dsl/active_record_enum.rb
@@ -153,9 +155,21 @@ files:
 - lib/tapioca/config_builder.rb
 - lib/tapioca/constant_locator.rb
 - lib/tapioca/core_ext/class.rb
+- lib/tapioca/core_ext/string.rb
 - lib/tapioca/gemfile.rb
 - lib/tapioca/generator.rb
+- lib/tapioca/generic_type_registry.rb
+- lib/tapioca/internal.rb
 - lib/tapioca/loader.rb
+- lib/tapioca/rbi/model.rb
+- lib/tapioca/rbi/printer.rb
+- lib/tapioca/rbi/rewriters/group_nodes.rb
+- lib/tapioca/rbi/rewriters/nest_non_public_methods.rb
+- lib/tapioca/rbi/rewriters/nest_singleton_methods.rb
+- lib/tapioca/rbi/rewriters/sort_nodes.rb
+- lib/tapioca/rbi/visitor.rb
+- lib/tapioca/sorbet_ext/generic_name_patch.rb
+- lib/tapioca/sorbet_ext/name_patch.rb
 - lib/tapioca/version.rb
 homepage: https://github.com/Shopify/tapioca
 licenses:
@@ -177,7 +191,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.2.17
 signing_key: 
 specification_version: 4
 summary: A Ruby Interface file generator for gems, core types and the Ruby standard