parlour 2.0.0 → 5.0.0.beta.1

data/lib/parlour/rbi_generator/parameter.rb

@@ -1,6 +1,7 @@
 # typed: true
+require 'rainbow'
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # Represents a method parameter with a Sorbet type signature.
     class Parameter
       extend T::Sig
@@ -8,7 +9,7 @@ module Parlour
       sig do
         params(
           name: String,
-          type: T.nilable(String),
+          type: T.nilable(Types::TypeLike),
           default: T.nilable(String)
         ).void
       end
@@ -42,7 +43,7 @@ module Parlour
 
         @kind = :keyword if kind == :normal && name.end_with?(':')
 
-        @type = type
+        @type = type || 'T.untyped'
         @default = default
       end
 
@@ -80,10 +81,10 @@ module Parlour
         T.must(name[prefix.length..-1])
       end
 
-      sig { returns(T.nilable(String)) }
+      sig { returns(Types::TypeLike) }
       # A Sorbet string of this parameter's type, such as +"String"+ or
       # +"T.untyped"+.
-      # @return [String, nil]
+      # @return [String]
       attr_reader :type
 
       sig { returns(T.nilable(String)) }
@@ -118,8 +119,8 @@ module Parlour
       #
       # @return [String]
       def to_sig_param
-        "#{name_without_kind}: #{type || 'T.untyped'}"
-      end#
+        "#{name_without_kind}: #{String === @type ? @type : @type.generate_rbi}"
+      end
 
       # A mapping of {kind} values to the characteristic prefixes each kind has.
       PREFIXES = {
@@ -128,6 +129,11 @@ module Parlour
         double_splat: '**',
         block: '&'
       }.freeze
+
+      sig { void }
+      def generalize_from_rbi!
+        @type = TypeParser.parse_single_type(@type) if String === @type
+      end
     end
   end
 end

data/lib/parlour/rbi_generator/rbi_object.rb

@@ -1,17 +1,15 @@
 # typed: true
 module Parlour
-  class RbiGenerator
+  class RbiGenerator < Generator
     # An abstract class which is subclassed by any classes which can generate
     # entire lines of an RBI, such as {Namespace} and {Method}. (As an example,
     # {Parameter} is _not_ a subclass because it does not generate lines, only
     # segments of definition and signature lines.)
     # @abstract
-    class RbiObject
-      extend T::Helpers
-      extend T::Sig
+    class RbiObject < TypedObject
       abstract!
-
-      sig { params(generator: RbiGenerator, name: String).void }
+      
+      sig { params(generator: Generator, name: String).void }
       # Creates a new RBI object.
       # @note Don't call this directly.
       #
@@ -19,60 +17,16 @@ module Parlour
       # @param name [String] The name of this module.
       # @return [void]
       def initialize(generator, name)
+        super(name)
         @generator = generator
-        @generated_by = generator.current_plugin
-        @name = name
-        @comments = []
+        @generated_by = RbiGenerator === generator ? generator.current_plugin : nil
       end
 
-      sig { returns(RbiGenerator) }
+      sig { returns(Generator) }
       # The generator which this object belongs to.
-      # @return [RbiGenerator]
+      # @return [Generator]
       attr_reader :generator
 
