parlour 2.0.0 → 5.0.0.beta.1

data/lib/parlour/rbi_generator/enum_class_namespace.rb

@@ -1,13 +1,13 @@
 # typed: true
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # Represents an enum definition; that is, a class with an +enum+ call.
     class EnumClassNamespace < ClassNamespace
       extend T::Sig
 
       sig do
         params(
-          generator: RbiGenerator,
+          generator: Generator,
           name: String,
           final: T::Boolean,
           enums: T::Array[T.any([String, String], String)],
@@ -38,7 +38,7 @@ module Parlour
       sig do
         override.params(
           indent_level: Integer,
-          options: Options
+          options: Options,
         ).returns(T::Array[String])
       end
       # Generates the RBI lines for the body of this enum. This consists of
@@ -80,10 +80,37 @@ module Parlour
       # @param others [Array<RbiGenerator::RbiObject>] An array of other {EnumClassNamespace} instances.
       # @return [Boolean] Whether this instance may be merged with them.
       def mergeable?(others)
-        others = T.cast(others, T::Array[EnumClassNamespace]) rescue (return false)
+        others = T.cast(others, T::Array[Namespace]) rescue (return false)
         all = others + [self]
+        all_enums = T.cast(all.select { |x| EnumClassNamespace === x }, T::Array[EnumClassNamespace])
 
-        T.must(super && all.map(&:enums).uniq.length <= 1)
+        T.must(super && all_enums.map { |e| e.enums.sort }.reject(&:empty?).uniq.length <= 1)
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).void
+      end
+      # Given an array of {EnumClassNamespace} instances, merges them into this one.
+      # You MUST ensure that {mergeable?} is true for those instances.
+      #
+      # @param others [Array<RbiGenerator::RbiObject>] An array of other {EnumClassNamespace} instances.
+      # @return [void]
+      def merge_into_self(others)
+        super
+
+        others.each do |other|
+          next unless EnumClassNamespace === other
+          other = T.cast(other, EnumClassNamespace)
+
+          @enums = other.enums if enums.empty?
+        end
+      end
+
+      sig { override.void }
+      def generalize_from_rbi!
+        super
       end
     end
   end

data/lib/parlour/rbi_generator/extend.rb

@@ -1,11 +1,11 @@
 # typed: true
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # Represents an +extend+ call.
     class Extend < RbiObject
       sig do
         params(
-          generator: RbiGenerator,
+          generator: Generator,
           name: String,
           block: T.nilable(T.proc.params(x: Extend).void)
         ).void
@@ -82,6 +82,9 @@ module Parlour
       def describe
         "Extend (#{name})"
       end
+
+      sig { override.void }
+      def generalize_from_rbi!; end # Nothing to do
     end
   end
 end

data/lib/parlour/rbi_generator/include.rb

@@ -1,11 +1,11 @@
 # typed: true
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # Represents an +include+ call.
     class Include < RbiObject
       sig do
         params(
-          generator: RbiGenerator,
+          generator: Generator,
           name: String,
           block: T.nilable(T.proc.params(x: Include).void)
         ).void
@@ -82,6 +82,9 @@ module Parlour
       def describe
         "Include (#{name})"
       end
+
+      sig { override.void }
+      def generalize_from_rbi!; end # Nothing to do
     end
   end
 end

data/lib/parlour/rbi_generator/method.rb

@@ -1,16 +1,16 @@
 # typed: true
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # Represents a method definition.
     class Method < RbiObject
       extend T::Sig
 
       sig do
         params(
-          generator: RbiGenerator,
+          generator: Generator,
           name: String,
           parameters: T::Array[Parameter],
-          return_type: T.nilable(String),
+          return_type: T.nilable(Types::TypeLike),
           abstract: T::Boolean,
           implementation: T::Boolean,
           override: T::Boolean,
@@ -29,8 +29,7 @@ module Parlour
       #   this - use the +class_method+ parameter instead.
       # @param parameters [Array<Parameter>] An array of {Parameter} instances representing this 
       #   method's parameters.
-      # @param return_type [String, nil] A Sorbet string of what this method returns, such as
-      #   +"String"+ or +"T.untyped"+. Passing nil denotes a void return.
+      # @param return_type [Types::TypeLike, nil] What this method returns. Passing nil denotes a void return.
       # @param abstract [Boolean] Whether this method is abstract.
       # @param implementation [Boolean] DEPRECATED: Whether this method is an 
       #   implementation of a parent abstract method.
@@ -82,10 +81,9 @@ module Parlour
       # @return [Array<Parameter>]
       attr_reader :parameters
 
-      sig { returns(T.nilable(String)) }
-      # A Sorbet string of what this method returns, such as "String" or
-      # "T.untyped". Passing nil denotes a void return.
-      # @return [String, nil]
+      sig { returns(T.nilable(Types::TypeLike)) }
+      # What this method returns. Passing nil denotes a void return.
+      # @return [Types::TypeLike, nil]
       attr_reader :return_type
 
       sig { returns(T::Boolean) }
@@ -140,7 +138,7 @@ module Parlour
       # @param options [Options] The formatting options to use.
       # @return [Array<String>] The RBI lines, formatted as specified.
       def generate_rbi(indent_level, options)
-        return_call = return_type ? "returns(#{return_type})" : 'void'
+        return_call = @return_type ? "returns(#{String === @return_type ? @return_type : @return_type.generate_rbi})" : 'void'
         sig_args = final ? '(:final)' : ''
 
         sig_params = parameters.map(&:to_sig_param)
@@ -218,6 +216,13 @@ module Parlour
           " returns #{return_type}"
       end
 
+      sig { override.void }
+      def generalize_from_rbi!
+        @return_type = TypeParser.parse_single_type(@return_type) if String === @return_type
+
+        parameters.each(&:generalize_from_rbi!)
+      end
+
       private
 
       sig do

data/lib/parlour/rbi_generator/module_namespace.rb

@@ -1,13 +1,13 @@
 # typed: true
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # Represents a module definition.
     class ModuleNamespace < Namespace
       extend T::Sig
 
       sig do
         params(
-          generator: RbiGenerator,
+          generator: Generator,
           name: String,
           final: T::Boolean,
           interface: T::Boolean,
@@ -96,6 +96,11 @@ module Parlour
         "Module #{name} - #{"interface, " if interface}#{children.length} " +
           "children, #{includes.length} includes, #{extends.length} extends"
       end
+
+      sig { override.void }
+      def generalize_from_rbi!
+        super
+      end
     end
   end
 end

data/lib/parlour/rbi_generator/namespace.rb

@@ -1,6 +1,6 @@
 # typed: true
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # A generic namespace. This shouldn't be used, except as the type of
     # {RbiGenerator#root}.
     class Namespace < RbiObject
@@ -24,7 +24,7 @@ module Parlour
 
       sig do
         params(
-          generator: RbiGenerator,
+          generator: Generator,
           name: T.nilable(String),
           final: T::Boolean,
           block: T.nilable(T.proc.params(x: Namespace).void)
@@ -77,6 +77,17 @@ module Parlour
         )
       end
 
+      sig { returns(T::Array[RbiGenerator::TypeAlias]) }
+      # The {RbiGenerator::TypeAlias} objects from {children}.
+      # @return [Array<RbiGenerator::TypeAlias>]
+      def aliases
+        T.cast(
+          children.select { |c| c.is_a?(RbiGenerator::TypeAlias) },
+          T::Array[RbiGenerator::TypeAlias]
+        )
+      end
+      alias type_aliases aliases
+
       sig { returns(T::Array[RbiGenerator::Constant]) }
       # The {RbiGenerator::Constant} objects from {children}.
       # @return [Array<RbiGenerator::Constant>]
@@ -196,6 +207,35 @@ module Parlour
         new_enum_class
       end
 
+      sig do
+        params(
+          name: String,
+          final: T::Boolean,
+          props: T.nilable(T::Array[StructProp]),
+          abstract: T::Boolean,
+          block: T.nilable(T.proc.params(x: StructClassNamespace).void)
+        ).returns(StructClassNamespace)
+      end
+      # Creates a new struct class definition as a child of this namespace.
+      #
+      # @example Create a person struct.
+      #   namespace.create_class('Person', props: [
+      #     Parlour::RbiGenerator::StructProp.new('name', 'String')
+      #   ])
+      #
+      # @param name [String] The name of this class.
+      # @param final [Boolean] Whether this namespace is final.
+      # @param props [Array<StructProp>] The props of the struct.
+      # @param abstract [Boolean] A boolean indicating whether this class is abstract.
+      # @param block A block which the new instance yields itself to.
+      # @return [EnumClassNamespace]
+      def create_struct_class(name, final: false, props: nil, abstract: false, &block)
+        new_struct_class = StructClassNamespace.new(generator, name, final, props || [], abstract, &block)
+        move_next_comments(new_struct_class)
+        children << new_struct_class
+        new_struct_class
+      end
+
       sig do
         params(
           name: String,
@@ -231,7 +271,7 @@ module Parlour
         params(
           name: String,
           parameters: T.nilable(T::Array[Parameter]),
-          return_type: T.nilable(String),
+          return_type: T.nilable(Types::TypeLike),
           returns: T.nilable(String),
           abstract: T::Boolean,
           implementation: T::Boolean,
@@ -247,13 +287,13 @@ module Parlour
       #
       # @param name [String] The name of this method. You should not specify +self.+ in
       #   this - use the +class_method+ parameter instead.
-      # @param parameters [Array<Parameter>] An array of {Parameter} instances representing this 
+      # @param parameters [Array<Parameter>] An array of {Parameter} instances representing this
       #   method's parameters.
       # @param return_type [String, nil] A Sorbet string of what this method returns, such as
       #   +"String"+ or +"T.untyped"+. Passing nil denotes a void return.
       # @param returns [String, nil] Same as return_type.
       # @param abstract [Boolean] Whether this method is abstract.
-      # @param implementation [Boolean] DEPRECATED: Whether this method is an 
+      # @param implementation [Boolean] DEPRECATED: Whether this method is an
       #   implementation of a parent abstract method.
       # @param override [Boolean] Whether this method is overriding a parent overridable
       #   method, or implementing a parent abstract method.
@@ -291,7 +331,7 @@ module Parlour
         params(
           name: String,
           kind: Symbol,
-          type: String,
+          type: Types::TypeLike,
           class_attribute: T::Boolean,
           block: T.nilable(T.proc.params(x: Attribute).void)
         ).returns(Attribute)
@@ -347,7 +387,7 @@ module Parlour
       sig do
         params(
           name: String,
-          type: String,
+          type: Types::TypeLike,
           class_attribute: T::Boolean,
           block: T.nilable(T.proc.params(x: Attribute).void)
         ).returns(Attribute)
@@ -368,7 +408,7 @@ module Parlour
       sig do
         params(
           name: String,
-          type: String,
+          type: Types::TypeLike,
           class_attribute: T::Boolean,
           block: T.nilable(T.proc.params(x: Attribute).void)
         ).returns(Attribute)
@@ -389,7 +429,7 @@ module Parlour
       sig do
         params(
           name: String,
-          type: String,
+          type: Types::TypeLike,
           class_attribute: T::Boolean,
           block: T.nilable(T.proc.params(x: Attribute).void)
         ).returns(Attribute)
@@ -498,7 +538,7 @@ module Parlour
         returned_includables
       end
 
-      sig { params(name: String, value: String, block: T.nilable(T.proc.params(x: Constant).void)).returns(Constant) }
+      sig { params(name: String, value: String, eigen_constant: T::Boolean, block: T.nilable(T.proc.params(x: Constant).void)).returns(Constant) }
       # Adds a new constant definition to this namespace.
       #
       # @example Add an +Elem+ constant to the class.
@@ -506,13 +546,16 @@ module Parlour
       #
       # @param name [String] The name of the constant.
       # @param value [String] The value of the constant, as a Ruby code string.
+      # @param eigen_constant [Boolean] Whether this constant is defined on the
+      #   eigenclass of the current namespace.
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Constant]
-      def create_constant(name, value:, &block)
+      def create_constant(name, value:, eigen_constant: false, &block)
         new_constant = RbiGenerator::Constant.new(
           generator,
           name: name,
           value: value,
+          eigen_constant: eigen_constant,
           &block
         )
         move_next_comments(new_constant)
@@ -520,7 +563,7 @@ module Parlour
         new_constant
       end
 
-      sig { params(name: String, type: String, block: T.nilable(T.proc.params(x: Constant).void)).returns(Constant) }
+      sig { params(name: String, type: Types::TypeLike, block: T.nilable(T.proc.params(x: TypeAlias).void)).returns(TypeAlias) }
       # Adds a new type alias, in the form of a constant, to this namespace.
       #
       # @example Add a +MyType+ type alias, to +Integer+, to the class.
@@ -531,7 +574,15 @@ module Parlour
       # @param block A block which the new instance yields itself to.
       # @return [RbiGenerator::Constant]
       def create_type_alias(name, type:, &block)
-        create_constant(name, value: "T.type_alias { #{type} }", &block)
+        new_type_alias = RbiGenerator::TypeAlias.new(
+          generator,
+          name: name,
+          type: type,
+          &block
+        )
+        move_next_comments(new_type_alias)
+        children << new_type_alias
+        new_type_alias
       end
 
       sig do
@@ -544,25 +595,25 @@ module Parlour
       # can be merged into each other, as they lack definitions for themselves,
       # so there is nothing to conflict. (This isn't the case for subclasses
       # such as {ClassNamespace}.)
-      # 
+      #
       # @param others [Array<RbiGenerator::RbiObject>] An array of other {Namespace} instances.
       # @return [true] Always true.
       def mergeable?(others)
         true
       end
 
-      sig do 
+      sig do
         override.overridable.params(
           others: T::Array[RbiGenerator::RbiObject]
         ).void
       end
       # Given an array of {Namespace} instances, merges them into this one.
-      # All children, constants, extends and includes are copied into this 
+      # All children, constants, extends and includes are copied into this
       # instance.
       #
       # There may also be {RbiGenerator::Method} instances in the stream, which
       # are ignored.
-      # 
+      #
       # @param others [Array<RbiGenerator::RbiObject>] An array of other {Namespace} instances.
       # @return [void]
       def merge_into_self(others)
@@ -583,12 +634,17 @@ module Parlour
           "includes, #{extends.length} extends, #{constants.length} constants"
       end
 
+      sig { override.void }
+      def generalize_from_rbi!
+        children.each(&:generalize_from_rbi!)
+      end
+
       private
 
       sig do
         overridable.params(
           indent_level: Integer,
-          options: Options
+          options: Options,
         ).returns(T::Array[String])
       end
       # Generates the RBI lines for the body of this namespace. This consists of
@@ -602,39 +658,71 @@ module Parlour
 
         result += [options.indented(indent_level, 'final!'), ''] if final
 
-        if includes.any? || extends.any? || constants.any?
+        # Split away the eigen constants; these need to be put in a
+        # "class << self" block later
+        eigen_constants, non_eigen_constants = constants.partition(&:eigen_constant)
+        eigen_constants.sort_by!(&:name) if options.sort_namespaces
+
+        if includes.any? || extends.any? || aliases.any? || non_eigen_constants.any?
           result += (options.sort_namespaces ? includes.sort_by(&:name) : includes)
             .flat_map { |x| x.generate_rbi(indent_level, options) }
             .reject { |x| x.strip == '' }
           result += (options.sort_namespaces ? extends.sort_by(&:name) : extends)
             .flat_map { |x| x.generate_rbi(indent_level, options) }
             .reject { |x| x.strip == '' }
-          result += (options.sort_namespaces ? constants.sort_by(&:name) : constants)
+          result += (options.sort_namespaces ? aliases.sort_by(&:name) : aliases)
+            .flat_map { |x| x.generate_rbi(indent_level, options) }
+            .reject { |x| x.strip == '' }
+          result += (options.sort_namespaces ? non_eigen_constants.sort_by(&:name) : non_eigen_constants)
             .flat_map { |x| x.generate_rbi(indent_level, options) }
             .reject { |x| x.strip == '' }
           result << ""
         end
 
         # Process singleton class attributes
-        class_attributes, remaining_children = \
-          (options.sort_namespaces ? children.sort_by(&:name) : children)
-          .partition { |child| child.is_a?(Attribute) && child.class_attribute }
-        
-        if class_attributes.any?
-          result << options.indented(indent_level, 'class << self')
+        sorted_children = (
+          if options.sort_namespaces
+            # sort_by can be unstable (and is in current MRI).
+            # Use the this work around to preserve order for ties
+            children.sort_by.with_index { |child, i| [child.name, i] }
+          else
+            children
+          end
+        )
+        class_attributes, remaining_children = sorted_children.partition do |child|
+          child.is_a?(Attribute) && child.class_attribute
+        end
+
+        # Handle the "class << self block"
+        result << options.indented(indent_level, 'class << self') \
+          if class_attributes.any? || eigen_constants.any?
+
+        if eigen_constants.any?
+          first, *rest = eigen_constants
+          result += T.must(first).generate_rbi(indent_level + 1, options) + T.must(rest)
+            .map { |obj| obj.generate_rbi(indent_level + 1, options) }
+            .map { |lines| [""] + lines }
+            .flatten
+        end
+
+        result << '' if eigen_constants.any? && class_attributes.any?
 
+        if class_attributes.any?
           first, *rest = class_attributes
           result += T.must(first).generate_rbi(indent_level + 1, options) + T.must(rest)
             .map { |obj| obj.generate_rbi(indent_level + 1, options) }
             .map { |lines| [""] + lines }
             .flatten
+        end
+
+        if class_attributes.any? || eigen_constants.any?
           result << options.indented(indent_level, 'end')
           result << ''
         end
 
         first, *rest = remaining_children.reject do |child|
           # We already processed these kinds of children
-          child.is_a?(Include) || child.is_a?(Extend) || child.is_a?(Constant)
+          child.is_a?(Include) || child.is_a?(Extend) || child.is_a?(Constant) || child.is_a?(TypeAlias)
         end
         unless first
           # Remove any trailing whitespace due to includes or class attributes