-      sig { returns(T.nilable(Plugin)) }
-      # The {Plugin} which was controlling the {generator} when this object was
-      # created.
-      # @return [Plugin, nil]
-      attr_reader :generated_by
-
-      sig { returns(String) }
-      # The name of this object.
-      # @return [String]
-      attr_reader :name
-
-      sig { returns(T::Array[String]) }
-      # An array of comments which will be placed above the object in the RBI
-      # file.
-      # @return [Array<String>]
-      attr_reader :comments
-
-      sig { params(comment: T.any(String, T::Array[String])).void }
-      # Adds one or more comments to this RBI object. Comments always go above 
-      # the definition for this object, not in the definition's body.
-      #
-      # @example Creating a module with a comment.
-      #   namespace.create_module('M') do |m|
-      #     m.add_comment('This is a module')
-      #   end
-      #
-      # @example Creating a class with a multi-line comment.
-      #   namespace.create_class('C') do |c|
-      #     c.add_comment(['This is a multi-line comment!', 'It can be as long as you want!'])
-      #   end
-      #
-      # @param comment [String, Array<String>] The new comment(s).
-      # @return [void]
-      def add_comment(comment)
-        if comment.is_a?(String)
-          comments << comment
-        elsif comment.is_a?(Array)
-          comments.concat(comment)
-        end
-      end
-
-      alias_method :add_comments, :add_comment
-
       sig do
         abstract.params(
           indent_level: Integer,
@@ -115,32 +69,19 @@ module Parlour
       # @return [void]
       def merge_into_self(others); end
 
-      sig { abstract.returns(String) }
-      # Returns a human-readable brief string description of this object. This
-      # is displayed during manual conflict resolution with the +parlour+ CLI.
-      #
-      # @abstract
-      # @return [String]
-      def describe; end
-      
-      private
-
-      sig do
-        params(
-          indent_level: Integer,
-          options: Options
-        ).returns(T::Array[String])
+      sig { override.overridable.returns(String) }
+      def describe
+        'RBI object'
       end
-      # Generates the RBI lines for this object's comments.
+
+      sig { abstract.void }
+      # Assuming that the types throughout this object and its children have
+      # been specified as RBI-style types, generalises them into type instances
+      # from the {Parlour::Types} module.
       #
-      # @param indent_level [Integer] The indentation level to generate the lines at.
-      # @param options [Options] The formatting options to use.
-      # @return [Array<String>] The RBI lines for each comment, formatted as specified.
-      def generate_comments(indent_level, options)
-        comments.any? \
-          ? comments.map { |c| options.indented(indent_level, "# #{c}") }
-          : []
-      end
+      # @abstract
+      # @return [void]
+      def generalize_from_rbi!; end
     end
   end
 end

data/lib/parlour/rbi_generator/struct_class_namespace.rb

@@ -0,0 +1,110 @@
+# typed: true
+module Parlour
+  class RbiGenerator
+    # Represents an struct definition; that is, a class which subclasses
+    # +T::Struct+ and declares `prop` members.
+    class StructClassNamespace < ClassNamespace
+      extend T::Sig
+
+      sig do
+        params(
+          generator: Generator,
+          name: String,
+          final: T::Boolean,
+          props: T::Array[StructProp],
+          abstract: T::Boolean,
+          block: T.nilable(T.proc.params(x: StructClassNamespace).void)
+        ).void
+      end
+      # Creates a new struct class definition.
+      # @note You should use {Namespace#create_struct_class} rather than this directly.
+      #
+      # @param generator [RbiGenerator] The current RbiGenerator.
+      # @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 [void]
+      def initialize(generator, name, final, props, abstract, &block)
+        super(generator, name, final, 'T::Struct', abstract, &block)
+        @props = props
+      end
+
+      sig { returns(T::Array[StructProp]) }
+      # The props of the struct.
+      # @return [Array<StructProp>]
+      attr_reader :props
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options,
+        ).returns(T::Array[String])
+      end
+      # Generates the RBI lines for the body of this struct. This consists of
+      # {props}, {includes}, {extends} and {children}.
+      #
+      # @param indent_level [Integer] The indentation level to generate the lines at.
+      # @param options [Options] The formatting options to use.
+      # @return [Array<String>] The RBI lines for the body, formatted as specified.
+      def generate_body(indent_level, options)
+        result = []
+        props.each do |prop|
+          result << options.indented(indent_level, prop.to_prop_call)
+        end
+        result << ''
+
+        result + super
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {StructClassNamespace} instances, returns true if they may
+      # be merged into this instance using {merge_into_self}. For instances to
+      # be mergeable, they must either all be abstract or all not be abstract,
+      # and they must define the same superclass (or none at all).
+      #
+      # @param others [Array<RbiGenerator::RbiObject>] An array of other {StructClassNamespace} instances.
+      # @return [Boolean] Whether this instance may be merged with them.
+      def mergeable?(others)
+        others = T.cast(others, T::Array[Namespace]) rescue (return false)
+        all = others + [self]
+        all_structs = T.cast(all.select { |x| StructClassNamespace === x }, T::Array[StructClassNamespace])
+
+        T.must(super && all_structs.map { |s| s.props.map(&:to_prop_call).sort }.reject(&:empty?).uniq.length <= 1)
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).void
+      end
+      # Given an array of {StructClassNamespace} 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 {StructClassNamespace} instances.
+      # @return [void]
+      def merge_into_self(others)
+        super
+
+        others.each do |other|
+          next unless StructClassNamespace === other
+          other = T.cast(other, StructClassNamespace)
+
+          @props = other.props if props.empty?
+        end
+      end
+
+      sig { override.void }
+      def generalize_from_rbi!
+        super
+
+        props.each(&:generalize_from_rbi!)
+      end
+    end
+  end
+end

data/lib/parlour/rbi_generator/struct_prop.rb

@@ -0,0 +1,139 @@
+# typed: true
+module Parlour
+  class RbiGenerator < Generator
+    # Represents a +T::Struct+ property.
+    class StructProp
+      extend T::Sig
+
+      sig do
+        params(
+          name: String,
+          type: Types::TypeLike,
+          optional: T.nilable(T.any(T::Boolean, Symbol)),
+          enum: T.nilable(String),
+          dont_store: T.nilable(T::Boolean),
+          foreign: T.nilable(String),
+          default: T.nilable(String),
+          factory: T.nilable(String),
+          immutable: T.nilable(T::Boolean),
+          array: T.nilable(String),
+          override: T.nilable(T::Boolean),
+          redaction: T.nilable(String),
+        ).void
+      end
+      # Create a new struct property.
+      #
+      # For documentation on all optional properties, please refer to the
+      # documentation for T::Struct within the sorbet-runtime gem:
+      # https://github.com/sorbet/sorbet/blob/master/gems/sorbet-runtime/lib/types/props/_props.rb#L31-L106
+      #
+      # @param name [String] The name of this property.
+      # @param type [String] This property's type.
+      # @return [void]
+      def initialize(name, type, optional: nil, enum: nil, dont_store: nil,
+        foreign: nil, default: nil, factory: nil, immutable: nil, array: nil,
+        override: nil, redaction: nil)
+        
+        @name = name
+        @type = type
+        @optional = optional
+        @enum = enum
+        @dont_store = dont_store
+        @foreign = foreign
+        @default = default
+        @factory = factory
+        @immutable = immutable
+        @array = array
+        @override = override
+        @redaction = redaction
+      end
+
+      sig { params(other: Object).returns(T::Boolean) }
+      # Returns true if this instance is equal to another instance.
+      #
+      # @param other [Object] The other instance. If this is not a {StructProp} (or a
+      #   subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        StructProp === other &&
+          name       == other.name &&
+          type       == other.type &&
+          optional   == other.optional &&
+          enum       == other.enum &&
+          dont_store == other.dont_store &&
+          foreign    == other.foreign &&
+          default    == other.default &&
+          factory    == other.factory &&
+          immutable  == other.immutable &&
+          array      == other.array &&
+          override   == other.override &&
+          redaction  == other.redaction
+      end
+
+      sig { returns(String) }
+      # The name of this parameter, including any prefixes or suffixes such as
+      # +*+.
+      # @return [String]
+      attr_reader :name
+
+      sig { returns(Types::TypeLike) }
+      # This parameter's type.
+      # @return [Types::TypeLike, nil]
+      attr_reader :type
+
+      sig { returns(T.nilable(T.any(T::Boolean, Symbol))) }
+      attr_reader :optional
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :enum
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :dont_store
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :foreign
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :default
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :factory
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :immutable
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :array
+
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :override
+
+      sig { returns(T.nilable(String)) }
+      attr_reader :redaction
+
+      # The optional properties available on instances of this class.
+      EXTRA_PROPERTIES = %i{
+        optional enum dont_store foreign default factory immutable array override redaction
+      }
+
+      sig { returns(String) }
+      # Returns the +prop+ call required to create this property.
+      # @return [String]
+      def to_prop_call
+        call = "prop :#{name}, #{String === @type ? @type : @type.generate_rbi}"
+
+        EXTRA_PROPERTIES.each do |extra_property|
+          value = send extra_property
+          call += ", #{extra_property}: #{value}" unless value.nil?
+        end
+
+        call
+      end
+
+      sig { void }
+      def generalize_from_rbi!
+        @type = TypeParser.parse_single_type(@type) if String === @type
+      end
+    end
+  end
+end

data/lib/parlour/rbi_generator/type_alias.rb

@@ -0,0 +1,101 @@
+# typed: true
+module Parlour
+  class RbiGenerator < Generator
+    # Represents a type alias.
+    class TypeAlias < RbiObject
+      sig do
+        params(
+          generator: Generator,
+          name: String,
+          type: Types::TypeLike,
+          block: T.nilable(T.proc.params(x: TypeAlias).void)
+        ).void
+      end
+      # Creates a new type alias.
+      #
+      # @param name [String] The name of the alias.
+      # @param value [String] The type to alias to.
+      def initialize(generator, name:, type:, &block)
+        super(generator, name)
+        @type = type
+        yield_self(&block) if block
+      end
+
+      # @return [String] The type to alias to.
+      sig { returns(Types::TypeLike) }
+      attr_reader :type
+
+      sig { params(other: Object).returns(T::Boolean) }
+      # Returns true if this instance is equal to another type alias.
+      #
+      # @param other [Object] The other instance. If this is not a {TypeAlias} (or a
+      #   subclass of it), this will always return false.
+      # @return [Boolean]
+      def ==(other)
+        TypeAlias === other && name == other.name && type == other.type
+      end
+
+      sig do
+        override.params(
+          indent_level: Integer,
+          options: Options
+        ).returns(T::Array[String])
+      end
+      # Generates the RBI lines for this type alias.
+      #
+      # @param indent_level [Integer] The indentation level to generate the lines at.
+      # @param options [Options] The formatting options to use.
+      # @return [Array<String>] The RBI lines, formatted as specified.
+      def generate_rbi(indent_level, options)
+        [options.indented(indent_level,
+          "#{name} = T.type_alias { #{String === @type ? @type : @type.generate_rbi} }"
+        )]
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).returns(T::Boolean)
+      end
+      # Given an array of {TypeAlias} instances, returns true if they may be 
+      # merged into this instance using {merge_into_self}. This is always false.
+      #
+      # @param others [Array<RbiGenerator::RbiObject>] An array of other
+      #   {TypeAlias} instances.
+      # @return [Boolean] Whether this instance may be merged with them.
+      def mergeable?(others)
+        others.all? { |other| self == other }
+      end
+
+      sig do
+        override.params(
+          others: T::Array[RbiGenerator::RbiObject]
+        ).void
+      end
+      # Given an array of {TypeAlias} instances, merges them into this one.
+      # This particular implementation will simply do nothing, as instances
+      # are only mergeable if they are indentical.
+      # You MUST ensure that {mergeable?} is true for those instances.
+      #
+      # @param others [Array<RbiGenerator::RbiObject>] An array of other
+      #   {TypeAlias} instances.
+      # @return [void]
+      def merge_into_self(others)
+        # We don't need to change anything! We only merge identical type alias
+      end
+
+      sig { override.returns(String) }
+      # Returns a human-readable brief string description of this code.
+      #
+      # @return [String]
+      def describe
+        "Type Alias (#{name} = #{type})"
+      end
+
+      sig { override.void }
+      def generalize_from_rbi!
+        @type = TypeParser.parse_single_type(@type) if String === @type
+      end
+    end
+  end
+end